Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345678910]

CROOT::Detail::__integer_sequence< _IdxType, _Values >
CROOT::Detail::__make< 0 >
CROOT::Detail::__make< 1 >
CROOT::Detail::__make< 2 >
CROOT::Detail::__make< 3 >
CROOT::Detail::__make< 4 >
CROOT::Detail::__make< 5 >
CROOT::Detail::__make< 6 >
CROOT::Detail::__make< 7 >
Cstd::__make_integer_sequence_checked< _Tp, _Ep >
CROOT::Detail::__parity< _Np >
CROOT::Detail::__parity< 0 >
CROOT::Detail::__parity< 1 >
CROOT::Detail::__parity< 2 >
CROOT::Detail::__parity< 3 >
CROOT::Detail::__parity< 4 >
CROOT::Detail::__parity< 5 >
CROOT::Detail::__parity< 6 >
CROOT::Detail::__parity< 7 >
CROOT::Detail::__repeat< _Tp, _Extra >
CROOT::Detail::__repeat< __integer_sequence< _Tp, _Np... >, _Extra... >
►CROOT::Detail::__repeat< __make< _Np/8 >::type >
CROOT::Detail::__parity< 0 >::__pmake< _Np >
►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 1 >
CROOT::Detail::__parity< 1 >::__pmake< _Np >
►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 2, _Np - 1 >
CROOT::Detail::__parity< 2 >::__pmake< _Np >
►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 3, _Np - 2, _Np - 1 >
CROOT::Detail::__parity< 3 >::__pmake< _Np >
►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1 >
CROOT::Detail::__parity< 4 >::__pmake< _Np >
►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1 >
CROOT::Detail::__parity< 5 >::__pmake< _Np >
►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1 >
CROOT::Detail::__parity< 6 >::__pmake< _Np >
►CROOT::Detail::__repeat< __make< _Np/8 >::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1 >
CROOT::Detail::__parity< 7 >::__pmake< _Np >
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)
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)
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 >
CROOT::Minuit2::ABSum< M1, M2 >
CTMVA::AbsValue
CROOT::Experimental::Internal::TUniWeakPtr< T >::Accessor	Gives transparent access to the shared or unique pointer
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::Type< Internal::TStdBitsetHelper< Bitset_t > >
CROOT::Detail::TCollectionProxyInfo::Pushback< Internal::TStdBitsetHelper< Bitset_t > >
►CROOT::Detail::TCollectionProxyInfo::Address< std::vector< Bool_t >::const_reference >
►CROOT::Detail::TCollectionProxyInfo::Type< std::vector< Bool_t > >
CROOT::Detail::TCollectionProxyInfo::Pushback< std::vector< bool > >
►CROOT::Detail::TCollectionProxyInfo::Address< TYPENAME T::const_reference >
►CROOT::Detail::TCollectionProxyInfo::Type< T >	Small helper to encapsulate basic data accesses for all STL continers
CROOT::Detail::TCollectionProxyInfo::Insert< T >	Small helper to encapsulate all necessary data accesses for containers like set, multiset etc
CROOT::Detail::TCollectionProxyInfo::MapInsert< T >	Small helper to encapsulate all necessary data accesses for containers like set, multiset etc
CROOT::Detail::TCollectionProxyInfo::Pushback< T >	Small helper to encapsulate all necessary data accesses for containers like vector, list, deque
CROOT::Detail::TCollectionProxyInfo::Pushfront< T >	Small helper to encapsulate all necessary data accesses for containers like forward_list
Cnlohmann::adl_serializer< typename, typename >	Default JSONSerializer template argument
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 >
CRooAbsCachedPdf::AnaIntConfig	Registry for analytical integration codes
CRooMultiVarGaussian::AnaIntData
►Cstd::array< T >	STL class
CROOT::Experimental::Hist::TCoordArray< DIMENSIONS >
CRooStats::HistFactory::Asimov
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 assigment 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::AssignSym	Force Expression evaluation from general to symmetric
CTExMap::Assoc_t
CROOT::MacOSX::Util::AutoreleasePool
CROOT::Math::AxisAngle	AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis
CROOT::Experimental::Internal::AxisConfigToType< EKind >	Converts a TAxisConfig of whatever kind to the corresponding TAxisBase-derived object
CROOT::Experimental::Internal::AxisConfigToType< TAxisConfig::kEquidistant >
CROOT::Experimental::Internal::AxisConfigToType< TAxisConfig::kGrow >
CROOT::Experimental::Internal::AxisConfigToType< TAxisConfig::kIrregular >
CROOT::Experimental::Internal::AxisConfigToType< TAxisConfig::kLabels >
►CB1
Cnlohmann::detail::conjunction< B1 >
CBalancerInfo
CRooStats::HistFactory::RooBarlowBeestonLL::BarlowCache
►CROOT::Math::BaseIntegratorOptions	Base 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::IntegratorMultiDimOptions	Numerical multi dimensional integration options
CROOT::Math::IntegratorOneDimOptions	Numerical one dimensional integration options
►CROOT::Math::KDTree< _DataPoint >::BaseNode
►CROOT::Math::KDTree< _DataPoint >::BinNode
CROOT::Math::KDTree< _DataPoint >::TerminalNode
CROOT::Math::KDTree< _DataPoint >::HeadNode
CROOT::Math::KDTree< _DataPoint >::SplitNode
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >	Class to store JSON values
Cbasic_string_view< _CharT, _Traits >
CROOT::Minuit2::BasicFunctionGradient
CROOT::Minuit2::BasicFunctionMinimum	Result of the minimization; both internal and external (MnUserParameterState) representation available For the parameters at the Minimum
CROOT::Minuit2::BasicMinimumError	Internal Class containing the error information on the estimated minimum : Error matrix + dcovar + additional flags for quality and validity checks
CROOT::Minuit2::BasicMinimumParameters
CROOT::Minuit2::BasicMinimumSeed
CROOT::Minuit2::BasicMinimumState
CBasicRNNLayer	Generic implementation
CTTreePerfStats::BasketInfo
CTMVA::DNN::Batch	Encapsulates one mini-batch
CTMVA::BDTEventWrapper
CRooStats::BernsteinCorrection	BernsteinCorrection is a utility in RooStats to augment a nominal PDF with a polynomial correction term
CROOT::Minuit2::BFGSMinimizerType
CROOT::Minuit2::VariableMetricMinimizer::BFGSType
CBidirMMapPipe	BidirMMapPipe creates a bidirectional channel between the current process and a child it forks
►Cbinary_function
CMemstat::SFind_t
CTMVA::compose_binary_t< F, G, H >
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
CBinaryOpPolicy
►CTMVA::BinaryTree	Base class for BinarySearch and Decision Trees
CTMVA::BinarySearchTree	A simple Binary search tree including a volume search method
CTMVA::DecisionTree	Implementation of a Decision Tree
CROOT::R::TRDataFrame::Binding
CROOT::R::TRInterface::Binding
CTMVA::OptionMap::Binding
CBinomialNeymanInterval< Sorter >
►CBinomialNeymanInterval< FeldmanCousinsSorter >
CFeldmanCousinsBinomialInterval
CBinomialProbHelper
CRooMultiVarGaussian::BitBlock
CROOT::Math::GenVector_detail::BitReproducible
CTEveParamList::BoolConfig_t
CROOT::Math::Boost	Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix
CROOT::Math::BoostX	Class representing a Lorentz Boost along the X axis, by beta
CROOT::Math::BoostY	Class representing a Lorentz Boost along the Y axis, by beta
CROOT::Math::BoostZ	Class representing a Lorentz Boost along the Z axis, by beta
CRgl::Pad::BoundingRect< ValueType >
CROOT::Experimental::TPadBase::BoundKindAndValue	Simple struct representing an axis bound
CRooNDKeysPdf::BoxInfo
CTGeoBatemanSol::BtCoef_t
►CRooSimWSTool::BuildConfig
CRooSimWSTool::MultiBuildConfig
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 >
CTInterpreter::CallFuncIFacePtr_t
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< Scalar >
CRooVectorDataStore::CatVector
CTMVA::CCPruner	A 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
►CTEveCaloData::CellGeom_t	Cell geometry inner structure
CTEveCaloData::CellData_t	Cell data inner structure
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
CROOT::Quartz::CGStateGuard
CRooStats::HistFactory::Channel
CROOT::Math::ChebyshevApprox	Class describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials
CROOT::Math::ChebyshevPol
Cstd::__ROOT::check_bound_t
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 >
►Cclass_
CROOT::R::class_< T >
CROOT::Meta::Selection::ClassAttributes< classAttributes >	Used to specify attributes of classes in the "DictSelection" syntax
CRooWorkspace::CodeRepo::ClassFiles
CTMVA::Classification	Class to perform two class classification
CTMVA::ClassificationResult	Class to save the results of the classifier
CTMVA::ClassifierFactory	This is the MVA factory
CRooWorkspace::CodeRepo::ClassRelInfo
Cclient_cert
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 >
CXrdClientConnectionMgr::CndVarInfo
CROOT::MacOSX::Details::CocoaPrivate
CROOT::MacOSX::X11::ColorParser
CColorStruct_t
CTFITSHDU::Column
►CROOT::MacOSX::X11::Command
CROOT::MacOSX::X11::ClearArea
CROOT::MacOSX::X11::CopyArea
CROOT::MacOSX::X11::DeletePixmap
CROOT::MacOSX::X11::DrawBoxXor
CROOT::MacOSX::X11::DrawLine
CROOT::MacOSX::X11::DrawLineXor
CROOT::MacOSX::X11::DrawRectangle
CROOT::MacOSX::X11::DrawSegments
CROOT::MacOSX::X11::DrawString
CROOT::MacOSX::X11::FillPolygon
CROOT::MacOSX::X11::FillRectangle
CROOT::MacOSX::X11::UpdateWindow
CROOT::MacOSX::X11::CommandBuffer
CCompareAsc< T >
CcompareBAasc
CcompareBAdesc
CCompareDesc< T >
CTTreeCloner::CompareEntry
CROOT::Math::KDTree< _DataPoint >::ComparePoints
CTTreeCloner::CompareSeek
CROOT::Math::CompileTimeChecker< bool >
CROOT::Math::CompileTimeChecker< false >
CTMVA::Config	Singleton class for global configuration settings used by TMVA
CRooStats::HistFactory::ConfigParser
CROOT::Math::Constant< T >	Constant expression class A class representing constant expressions (literals) in the parse tree
CContDist	Free functions adapter needed by UNURAN for onedimensional continuous distributions
CContext	Small helper to keep current directory context
CROOT::Minuit2::ContoursError
►CTMVA::ConvergenceTest	Check for convergence
CTMVA::MethodMLP	Multilayer Perceptron class built off of MethodANNBase
CROOT::Experimental::TPadLength::CoordSysBase< DERIVED >
►CROOT::Experimental::TPadLength::CoordSysBase< Normal >
CROOT::Experimental::TPadLength::Normal	A normalized coordinate: 0 in the left, bottom corner, 1 in the top, right corner of the TPad
►CROOT::Experimental::TPadLength::CoordSysBase< Pixel >
CROOT::Experimental::TPadLength::Pixel	A pixel coordinate: 0 in the left, bottom corner, 1 in the top, right corner of the TPad
►CROOT::Experimental::TPadLength::CoordSysBase< User >
CROOT::Experimental::TPadLength::User	A user coordinate, as defined by the EUserCoordSystem parameter of the TPad
CCpuInfo_t
CROOT::Minuit2::MnCross::CrossFcnLimit
CROOT::Minuit2::MnCross::CrossNewMin
CROOT::Minuit2::MnCross::CrossParLimit
CTMVA::CrossValidationFoldResult
CTMVA::CrossValidationResult	Class 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
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
CRooStats::HistFactory::Data
CROOT::Fit::DataOptions	DataOptions : simple structure holding the options on how the data are filled
CROOT::Fit::DataRange	Class describing the range in the coordinates it supports multiple range in a coordinate
CROOT::Math::GenVector_detail::BitReproducible::DB8
CDebuggingSampler	DebuggingSampler is a simple implementation of the DistributionCreator interface used for debugging
CDebuggingTestStat	DebuggingTestStat is a simple implementation of the DistributionCreator interface used for debugging
CROOT::Math::DefaultCoordinateSystemTag	DefaultCoordinateSystemTag Default tag for identifying any coordinate system
CROOT::Math::Delaunay2D	Class to generate a Delaunay triangulation of a 2D set of points
CTMVA::DeleteFunctor_t< T >
CROOT::Math::Derivator	Class for computing numerical derivative of a function
►CDerivFunType
►CROOT::Math::BasicFitMethodFunction< DerivFunType >
►CROOT::Fit::BasicFCN< DerivFunType, ModelFunType, BinData >
CROOT::Fit::Chi2FCN< DerivFunType, ModelFunType >	Chi2FCN class for binnned fits using the least square methods
CROOT::Fit::PoissonLikelihoodFCN< DerivFunType, ModelFunType >	Class evaluating the log likelihood for binned Poisson likelihood fits it is template to distinguish gradient and non-gradient case
►CROOT::Fit::BasicFCN< DerivFunType, ModelFunType, UnBinData >
CROOT::Fit::LogLikelihoodFCN< DerivFunType, ModelFunType >	LogLikelihoodFCN class for likelihood fits
CROOT::Fit::BasicFCN< DerivFunType, ModelFunType, DataType >	BasicFCN class: base class for the objective functions used in the fits It has a reference to the data and th emodel function used in the fit
CTKSocket::Desc_t
CROOT::Internal::TThreadedObjectUtils::Detacher< T, ISHISTO >
CROOT::Internal::TThreadedObjectUtils::Detacher< T, true >
CRooStats::DetailedOutputAggregator	This 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
►CTEveDigitSet::DigitBase_t
►CTEveBoxSet::BCone_t
CTEveBoxSet::BEllipticCone_t
►CTEveBoxSet::BOrigin_t
CTEveBoxSet::BAABox_t
CTEveBoxSet::BAABoxFixedDim_t
►CDigitBase_t
CTEveBoxSet::BFreeBox_t
CTEveQuadSet::QFreeQuad_t
►CTEveQuadSet::QOrigin_t
CTEveQuadSet::QHex_t
CTEveQuadSet::QLineFixC_t
►CTEveQuadSet::QRectFixDimC_t
CTEveQuadSet::QRectFixC_t
►CTEveQuadSet::QRectFixDim_t
CTEveQuadSet::QRect_t
CRooMomentMorphFuncND::Digits< T >
CROOT::Internal::TThreadedObjectUtils::DirCreator< T, ISHISTO >
CROOT::Internal::TThreadedObjectUtils::DirCreator< T, true >
CDiscrDist	Free functions adapter needed by UNURAN for one-dimensional discrete distribution
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< Scalar > >
CROOT::Math::DisplacementVector3D< Cartesian3D< T >, DefaultCoordinateSystemTag >
►CROOT::Math::DistSampler	Interface class for generic sampling of a distribution, i.e
CTFoamSampler	TFoamSampler class class implementing the ROOT::Math::DistSampler interface using FOAM for sampling arbitrary distributions
CTUnuranSampler	TUnuranSampler class class implementing the ROOT::Math::DistSampler interface using the UNU.RAN package for sampling distributions
CROOT::Math::DistSamplerOptions	DistSampler options class
CROOT::Math::DivOp< T >	Division (element-wise) Operation Class
CTHtml::DocEntityInfo_t
CTHtml::DocSyntax_t
CTGLScene::DrawElement_t
CRooPlot::DrawOpt
CTMVA::DTNodeTrainingInfo
CROOT::Fit::DummyDeleter< T >
CTEveGeoPolyShape::Edge_t
CTEvePolygonSetProjectedGL::Edge_t
CTBranchSTL::ElementBranchHelper_t
►Cenable_shared_from_this
►CTObjLink	Wrapper around a TObject so it can be stored in a TList
CTObjOptLink
CRooMappedCategory::Entry
CTTreeCache::MissCache::Entry
CROOT::Internal::EntryCluster	A cluster of entries
►CROOT::Detail::TCollectionProxyInfo::EnvironBase
CROOT::Detail::TCollectionProxyInfo::Environ< T >	Small helper to save proxy environment in the event of recursive calls
CROOT::Math::gv_detail::ERROR_This_Rotation_Conversion_is_NOT_Supported
CROOT::Math::EulerAngles	EulerAngles class describing rotation as three angles (Euler Angles)
CRooAbsReal::EvalError
CROOT::Fit::FitUtil::Evaluate< T >
CROOT::Math::EvaluatorOneDim< MultiFuncType >
CROOT::Math::EvaluatorOneDim< const ROOT::Math::IParamMultiFunction & >
CTMVA::kNN::Event
CEvent_t
CTMVA::QuickMVAProbEstimator::EventInfo
CTMVA::DataSetFactory::EventStats
CROOT::MacOSX::X11::EventTranslator
►Cstd::exception	STL class
CPyROOT::TPyException
CRooStats::HistFactory::hf_exc
CROOT::Experimental::TDirectoryTypeMismatch	Objects of this class are thrown to signal that the value known under the given name
CROOT::Experimental::TDirectoryUnknownKey	Objects of this class are thrown to signal that no key with that name exists
CROOT::Math::GenVector_detail::BitReproducibleException
►Cstd::runtime_error	STL class
CROOT::Math::GenVector_exception
CTEveException	Exception class thrown by TEve classes and macros
CExceptionContext_t
CRooExpensiveObjectCache::ExpensiveObject
CRcpp::traits::Exporter< std::array< T, i > >
CROOT::Math::Expr< ExprType, T, D, D2, R1 >
Cnlohmann::detail::external_constructor< value_t >
Cnlohmann::detail::external_constructor< value_t::array >
Cnlohmann::detail::external_constructor< value_t::boolean >
Cnlohmann::detail::external_constructor< value_t::number_float >
Cnlohmann::detail::external_constructor< value_t::number_integer >
Cnlohmann::detail::external_constructor< value_t::number_unsigned >
Cnlohmann::detail::external_constructor< value_t::object >
Cnlohmann::detail::external_constructor< value_t::string >
CRooWorkspace::CodeRepo::ExtraHeader
CROOT::Math::Fabs< T >	Unary abs Operation Class
CROOT::Math::Factory	Factory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager
►Cfalse_type
Cnlohmann::detail::is_compatible_integer_type_impl< bool, typename, typename >
Cnlohmann::detail::is_compatible_object_type_impl< B, RealType, CompatibleObjectType >
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
CFileStat_t
CRgl::Pad::FillAttribSet
CROOT::Fit::FitConfig	Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::ParameterSettings class
►CROOT::Fit::FitData	Base class for all the fit data types: Stores the coordinates and the DataOptions
CROOT::Fit::BinData	Class describing the binned data sets : vectors of x coordinates, y values and optionally error on y values and error on coordinates The dimension of the coordinate is free There are 4 different options:
CROOT::Fit::SparseData
CROOT::Fit::UnBinData	Class describing the unbinned data sets (just x coordinates values) of any dimensions
►CROOT::Fit::FitResult	Class containg 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
CTFitResult	Extends the ROOT::Fit::Result class with a TNamed inheritance providing easy possibility for I/O
CROOT::Fit::Fitter	Fitter class, entry point for performing all type of fits
CTEveParamList::FloatConfig_t
CFontAttributes_t
CROOT::MacOSX::Details::FontCache
CROOT::MacOSX::Details::FontCache::FontList
CFontMetrics_t
CTGFontDialog::FontProp_t
CFoption_t
CTLatex::FormSize_t	TLatex helper struct holding the dimensions of a piece of text
Cnlohmann::detail::from_json_fn
►CFuncCacheElem
CRooNumRunningInt::RICacheElem
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	TF1Convolution object
Cfuncptr_and_voidptr_t
CROOT::Minuit2::FunctionGradient
►CROOT::Minuit2::FunctionMinimizer	Base class for function minimizers; user may give FCN or FCN with Gradient, Parameter starting values and initial Error guess (sigma) (or "step size"), or Parameter starting values and initial covariance matrix; covariance matrix is stored in Upper triangular packed storage format, e.g
►CROOT::Minuit2::ModularFunctionMinimizer	Base 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
CROOT::Minuit2::CombinedMinimizer	Combined minimizer: combination of Migrad and Simplex
CROOT::Minuit2::FumiliMinimizer	Instantiates the seed generator and Minimum builder for the Fumili minimization method
CROOT::Minuit2::ScanMinimizer	Class implementing the required methods for a minimization using SCAN API is provided in the upper ROOT::Minuit2::ModularFunctionMinimizer class
CROOT::Minuit2::SimplexMinimizer	Class implementing the required methods for a minimization using Simplex
CROOT::Minuit2::VariableMetricMinimizer	Instantiates the SeedGenerator and MinimumBuilder for Variable Metric Minimization method
CROOT::Minuit2::FunctionMinimum	Class holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum
CTClassEdit::FunctionSplitInfo	Result of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters)
CRooRandomizeParamMCSModule::GausParam
CRooRandomizeParamMCSModule::GausParamSet
CGcCache_t
CGCValues_t
CROOT::Minuit2::gen
CRooMultiVarGaussian::GenData
CROOT::Math::GeneralLinearFunctionDerivation< T >	Auxiliar class to bypass the (provisional) lack of vectorization in TFormula::EvalPar
CROOT::Math::GeneralLinearFunctionDerivation< double >
CROOT::Experimental::Internal::TVirtualCanvasPainter::Generator
►CROOT::Minuit2::GenericFunction	Class from which all the other classes, representing functions, inherit
►CROOT::Minuit2::FCNBase	Interface (abstract class) defining the function to be minimized, which has to be implemented by the user
CROOT::Minuit2::FCNAdapter< Function >	Template wrapped class for adapting to FCNBase signature
►CROOT::Minuit2::FCNGradientBase	Extension of the FCNBase for providing the analytical Gradient of the function
CROOT::Minuit2::FCNGradAdapter< Function >	Template wrapped class for adapting to FCNBase signature a IGradFunction
►CROOT::Minuit2::FumiliFCNBase	Extension of the FCNBase for the Fumili method
►CROOT::Minuit2::FumiliChi2FCN	Extension of the FCNBase for the Fumili method
CROOT::Minuit2::FumiliStandardChi2FCN	Class implementing the standard chi square function, which is the sum of the squares of the figures-of-merit calculated for each measurement point, the individual figures-of-merit being: (the Value predicted by the model-measured Value)/standard deviation
CROOT::Minuit2::FumiliFCNAdapter< Function >	Template wrapped class for adapting to FumiliFCNBase signature
►CROOT::Minuit2::FumiliMaximumLikelihoodFCN	Extension of the FCNBase for the Fumili method
CROOT::Minuit2::FumiliStandardMaximumLikelihoodFCN	Class implementing the Elements member function for the standard maximum likelihood method
CROOT::Minuit2::ParametricFunction	Function which has parameters
CTMVA::GeneticAlgorithm	Base definition for genetic algorithm
CTMVA::GeneticGenes	Cut optimisation interface class for genetic algorithm
CROOT::Math::GeneticMinimizerParameters
CTMVA::GeneticPopulation	Population definition for genetic algorithm
CTMVA::GeneticRange	Range definition for genetic algorithm
CRooAbsPdf::GenSpec
CROOT::Internal::GetFunctorType< T >
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 *)>
CTLeaf::GetValueHelper< T >
CTFormLeafInfo::GetValueHelper< T >
CTLeaf::GetValueHelper< Long64_t >
CTFormLeafInfo::GetValueHelper< Long64_t >
CTLeaf::GetValueHelper< LongDouble_t >
CTFormLeafInfo::GetValueHelper< LongDouble_t >
CTLeaf::GetValueHelper< ULong64_t >
CTFormLeafInfo::GetValueHelper< ULong64_t >
CRgl::Pad::GLLimits
CROOT::Math::GlobalCoordinateSystemTag	Tag for identifying vectors based on a global coordinate system
CROOT::Math::GoFTest
►CROOT::Minuit2::GradientCalculator	Interface class for gradient calculators
CROOT::Minuit2::AnalyticalGradientCalculator
CROOT::Minuit2::FumiliGradientCalculator
CROOT::Minuit2::HessianGradientCalculator	HessianGradientCalculator: class to calculate Gradient for Hessian
CROOT::Minuit2::InitialGradientCalculator	Class to calculate an initial estimate of the gradient
CROOT::Minuit2::Numerical2PGradientCalculator	Class performing the numerical gradient calculation
CRooMomentMorphND::Grid
CRooMomentMorphFuncND::Grid2
Cgroup
CROOT::Experimental::TAxisConfig::Grow_t	Tag type signalling that an axis should be able to grow; used for calling the appropriate constructor
CROOT::Math::GSL1DMinimizerWrapper	Wrapper class for gsl_min_fminimizer structure
CROOT::Math::GSLChebSeries	Wrapper class for C struct gsl_cheb_series
CROOT::Math::GSLDerivator	Class 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::GSLFunctionAdapter< UserFunc >	Class for adapting any C++ functor class to C function pointers used by GSL
CROOT::Math::GSLFunctionDerivWrapper	Class to wrap a gsl_function_fdf (with derivatives)
CROOT::Math::GSLFunctionWrapper	Wrapper class to the gsl_function C structure
CROOT::Math::GSLIntegrationWorkspace
CROOT::Math::GSLInterpolator	Interpolation class based on GSL interpolation functions
►CROOT::Math::GSLMCIntegrationWorkspace
CROOT::Math::GSLMiserIntegrationWorkspace	Workspace for MISER
CROOT::Math::GSLPlainIntegrationWorkspace
CROOT::Math::GSLVegasIntegrationWorkspace	Workspace for VEGAS
CROOT::Math::GSLMonteFunctionAdapter< UserFunc >
CROOT::Math::GSLMonteFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm
CROOT::Math::GSLMultiFit	GSLMultiFit, 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::GSLMultiFitFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
CROOT::Math::GSLMultiMinDerivFunctionWrapper	Wrapper 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::GSLMultiMinFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
CROOT::Math::GSLMultiMinimizer	GSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives
►CROOT::Math::GSLMultiRootBaseSolver	GSLMultiRootBaseSolver, 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::GSLMultiRootDerivSolver	GSLMultiRootDerivSolver, internal class for implementing GSL multi-root finders using derivatives
CROOT::Math::GSLMultiRootSolver	GSLMultiRootSolver, internal class for implementing GSL multi-root finders not using derivatives
CROOT::Math::GSLMultiRootDerivFunctionWrapper	Wrapper to a multi-dim function with derivatives for multi roots algorithm
CROOT::Math::GSLMultiRootFinder	Class 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::GSLMultiRootFunctionWrapper	Wrapper to a multi-dim function without derivatives for multi roots algorithm
CROOT::Math::GSLQRngWrapper	GSLQRngWrapper class to wrap gsl_qrng structure
►CROOT::Math::GSLQuasiRandomEngine	GSLQuasiRandomEngine 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::GSLQRngNiederreiter2	Niederreiter generator gsl_qrng_niederreiter_2 from here
CROOT::Math::GSLQRngSobol	Sobol generator gsl_qrng_sobol from here
►CROOT::Math::GSLRandomEngine	GSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator
CROOT::Math::GSLRngCMRG	Combined multiple recursive generator (L'Ecuyer) see here
CROOT::Math::GSLRngGFSR4	Lagged Fibonacci generator by Ziff see here
CROOT::Math::GSLRngMinStd	MINSTD generator (Park and Miller) see here
CROOT::Math::GSLRngMixMax	MixMax generator based on ROOT::Math::MixMaxEngine of N=240
CROOT::Math::GSLRngMRG	5-th order multiple recursive generator (L'Ecuyer, Blouin and Coutre) see here
CROOT::Math::GSLRngMT	Mersenne-Twister generator gsl_rng_mt19937 from here
CROOT::Math::GSLRngRand	BSD rand() generator gsl_rmg_rand from here
CROOT::Math::GSLRngRanLux	Old Ranlux generator (James, Luscher) (default luxury level, p = 223) (This is eequivalent to TRandom1 with default luxury level) see here
CROOT::Math::GSLRngRanLuxD1	Double precision (48 bits) version of Second generation of Ranlux generator with luxury level of 1 (It throws away 202 value for every 12 used) see here
CROOT::Math::GSLRngRanLuxD2	Double precision (48 bits) version of Second generation of Ranlux generator with luxury level of 2 (It throws away 397 value for every 12 used) see here
CROOT::Math::GSLRngRanLuxS1	Second generation of Ranlux generator for single precision with luxury level of 1 (It throws away 202 values for every 12 used) see here
CROOT::Math::GSLRngRanLuxS2	Second generation of Ranlux generator for Single precision with luxury level of 2 (It throws away 397 value for every 12 used) see here
CROOT::Math::GSLRngRanMar	RANMAR generator see here
CROOT::Math::GSLRngTaus	Tausworthe generator by L'Ecuyer see here
CROOT::Math::GSLRngROOTWrapper< Engine >
CROOT::Math::GSLRngWrapper	GSLRngWrapper class to wrap gsl_rng structure
CROOT::Math::GSLRootFdFSolver	Root-Finder with derivatives implementation class using GSL
CROOT::Math::GSLRootFSolver	Root-Finder implementation class using GSL
CROOT::Math::GSLSimAnFunc	GSLSimAnFunc class description
CROOT::Math::GSLSimAnnealing	GSLSimAnnealing class for performing a simulated annealing search of a multidimensional function
CROOT::Math::GSLSimAnParams	Structure holding the simulated annealing parameters
CRooRandom::Guard
Cnlohmann::detail::has_from_json< BasicJsonType, T >
Cnlohmann::detail::has_non_default_from_json< BasicJsonType, T >
Cnlohmann::detail::has_to_json< BasicJsonType, T >
CROOT::TypeTraits::HasBeginAndEnd< T >
Cstd::hash< nlohmann::json >	Hash value for JSON objects
CROOT::Internal::RConcurrentHashColl::HashValue
CTFITSHDU::HDURecord
CTEveTrackPropagator::Helix_t
CHelperOps
CHEPEVT_DEF	HEPEVT common block
CRooStats::HistFactory::HistFactoryNavigation
CRooStats::HistFactory::HistoFactor
CRooStats::HistFactory::HistoSys
CRooStats::HistFactory::HistRef
CHoption_t	Histogram option structure
CHparam_t	Histogram parameters structure
CTMVA::HyperParameterOptimisationResult
►CRooStats::HypoTestCalculator	HypoTestCalculator is an interface class for a tools which produce RooStats HypoTestResults
►CRooStats::CombinedCalculator	CombinedCalculator is an interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals
CRooStats::ProfileLikelihoodCalculator	ProfileLikelihoodCalculator is a concrete implementation of CombinedCalculator (the interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals)
CRooStats::HybridCalculatorOriginal	HybridCalculatorOriginal class
►CRooStats::HypoTestCalculatorGeneric	Common base class for the Hypothesis Test Calculators
CRooStats::AsymptoticCalculator	Hypothesis Test Calculator based on the asymptotic formulae for the profile likelihood ratio
CRooStats::FrequentistCalculator	Does a frequentist hypothesis test
CRooStats::HybridCalculator	Same purpose as HybridCalculatorOriginal, but different implementation
►CIBaseFunc
CROOT::Math::FunctorImpl< IBaseFunc >	FunctorImpl is a base class for the functor handler implementation class
►CROOT::Math::IBaseFunctionMultiDimTempl< T >	Documentation for the abstract class IBaseFunctionMultiDim
►CROOT::Math::IParametricFunctionMultiDimTempl< double >
CROOT::Math::MultiDimParamFunctionAdapter	MultiDimParamFunctionAdapter class to wrap a one-dimensional parametric function in a multi dimensional parameteric function interface This is used typically in fitting where internally the function is stored as multidimension
CRooMinimizerFcn
CRooMultiGenFunction	Lightweight interface adaptor that exports a RooAbsReal as a ROOT::Math::IMultiGenFunction
CROOT::Fit::FcnAdapter
CROOT::Math::Functor	Documentation for class Functor class
►CROOT::Math::IGradientFunctionMultiDimTempl< T >	Interface (abstract class) for multi-dimensional functions providing a gradient calculation
CROOT::Math::GradFunctor	GradFunctor class for Multidimensional gradient functions
CROOT::Math::LSResidualFunc	LSResidualFunc class description
CROOT::Math::MinimTransformFunction	MinimTransformFunction class to perform a transformations on the variables to deal with fixed or limited variables (support both double and single bounds) The class manages the passed function pointer
CROOT::Math::MultiNumGradFunction	MultiNumGradFunction class to wrap a normal function in a gradient function using numerical gradient calculation provided by the class Derivator (based on GSL numerical derivation)
CTPyMultiGradFunction
►CROOT::Math::IParametricFunctionMultiDimTempl< T >	IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam
►CROOT::Math::IParametricGradFunctionMultiDimTempl< T >	Interface (abstract class) for parametric gradient multi-dimensional functions providing in addition to function evaluation with respect to the coordinates also the gradient with respect to the parameters, via the method ParameterGradient
CROOT::Math::MultiDimParamGradFunctionAdapter	MultiDimParamGradFunctionAdapter class to wrap a one-dimensional parametric gradient function in a multi dimensional parameteric gradient function interface This is used typically in fitting where internally the function is stored as multidimension
CROOT::Math::WrappedMultiTF1Templ< T >	Class to Wrap a ROOT Function class (like TF1) in a IParamMultiFunction interface of multi-dimensions to be used in the ROOT::Math numerical algorithm
CROOT::Math::WrappedParamFunction< FuncPtr >	WrappedParamFunction class to wrap any multi-dimensional function pbject implementing the operator()(const double * x, const double * p) in an interface-like IParamFunction with a vector storing and caching internally the parameter values
CROOT::Math::WrappedParamFunctionGen< FuncPtr >	WrappedParamGenFunction class to wrap any multi-dimensional function implementing the operator()(const double * ) in an interface-like IParamFunction, by fixing some of the variables and define them as parameters
CROOT::Math::WrappedMemMultiFunction< FuncObj, MemFuncPtr >
CROOT::Math::WrappedMultiFunction< Func >	Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-dimensional function interface
CTPyMultiGenFunction
►CROOT::Math::IBaseFunctionOneDim	Interface (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 )
CRooGenFunction	Lightweight interface adaptor that exports a RooAbsReal as a ROOT::Math::IGenFunction
CROOT::Math::Functor1D	Functor1D class for one-dimensional functions
►CROOT::Math::IGradientFunctionOneDim	Interface (abstract class) for one-dimensional functions providing a gradient calculation
CROOT::Math::GradFunctor1D	GradFunctor1D class for one-dimensional gradient functions
CROOT::Math::IntegrandTransform	Auxiliary inner class for mapping infinite and semi-infinite integrals
►CROOT::Math::IParametricFunctionOneDim	Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam
►CROOT::Math::IParametricGradFunctionOneDim	Interface (abstract class) for parametric one-dimensional gradient functions providing in addition to function evaluation with respect the coordinates also the gradient with respect to the parameters, via the method ParameterGradient
►CROOT::Math::ParamFunction< IParamGradFunction >
CROOT::Math::Polynomial	Parametric Function class describing polynomials of order n
CROOT::Math::WrappedTF1	Class to Wrap a ROOT Function class (like TF1) in a IParamFunction interface of one dimensions to be used in the ROOT::Math numerical algorithms The wrapper does not own bby default the TF1 pointer, so it assumes it exists during the wrapper lifetime
CROOT::Math::VavilovAccurateCdf	Class describing the Vavilov cdf
CROOT::Math::VavilovAccuratePdf	Class describing the Vavilov pdf
CROOT::Math::VavilovAccurateQuantile	Class describing the Vavilov quantile function
CROOT::Math::OneDimMultiFunctionAdapter< MultiFuncType >	OneDimMultiFunctionAdapter class to wrap a multidimensional function in one dimensional one
CROOT::Math::OneDimParamFunctionAdapter< ParamFuncType >	OneDimParamFunctionAdapter class to wrap a multi-dim parameteric function in one dimensional one
CROOT::Math::WrappedFunction< Func >	Template class to wrap any C++ callable object which takes one argument i.e
CROOT::Math::WrappedMemFunction< FuncObj, MemFuncPtr >	Template class to wrap any member function of a class taking a double and returning a double in a 1D function interface For example, if you have a class like: struct X { double Eval(double x); }; you can wrapped in the following way: WrappedMemFunction<X, double ( X::* ) (double) > f;
►CROOT::Math::IBaseParam	Documentation for the abstract class IBaseParam
CROOT::Math::IParametricFunctionMultiDimTempl< double >
CROOT::Math::IParametricFunctionMultiDimTempl< T >	IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam
CROOT::Math::IParametricFunctionOneDim	Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam
CROOT::Math::IParametricGradFunctionMultiDimTempl< T >	Interface (abstract class) for parametric gradient multi-dimensional functions providing in addition to function evaluation with respect to the coordinates also the gradient with respect to the parameters, via the method ParameterGradient
►CRooFactoryWSTool::IFace
CRooClassFactory::ClassFacIFace
CRooCustomizer::CustIFace
CRooFactoryWSTool::SpecialsIFace
CRooSimWSTool::SimWSIFace
►CTMVA::IFitterTarget	Interface for a fitter 'target'
CTMVA::MethodCuts	Multivariate optimisation of signal efficiency for given background efficiency, applying rectangular minimum and maximum requirements
CTMVA::MethodFDA	Function discriminant analysis (FDA)
CTMVA::MethodMLP	Multilayer Perceptron class built off of MethodANNBase
CTMVA::MinuitFitter	/Fitter using MINUIT
CTMVA::OptimizeConfigParameters
CTMVA::ResultsMulticlass	Class which takes the results of a multiclass classification
►CROOT::Math::IGradientMultiDimTempl< T >	Gradient interface (abstract class) defining the signature for calculating the gradient of a multi-dimensional function
CROOT::Math::IGradientFunctionMultiDimTempl< T >	Interface (abstract class) for multi-dimensional functions providing a gradient calculation
►CROOT::Math::IGradientOneDim	Specialized Gradient interface(abstract class) for one dimensional functions It provides a method to evaluate the derivative of the function, Derivative and a method to evaluate at the same time the function and the derivative FdF
CROOT::Math::IGradientFunctionOneDim	Interface (abstract class) for one-dimensional functions providing a gradient calculation
CROOT::Math::Polynomial	Parametric Function class describing polynomials of order n
CROOT::Math::WrappedTF1	Class to Wrap a ROOT Function class (like TF1) in a IParamFunction interface of one dimensions to be used in the ROOT::Math numerical algorithms The wrapper does not own bby default the TF1 pointer, so it assumes it exists during the wrapper lifetime
►CTMVA::IMethod	Interface for all concrete MVA method implementations
►CTMVA::MethodBase	Virtual base Class for all MVA method
►CTMVA::MethodANNBase	Base class for all TMVA methods using artificial neural networks
CTMVA::MethodMLP	Multilayer Perceptron class built off of MethodANNBase
CTMVA::MethodBayesClassifier	Description of bayesian classifiers
CTMVA::MethodBDT	Analysis of Boosted Decision Trees
CTMVA::MethodCFMlpANN	Interface to Clermond-Ferrand artificial neural network
►CTMVA::MethodCompositeBase	Virtual base class for combining several TMVA method
CTMVA::MethodBoost	Class for boosting a TMVA method
CTMVA::MethodCategory	Class for categorizing the phase space
CTMVA::MethodCrossValidation
CTMVA::MethodCuts	Multivariate optimisation of signal efficiency for given background efficiency, applying rectangular minimum and maximum requirements
CTMVA::MethodDL
CTMVA::MethodDNN	Deep Neural Network Implementation
CTMVA::MethodDT	Analysis of Boosted Decision Trees
CTMVA::MethodFDA	Function discriminant analysis (FDA)
CTMVA::MethodFisher	Fisher and Mahalanobis Discriminants (Linear Discriminant Analysis)
CTMVA::MethodHMatrix	H-Matrix method, which is implemented as a simple comparison of chi-squared estimators for signal and background, taking into account the linear correlations between the input variables
CTMVA::MethodKNN	Analysis of k-nearest neighbor
CTMVA::MethodLD	Linear Discriminant
CTMVA::MethodLikelihood	Likelihood analysis ("non-parametric approach")
CTMVA::MethodPDEFoam	The PDEFoam method is an extension of the PDERS method, which divides the multi-dimensional phase space in a finite number of hyper-rectangles (cells) of constant event density
CTMVA::MethodPDERS	This is a generalization of the above Likelihood methods to $N_{var}$ dimensions, where $N_{var}$ is the number of input variables used in the MVA
CTMVA::MethodRuleFit	J Friedman's RuleFit method
CTMVA::MethodSVM	SMO Platt's SVM classifier with Keerthi & Shavade improvements
CTMVA::MethodTMlpANN	This is the TMVA TMultiLayerPerceptron interface class
►CTMVA::PyMethodBase
CTMVA::MethodPyAdaBoost
CTMVA::MethodPyGTB
CTMVA::MethodPyKeras
CTMVA::MethodPyRandomForest
►CTMVA::RMethodBase
CTMVA::MethodC50
CTMVA::MethodRSNNS
CTMVA::MethodRSVM
CTMVA::MethodRXGB
►CROOT::Math::IMinimizer1D	Interface class for numerical methods for one-dimensional minimization
CROOT::Math::BrentMinimizer1D	User class for performing function minimization
CROOT::Math::GSLMinimizer1D	Minimizer for arbitrary one dimensional functions
CBidirMMapPipe_impl::Pages::impl	Implementation
►CImpl
CROOT::Math::FunctorGradHandler< ParentFunctor, Func, GradFunc >	Functor Handler class for gradient functions where both callable objects are provided for the function evaluation (type Func) and for the gradient (type GradFunc)
CROOT::Math::FunctorHandler< ParentFunctor, Func >	Functor Handler class is responsible for wrapping any other functor and pointer to free C functions
CROOT::Math::MemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >	Functor Handler to Wrap pointers to member functions The member function type must be (XXX means any name is allowed) : double XXX ( double x) for 1D functions and double XXXX (const double *x) for multi-dimensional functions
CROOT::Math::MemGradFunHandler< ParentFunctor, PointerToObj, PointerToMemFn, PointerToGradMemFn >	Functor Handler to Wrap pointers to member functions for the evaluation of the function and the gradient
CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >	ParamFunctor Handler class is responsible for wrapping any other functor and pointer to free C functions
CROOT::Math::ParamMemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >	ParamFunctor Handler to Wrap pointers to member functions
CTMVA::Increment< T >
CROOT::Detail::indices< Indices >
CROOT::Math::rowOffsetsUtils::indices<... >
CTFile::InfoListRet	Simple struct of the return value of GetStreamerInfoListImpl
CTClass::InsertTClassInRegistryRAII
CTEveParamList::IntConfig_t
Cstd::integer_sequence< _Tp, _Ip >
►Cintegral_constant
Cnlohmann::detail::negation< B >
CROOT::TypeTraits::IsSignedNumeral< T >	Checks for signed integers types that are not characters
CROOT::TypeTraits::IsSmartOrDumbPtr< T >
CROOT::TypeTraits::IsUnsignedNumeral< T >	Checks for unsigned integer types that are not characters
CROOT::Fit::FitUtil::IntegralEvaluator< ParamFunc >
CROOT::Math::IntegratorMultiDim	User class for performing multidimensional integration
CROOT::Math::IntegratorOneDim	User Class for performing numerical integration of a function in one dimension
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::internal_iterator	Iterator value
CROOT::Math::Interpolator	Class for performing function interpolation of points
CROOT::Internal::InterpreterMutexRegistrationRAII
►CTMVA::Interval	The TMVA::Interval Class
CTMVA::LogInterval	The TMVA::Interval Class
►CRooStats::IntervalCalculator	IntervalCalculator is an interface class for a tools which produce RooStats ConfIntervals
CRooStats::BayesianCalculator	BayesianCalculator is a concrete implementation of IntervalCalculator, providing the computation of a credible interval using a Bayesian method
CRooStats::CombinedCalculator	CombinedCalculator is an interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals
CRooStats::FeldmanCousins	(like the Feldman-Cousins technique) is essentially a specific configuration of the more general NeymanConstruction
CRooStats::HypoTestInverter	HypoTestInverter class for performing an hypothesis test inversion by scanning the hypothesis test results of an HypoTestCalculator for various values of the parameter of interest
CRooStats::HypoTestInverterOriginal	This class is now deprecated and to be replaced by the HypoTestInverter
CRooStats::MCMCCalculator	Bayesian Calculator estimating an interval or a credible region using the Markov-Chain Monte Carlo method to integrate the likelihood function with the prior to obtain the posterior function
CRooStats::NeymanConstruction	NeymanConstruction is a concrete implementation of the NeymanConstruction interface that, as the name suggests, performs a NeymanConstruction
CTMVA::RuleFitAPI::IntParms
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 $a_{11} \to 1/a_{11}$
CROOT::Math::Inverter< 2 >	2x2 matrix inversion using Cramers rule
CTMVA::Config::IONames
CTTreeCache::IOPos
►CROOT::Math::IOptions	Generic interface for defining configuration options of a numerical algorithm
CROOT::Math::GenAlgoOptions	Class implementing generic options for a numerical algorithm Just store the options in a map of string-value pairs
►Cstd::ios_base	STL class
►Cstd::basic_ios< Char >	STL class
►Cstd::basic_ostream< Char >	STL class
►Cstd::basic_ostringstream< Char >	STL class
►Cstd::ostringstream	STL class
CROOT::Experimental::TLogEntry	A diagnostic, emitted by the TLogManager upon destruction of the TLogEntry
CTMVA::MsgLogger	Ostringstream derivative to redirect and format output
►Cstd::ostream	STL class
CTGTextViewostream
►CTMVA::IPruneTool	IPruneTool - a helper interface class to prune a decision tree
CTMVA::CostComplexityPruneTool	A class to prune a decision tree using the Cost Complexity method
CTMVA::ExpectedErrorPruneTool	A helper class to prune a decision tree using the expected error (C4.5) method
CTMVA::IPythonInteractive	This class is needed by JsMVA, and it's a helper class for tracking errors during the training in Jupyter notebook
►CROOT::Math::IRootFinderMethod	Interface for finding function roots of one-dimensional functions
CROOT::Math::BrentRootFinder	Class for finding the root of a one dimensional function using the Brent algorithm
►CROOT::Math::GSLRootFinder	Base class for GSL Root-Finding algorithms for one dimensional functions which do not use function derivatives
CROOT::Math::Roots::Bisection	Roots::Bisection Bisection algorithm, simplest algorithm for bracketing the roots of a function, but slowest one
CROOT::Math::Roots::Brent	Brent-Dekker algorithm which combines an interpolation strategy with the bisection algorithm See the GSL manual for more information
CROOT::Math::Roots::FalsePos	False Position algorithm based on linear interpolation
►CROOT::Math::GSLRootFinderDeriv	Base class for GSL Root-Finding algorithms for one dimensional functions which use function derivatives
CROOT::Math::Roots::Newton	Newton algorithm, which computes the derivative at each iteration See the GSL manual for more information
CROOT::Math::Roots::Secant	Secant algorithm, simplified version of Newton method, which does not require the derivative at every step
CROOT::Math::Roots::Steffenson	Steffenson method, providing the fastes convergence
CROOT::Detail::is_array_class< Array >
CROOT::Detail::is_array_class< std::array< T, N > >
CROOT::Detail::is_array_class< std::initializer_list< T > >
CROOT::Detail::is_array_class< std::vector< T > >
Cnlohmann::detail::is_basic_json_nested_type< BasicJsonType, T >
Cnlohmann::detail::is_compatible_array_type< BasicJsonType, CompatibleArrayType >
Cnlohmann::detail::is_compatible_integer_type< RealIntegerType, CompatibleNumberIntegerType >
Cnlohmann::detail::is_compatible_integer_type_impl< true, RealIntegerType, CompatibleNumberIntegerType >
Cnlohmann::detail::is_compatible_object_type< BasicJsonType, CompatibleObjectType >
Cnlohmann::detail::is_compatible_object_type_impl< true, RealType, CompatibleObjectType >
CROOT::TypeTraits::IsContainer< T >	Check for container traits
CROOT::TypeTraits::IsContainer< std::span< T > >
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::iteration_proxy< IteratorType >	Proxy class for the iterator_wrapper functions
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::iteration_proxy< IteratorType >::iteration_proxy_internal	Helper class for iteration
CTEveChunkManager::iterator
CROOT::Math::KDTree< _DataPoint >::iterator
►Citerator
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::iter_impl< U >	Template for a random access iterator for the basic_json class
CROOT::Experimental::Internal::TIndexIter< REFERENCE, POINTER >	Iterates over an index; the REFERENCE is defined by the REFERENCE template parameter
CROOT::Experimental::TAxisBase::const_iterator	Random const_iterator through bins
CROOT::TSeq< T >::iterator
CTBtreeIter	Iterator of btree
►CROOT::Experimental::Internal::TIndexIter< THistBinRef< HISTIMPL >, THistBinPtr< HISTIMPL > >
CROOT::Experimental::Detail::THistBinIter< HISTIMPL >	Iterates over the bins of a THist or THistImpl
►CTListIter	Iterator of linked list
CTFileIter
CTListOfEnumsWithLockIter	Iterator for TListOfEnumsWithLock
CTListOfFunctionsIter	Iterator for TListOfFunctions
CTMapIter	Iterator of map
CTObjArrayIter	Iterator of object array
CTOrdCollectionIter	Iterator of ordered collection
CTRefArrayIter	Iterator of object array
CTTreeReader::Iterator_t	Iterate through the entries of a TTree
CTViewPubDataMembersIter	Iterator of over the view's content
CTViewPubFunctionsIter	Iterator of over the view's content
CTGenericTable::iterator
CTIndexTable::iterator
CTTable::iterator
CTTreeReaderArray< T >::Iterator_t< ReaderArrayType >	Random access iterator to the elements of a TTreeReaderArray
►Citerator_traits
CTIterCategory< T >
CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, large >	Small helper to implement the function to create,access and destroy iterators
CROOT::Detail::TCollectionProxyInfo::Type< std::vector< Bool_t > >::Iterators
CROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators
CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, true >
CROOT::Detail::TCollectionProxyInfo::Iterators< std::vector< T >, false >
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 * >
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::json_pointer	JSON Pointer
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::json_value	JSON value
CROOT::Math::KahanSum< T >	The Kahan compensate summation algorithm significantly reduces the numerical error in the total obtained by adding a sequence of finite precision floating point numbers
CTMVA::KDEKernel	KDE Kernel for "smoothing" the PDFs
CROOT::Math::KDTree< _DataPoint >
CROOT::Meta::Selection::KeepFirstTemplateArguments< I >	Used to specify the number of arguments to be kept
CROOT::Math::KelvinFunctions	This class calculates the Kelvin functions Ber(x), Bei(x), Ker(x), Kei(x), and their first derivatives
CROOT::Minuit2::LASymMatrix	Class describing a symmetric matrix of size n
CROOT::Minuit2::LAVector
CTMVA::DNN::Layer	Layer defines the layout of a layer
CTMVA::DNN::LayerData	LayerData holds the data of one layer
CTMVA::LDA
Cstd::less< ROOT::Internal::RConcurrentHashColl::HashValue >
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::lexer	Lexical analysis
CROOT::Fit::FitUtil::LikelihoodAux< T >
CROOT::Fit::FitUtil::LikelihoodAux< double >
CTMath::Limits< T >
CTEveStraightLineSet::Line_t
CRgl::Pad::LineAttribSet
CTHtml::LinkInfo_t
CROOT::Math::LocalCoordinateSystemTag	Tag for identifying vectors based on a local coordinate system
CROOT::Internal::UniqueLockRecurseCount::LocalCounts
CTAtomicCount::LockGuard
CTString::LongStr_t
CROOT::Math::LorentzRotation	Lorentz 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::AbsoluteDeviationLossFunction	Absolute Deviation Loss Function
CTMVA::AbsoluteDeviationLossFunctionBDT	Absolute Deviation BDT Loss Function
►CTMVA::HuberLossFunction	Huber Loss Function
CTMVA::HuberLossFunctionBDT	Huber BDT Loss Function
►CTMVA::LeastSquaresLossFunction	Least Squares Loss Function
CTMVA::LeastSquaresLossFunctionBDT	Least Squares BDT Loss Function
►CTMVA::LossFunctionBDT
CTMVA::AbsoluteDeviationLossFunctionBDT	Absolute Deviation BDT Loss Function
CTMVA::HuberLossFunctionBDT	Huber BDT Loss Function
CTMVA::LeastSquaresLossFunctionBDT	Least Squares BDT Loss Function
CTMVA::LossFunctionEventInfo
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::Math::rowOffsetsUtils::make_indices< N >
CROOT::Detail::make_indices_impl< First, Step, N, typename std::enable_if<(N==0)>::type >
CROOT::Detail::make_indices_impl< First, Step, N, typename std::enable_if<(N==1)>::type >
►CROOT::Detail::make_indices_impl< First, Step,((Last - First)+(Step - 1))/Step >
CROOT::Detail::make_indices_< First, Last, Step >
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_impl< First, Step, N, class >::type >
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::Detail::make_indices_impl< First, Step, N, class >::type >
CROOT::Math::detail::manipulator< char_t >
►Cstd::map< K, T >	STL class
►CTGDMLBaseTGDMMapHelper
CTGDMMapHelper< T >
CTGDMMapHelper< const char >
CTGDMMapHelper< TGDMLRefl >
CTGDMMapHelper< TGeoElement >
CTGDMMapHelper< TGeoIsotope >
CTGDMMapHelper< TGeoMaterial >
CTGDMMapHelper< TGeoMedium >
CTGDMMapHelper< TGeoMixture >
CTGDMMapHelper< TGeoRotation >
CTGDMMapHelper< TGeoScale >
CTGDMMapHelper< TGeoShape >
CTGDMMapHelper< TGeoTranslation >
CTGDMMapHelper< TGeoVolume >
CTEveStraightLineSet::Marker_t
CRgl::Pad::MarkerPainter
CROOT::Math::MathMoreLib
CROOT::Math::MatRepStd< T, D1, D2 >	Expression wrapper class for Matrix objects
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
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
CRgl::Pad::MeshPatch_t
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::Method	Small helper to execute (compiler) generated function for the access to STL or other containers
CTGenCollectionProxy::Method0
►CTMVA::MethodCFMlpANN_Utils	Implementation of Clermond-Ferrand artificial neural network
CTMVA::MethodCFMlpANN	Interface to Clermond-Ferrand artificial neural network
CPyROOT::MethodProxy::MethodInfo_t
CPyROOT::MethodProxy
Cmg_callbacks
Cmg_client_cert
Cmg_client_options
Cmg_form_data_handler
Cmg_header
Cmg_option
Cmg_request_info
Cmg_response_info
Cmg_server_ports
Cmg_websocket_subprotocols
►CROOT::Math::Minimizer	Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2, Minuit, GSL, etc..) Plug-in's exist in ROOT to be able to instantiate the derived classes like ROOT::Math::GSLMinimizer or ROOT::Math::Minuit2Minimizer via the plug-in manager
►CROOT::Math::BasicMinimizer	Base Minimizer class, which defines the basic funcionality of various minimizer implementations (apart from Minuit and Minuit2) It provides support for storing parameter values, step size, parameter transofrmation etc
CROOT::Math::GSLMinimizer	GSLMinimizer class
CROOT::Math::GSLNLSMinimizer	GSLNLSMinimizer class for Non Linear Least Square fitting It Uses the Levemberg-Marquardt algorithm from GSL Non Linear Least Square fitting
CROOT::Math::GSLSimAnMinimizer	GSLSimAnMinimizer class for minimization using simulated annealing using the algorithm from GSL
CROOT::Math::RMinimizer	RMinimizer class
CROOT::Math::GeneticMinimizer	GeneticMinimizer
CROOT::Minuit2::Minuit2Minimizer	Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for Minuit2 minimization algorithm
CTFumiliMinimizer	TFumiliMinimizer class: minimizer implementation based on TFumili
CTLinearMinimizer	TLinearMinimizer class: minimizer implementation based on TMinuit
CTMinuitMinimizer	TMinuitMinimizer class: ROOT::Math::Minimizer implementation based on TMinuit
CROOT::Math::MinimizerOptions	Minimizer options
►CROOT::Math::MinimizerVariableTransformation	Base class for MinimizerVariable transformations defining the functions to deal with bounded parameters
CROOT::Math::SinVariableTransformation	Sin Transformation class for dealing with double bounded variables
CROOT::Math::SqrtLowVariableTransformation	Sqrt Transformation class for dealing with lower bounded variables
CROOT::Math::SqrtUpVariableTransformation	Sqrt Transformation class for dealing with upper bounded variables
CROOT::Math::MinimTransformVariable	MinimTransformVariable 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::CombinedMinimumBuilder
CROOT::Minuit2::FumiliBuilder	Builds the FunctionMinimum using the Fumili method
CROOT::Minuit2::ScanBuilder	Performs a minimization using the simplex method of Nelder and Mead (ref
CROOT::Minuit2::SimplexBuilder	Performs a minimization using the simplex method of Nelder and Mead (ref
CROOT::Minuit2::VariableMetricBuilder	Build (find) function minimum using the Variable Metric method (MIGRAD) Two possible error updators can be choosen
CROOT::Minuit2::MinimumError	MinimumError keeps the inv
►CROOT::Minuit2::MinimumErrorUpdator
CROOT::Minuit2::BFGSErrorUpdator	Update of the covariance matrix for the Variable Metric minimizer (MIGRAD)
CROOT::Minuit2::DavidonErrorUpdator	Update of the covariance matrix for the Variable Metric minimizer (MIGRAD)
CROOT::Minuit2::FumiliErrorUpdator	In the case of the Fumili algorithm the Error matrix (or the Hessian matrix containing the (approximate) second derivatives) is calculated using a linearization of the model function negleting second derivatives
CROOT::Minuit2::MinimumParameters
CROOT::Minuit2::MinimumSeed	MinimumSeed contains the starting values for the minimization produced by the SeedGenerator
►CROOT::Minuit2::MinimumSeedGenerator	Base class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization;
CROOT::Minuit2::MnSeedGenerator	Concrete implementation of the MinimumSeedGenerator interface; used within ModularFunctionMinimizer;
CROOT::Minuit2::SimplexSeedGenerator	Generate Simplex starting point (state)
CROOT::Minuit2::MinimumState	MinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder)
CROOT::Math::MinOp< T >	Subtraction Operation Class
CROOT::Minuit2::MinosError	Class holding the result of Minos (lower and upper values) for a specific parameter
CROOT::Minuit2::MinuitParameter	Class 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::Math::MiserParameters	Structures collecting parameters for MISER multidimensional integration
CTTreeCache::MissCache
CROOT::Math::MixMaxEngineImpl< N >
CROOT::Math::MixMaxEngineImpl< ROOT_MM_N >
CROOT::Minuit2::BasicFunctionMinimum::MnAboveMaxEdm
CROOT::Minuit2::FunctionMinimum::MnAboveMaxEdm
►CROOT::Minuit2::MnApplication	Application 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::MnFumiliMinimize	API class for minimization using Fumili technology; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CROOT::Minuit2::MnMigrad	API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CROOT::Minuit2::MnMinimize	API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CROOT::Minuit2::MnScan	API class for minimization using a scan method to find the minimum; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc
CROOT::Minuit2::MnSimplex	API class for minimization using the Simplex method, which does not need and use the derivatives of the function, but only function values
CROOT::Minuit2::MnContours	API 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::MnCovarianceSqueeze	Class to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index
CROOT::Minuit2::MnCross
CROOT::Minuit2::MnEigen	API class for calculating the eigenvalues of symmetric matrix
►CROOT::Minuit2::MnFcn	Wrapper class to FCNBase interface used internally by Minuit
CROOT::Minuit2::MnUserFcn	Wrapper used by Minuit of FCN interface containing a reference to the transformation object
CROOT::Minuit2::MnFunctionCross	MnFunctionCross
CROOT::Minuit2::MnGlobalCorrelationCoeff	Class for global correlation coefficient
CROOT::Minuit2::MnHesse	API 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::BasicMinimumError::MnHesseFailed
CROOT::Minuit2::MinimumError::MnHesseFailed
CROOT::Minuit2::BasicMinimumError::MnInvertFailed
CROOT::Minuit2::MinimumError::MnInvertFailed
CROOT::Minuit2::MnLineSearch	Implements a 1-dimensional minimization along a given direction (i.e
CROOT::Minuit2::MnMachinePrecision	Determines the relative floating point arithmetic precision
CROOT::Minuit2::BasicMinimumError::MnMadePosDef
CROOT::Minuit2::MinimumError::MnMadePosDef
CROOT::Minuit2::MnMinos	API 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::BasicMinimumError::MnNotPosDef
CROOT::Minuit2::MinimumError::MnNotPosDef
CROOT::Minuit2::MnParabola	This class defines a parabola of the form a*x*x + b*x + c
CROOT::Minuit2::MnParabolaFactory
CROOT::Minuit2::MnParabolaPoint	A point of a parabola
CROOT::Minuit2::MnParameterScan	Scans the values of FCN as a function of one Parameter and retains the best function and Parameter values found
CROOT::Minuit2::MnPlot	MnPlot produces a text-screen graphical output of (x,y) points, e.g
CROOT::Minuit2::MnPosDef	Force the covariance matrix to be positive defined by adding extra terms in the diagonal
CROOT::Minuit2::MnPrint
CROOT::Minuit2::BasicFunctionMinimum::MnReachedCallLimit
CROOT::Minuit2::FunctionMinimum::MnReachedCallLimit
CROOT::Minuit2::MnRefCountedPointer< T >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicFunctionGradient >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicFunctionMinimum >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumError >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumParameters >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumSeed >
CROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumState >
CROOT::Minuit2::MnReferenceCounter
CROOT::Minuit2::MnStrategy	API class for defining three levels of strategies: low (0), medium (1), high (>=2); acts on: Migrad (behavioural), Minos (lowers strategy by 1 for Minos-own minimization), Hesse (iterations), Numerical2PDerivative (iterations)
CROOT::Minuit2::MnTiny
►CROOT::Minuit2::MnTraceObject
CTMinuit2TraceObject
CROOT::Minuit2::MnUserCovariance	Class 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::MnUserParameters	API 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
CROOT::Minuit2::MnUserParameterState	Class which holds the external user and/or internal Minuit representation of the parameters and errors; transformation internal <-> external on demand;
CROOT::Minuit2::MnUserTransformation	Class dealing with the transformation between user specified parameters (external) and internal parameters used for minimization
CROOT::Minuit2::MnVectorTransform
CTMVA::kNN::ModulekNN
CTMVA::Monitoring
CROOT::Minuit2::MPIProcess
CROOT::Minuit2::MPITerminate
CROOT::Math::MulOp< T >	Multiplication (element-wise) Operation Class
CMultiDist	Free functions adapter needed by UNURAN for multidimensional cont distribution
CROOT::Math::MultPolicy< T, R1, R2 >	Matrix-matrix multiplication policy
CXrdClientVector< T >::myindex
CMYSQL_BIND
CMYSQL_STMT
CTGDMLWrite::NameLst
CROOT::Minuit2::NegativeG2LineSearch	In 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::Net	Neural net
►CTMVA::Node	Node for the BinarySearch or Decision Trees
CTMVA::BinarySearchTreeNode	Node for the BinarySearch or Decision Trees
CTMVA::CCTreeWrapper::CCTreeNode
CTMVA::DecisionTreeNode
CTMVA::kNN::Node< T >	This file contains binary tree and global function template that searches tree for k-nearest neigbors
CTMVA::kNN::Node< TMVA::kNN::Event >
CRooStats::HistFactory::EstimateSummary::NormFactor
CRooStats::HistFactory::NormFactor
Cstd::Detail::not_fn_t< F >
►C<NSApplicationDelegate>
CROOTApplicationDelegate
►CNSObject
CPassiveKeyGrab
CQuartzImage
CQuartzPixmap
CROOTApplicationDelegate
CROOT::MacOSX::Util::NSScopeGuard< DerivedType >
CROOT::MacOSX::Util::NSScopeGuard< ROOTApplicationDelegate >
CROOT::MacOSX::Util::NSStrongReference< DerivedType >
CROOT::MacOSX::Util::NSStrongReference< NSObject< X11Drawable-p > >
CROOT::MacOSX::Util::NSStrongReference< NSOpenGLContext >
CROOT::MacOSX::Util::NSStrongReference< QuartzWindow >
►CNSView
►CQuartzView
CROOTOpenGLView
►CNSWindow
CQuartzWindow
►C<NSWindowDelegate>
CQuartzWindow
CRooStats::NuisanceParametersSampler	Helper class for ToyMCSampler
CTMVA::null_t< F >
CROOT::Math::NullTypeFunc1D
CRooStats::NumberCountingPdfFactory	A factory for building PDFs and data for a number counting combination
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::numtostr	Locale-independent serialization for built-in arithmetic types
CRooSimWSTool::ObjBuildConfig
►Cobject
CROOTwriter.ROOTwriter
Cwriter.writer
CPyROOT::ObjectProxy
CRooSimWSTool::ObjSplitRule
CTODBCStatement::ODBCBufferRec_t
CRgl::Pad::OffScreenDevice
CTMVA::OptionMap	Class to storage options for the differents methods
CROOT::Experimental::TFile::Options_t	Options for TFile construction
CTHtml::OutputStyle_t
CRooStats::HistFactory::OverallSys
CROOT::Math::CholeskyDecompHelpers::PackedArrayAdapter< G >	Adapter for packed arrays (to SMatrix indexing conventions)
CBidirMMapPipe_impl::PageChunk	Class representing a chunk of pages
CBidirMMapPipe_impl::Pages	Handle class for a number of Pages
CRooNormSetCache::PairCmp
CROOT::Detail::TCollectionProxyInfo::PairHolder< T, Q >
CROOT::Fit::ParameterSettings	Class, 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
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::parser	Syntax analysis
Cpasswd
CTHtml::PathInfo_t
CPattern
►CPdfCacheElem
CRooFFTConvPdf::FFTCacheElem
CPgSQL_Stmt_t
CPictureAttributes_t
CXrdPoll::PipeData
CTTable::piterator
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
CRgl::PlotTranslation
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 )
CTColorGradient::Point
CROOT::MacOSX::X11::Point
CTProofDrawListOfGraphs::Point3D_t
CTProofDrawListOfPolyMarkers3D::Point4D_t
CPoint_t
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)
CBidirMMapPipe::PollEntry	For poll() interface
CTEvePolygonSetProjected::Polygon_t
CRgl::Pad::PolygonStippleSet
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
CRooStats::HistFactory::PreprocessFunction
CTEveProjection::PreScaleEntry_t
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::primitive_iterator_t	Iterator for primitive JSON types
Cnlohmann::detail::priority_tag< N >
Cnlohmann::detail::priority_tag< 0 >
CProcInfo_t
CRooStats::ProfileInspector	Utility class to plot conditional MLE of nuisance parameters vs
CTGLSurfacePainter::Projection_t
CROOT::VecOps::PromoteTypeImpl< T >
CROOT::VecOps::PromoteTypeImpl< double >
CROOT::VecOps::PromoteTypeImpl< float >
CROOT::VecOps::PromoteTypeImpl< long double >
CRooStats::ProofConfig	Holds configuration options for proof and proof-lite
CProofServEnv_t
CPyROOT::PropertyProxy
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)
CPybins_t	Pythia6 common block Pybins
►CPyROOT::PyCallable
►CPyROOT::TMethodHolder
CPyROOT::TClassMethodHolder
CPyROOT::TConstructorHolder
CPyROOT::TFunctionHolder
CPyROOT::TSetItemHolder
CPydat1_t	Pythia6 common block Pydat1
CPydat2_t	Pythia6 common block Pydat2
CPydat3_t	Pythia6 common block Pydat3
CPydat4_t	Pythia6 common block Pydat4
CPydatr_t	Pythia6 common block Pydatr
CPyROOT::PyGILRAII
CPyint1_t	Pythia6 common block Pyint1
CPyint2_t	Pythia6 common block Pyint2
CPyint3_t	Pythia6 common block Pyint3
CPyint4_t	Pythia6 common block Pyint4
CPyint5_t	Pythia6 common block Pyint5
CPyint6_t	Pythia6 common block Pyint6
CPyint7_t	Pythia6 common block Pyint7
CPyint8_t	Pythia6 common block Pyint8
CPyint9_t	Pythia6 common block Pyint9
CPyints_t	Pythia6 common block Pyints
CPyjets_t	Pythia6 common block Pyjets
CPymssm_t	Pythia6 common block Pymssm
CPypars_t	Pythia6 common block Pypars
CPyROOT::PyRootClass	Type object to hold TClassRef instance (this is only semantically a presentation of PyRootType instances, not in a C++ sense)
CPyssmt_t	Pythia6 common block Pyssmt
CPysubs_t	Pythia6 common block Pysubs
►CQApplication
CTQRootApplication
►CQObject
CTQCanvasMenu
CQuad
CROOT::Math::QuasiRandom< Engine >	User class for MathMore random numbers template on the Engine type
CROOT::Math::Quaternion	Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k)
CTHttpLongPollEngine::QueueItem
CTMVA::QuickMVAProbEstimator
►CQWidget
CTQRootCanvas
CTQRootDialog
►CROOT::Internal::RDF::RActionBase
CROOT::Internal::RDF::RAction< Helper, PrevDataFrame, ColumnTypes_t >
CROOT::Detail::VecOps::RAdoptAllocator< T >	RAdoptAllocator can provide a view on already allocated memory
CROOT::Detail::VecOps::RAdoptAllocator< bool >
CROOT::Math::Random< Engine >	Documentation for the Random class
CROOT::Math::RandomFunctions< Engine, EngineBaseType >
►CROOT::Math::RandomFunctions< EngineType, DefaultEngineType >
CROOT::Math::RandomFunctions< EngineType, ROOT::Math::GSLRandomEngine >	Specialized implementation of the Random functions based on the GSL library
CROOT::Math::RandomFunctionsImpl< EngineBaseType >	Definition of the generic impelmentation 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::Ranking	Ranking for variables in method (implementation)
CTString::RawStr_t
CROOT::Internal::RConcurrentHashColl	This class is a TS set of unsigned set
►CROOT::Detail::RDF::RCustomColumnBase
CROOT::Detail::RDF::RCustomColumn< F, UPDATE_HELPER_TYPE >
CROOT::RDF::RCutFlowReport
►CROOT::RDF::RDataSource	RDataSource defines an API that RDataFrame can use to read arbitrary data formats
CROOT::RDF::RArrowDS	RDataFrame data source class to interface with Apache Arrow
CROOT::RDF::RCsvDS	RDataFrame data source class for reading CSV files
CROOT::RDF::RLazyDS< ColumnTypes >	A RDataSource implementation which is built on top of result proxies
CROOT::RDF::RRootDS
CROOT::RDF::RTrivialDS
CTFormLeafInfo::ReadValueHelper< T >
CTFormLeafInfo::ReadValueHelper< Long64_t >
CTFormLeafInfo::ReadValueHelper< LongDouble_t >
CTFormLeafInfo::ReadValueHelper< ULong64_t >
CTTreeFormula::RealInstanceCache
CTMVA::RuleFitAPI::RealParms
►CRooVectorDataStore::RealVector
CRooVectorDataStore::RealFullVector
CROOT::Detail::VecOps::RAdoptAllocator< T >::rebind< U >
CROOT::Detail::VecOps::RAdoptAllocator< bool >::rebind< U >
CTEveCaloData::RebinData_t
CROOT::MacOSX::X11::Rectangle
CRectangle_t
CROOT::Internal::RecurseCounts
CRedirectHandle_t
Credirguard
CROOT::ExecutorUtils::ReduceObjects< T >	Merge collection of TObjects
CROOT::Detail::TStatusBitsChecker::Registry
CTMVA::RegressionVariance	Calculate the "SeparationGain" for Regression analysis separation criteria used in various training algorithms
CROOT::TypeTraits::RemoveFirst< T, Rest >
CROOT::TypeTraits::RemoveFirstParameter< typename >	Remove first of possibly many template parameters
CROOT::TypeTraits::RemoveFirstParameter< U< T, Rest... > >
CTString::Rep_t
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 > >
►Creverse_iterator
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::json_reverse_iterator< Base >	Template for a reverse iterator class
►CROOT::Detail::RDF::RFilterBase
CROOT::Detail::RDF::RFilter< FilterF, PrevDataFrame >
CROOT::Detail::RDF::RJittedFilter	A wrapper around a concrete RFilter, which forwards all calls to it RJittedFilter is the type of the node returned by jitted Filter calls: the concrete filter can be created and set at a later time, from jitted code
CROOT::MacOSX::X11::ColorParser::RGB_t
CROOT::Math::RichardsonDerivator	User class for calculating the derivatives of a function
CROOT::RDF::RInterface< Proxied, DataSource >	The public interface to the RDataFrame federation of classes
►CROOT::RDF::RInterface< RDFDetail::RLoopManager >
CROOT::RDataFrame	ROOT's RDataFrame offers a high level interface for analyses of data stored in TTrees, CSV's and other data formats
CROOT::Detail::RDF::RLoopManager
Crng_state_st
CTMVA::ROCCalc
CTMVA::ROCCurve
►CRooAbsCache	RooAbsCache is the abstract base class for data members of RooAbsArgs that cache other (composite) RooAbsArg expressions
CRooCacheManager< T >	Template class RooCacheManager manages the storage of any type of data indexed on the choice of normalization and optionally the set of integrated observables
►CRooCacheManager< RooAbsCacheElement >
CRooObjCacheManager	Class RooObjCacheManager is an implementation of class RooCacheManager<RooAbsCacheElement> and specializes in the storage of cache elements that contain RooAbsArg objects
CRooCacheManager< std::vector< Double_t > >
►CRooAbsCacheElement	RooAbsCacheElement is the abstract base class for objects to be stored in RooAbsCache cache manager objects
CParamHistFunc::CacheElem
CPiecewiseInterpolation::CacheElem
CRooAbsAnaConvPdf::CacheElem	Iterator over _convNormSet
►CRooAbsCachedPdf::PdfCacheElem
CRooIntegralMorph::MorphCacheElem
CRooAbsCachedReal::FuncCacheElem
CRooAbsPdf::CacheElem	Normalization set with for above integral
CRooAddition::CacheElem	Iterator over set
CRooAddModel::CacheElem	Transiet cache with transformed values of coefficients
CRooAddModel::IntCacheElem
CRooAddPdf::CacheElem	Transiet cache with transformed values of coefficients
CRooEffProd::CacheElem
CRooMomentMorph::CacheElem
CRooMomentMorphFunc::CacheElem
CRooMomentMorphFuncND::CacheElem
CRooMomentMorphND::CacheElem
CRooProdPdf::CacheElem
CRooProduct::CacheElem
CRooProjectedPdf::CacheElem
CRooRealSumFunc::CacheElem
CRooRealSumPdf::CacheElem
CRooSimultaneous::CacheElem
►CRooAbsFunc	Abstract interface for evaluating a real-valued function of one real variable and performing numerical algorithms on it
CRooConvIntegrandBinding	Implementation of RooAbsFunc that represent the the integrand of a generic (numeric) convolution A (x) B so that it can be passed to a numeric integrator
CRooHistError::BinomialSumAsym
CRooHistError::BinomialSumEff
CRooHistError::PoissonSum
CRooIntegratorBinding	Function binding representing the output of a RooAbsIntegrator
CRooInvTransform	Lightweight function binding that returns the inverse of an input function binding Apply the change of variables transformation x -> 1/x to the input function and its range
►CRooRealBinding	Lightweight interface adaptor that binds a RooAbsReal object to a subset of its servers and present it as a simple array oriented interface
CRooDataProjBinding	Adaptor that projects a real function via summation of states provided in a dataset
CRooRealAnalytic	Lightweight RooAbsFunc interface adaptor that binds an analytic integral of a RooAbsReal object (specified by a code) to a set of dependent variables
CRooScaledFunc	Lightweight RooAbsFunction implementation that applies a constant scale factor to another RooAbsFunc
►CRooAbsLValue	Abstract base class for objects that are lvalues, i.e
►CRooAbsCategoryLValue	RooAbsCategoryLValue is the common abstract base class for objects that represent a discrete value that may appear on the left hand side of an equation ('lvalue')
CRooCategory	RooCategory represents a fundamental (non-derived) discrete value object
CRooSuperCategory	RooSuperCategory consolidates several RooAbsCategoryLValue objects into a single category
►CRooAbsRealLValue	RooAbsRealLValue is the common abstract base class for objects that represent a real value that may appear on the left hand side of an equation ('lvalue') Each implementation must provide a setVal() member to allow direct modification of the value
CRooErrorVar	RooErrorVar is an auxilary class that represents the error of a RooRealVar as a seperate object
CRooLinearVar
CRooRealVar	RooRealVar represents a fundamental (non-derived) real valued object
►CRooAbsProxy	RooAbsProxy is the abstact interface for proxy classes
►CRooArgProxy	RooArgProxy is the abstact interface for RooAbsArg proxy classes
CRooCategoryProxy	RooCategoryProxy is the proxy implementation for RooAbsCategory objects A RooCategoryProxy is the general mechanism to store references to RooAbsCategoriess inside a RooAbsArg
CRooRealProxy	RooRealProxy is the concrete proxy for RooAbsReal objects A RooRealProxy is the general mechanism to store references to RooAbsReals inside a RooAbsArg
CRooListProxy	RooListProxy is the concrete proxy for RooArgList objects
CRooSetProxy	RooSetProxy is the concrete proxy for RooArgSet objects
►CRooAbsRootFinder	RooAbsRootFinder is the abstract interface for finding roots of real-valued 1-dimensional function that implements the RooAbsFunc interface
CRooBrentRootFinder	Implement the abstract 1-dimensional root finding interface using the Brent-Decker method
CRooAICRegistry	RooAICRegistry is a utility class for operator p.d.f classes that keeps track of analytical integration codes and associated normalization and integration sets
CRooBlindTools
CRooCFunction1Map< VO, VI >
CRooCFunction2Map< VO, VI1, VI2 >
CRooCFunction3Map< VO, VI1, VI2, VI3 >
CRooCFunction4Map< VO, VI1, VI2, VI3, VI4 >
►CRooDirItem	RooDirItem is a utility base class for RooFit objects that are to be attached to ROOT directories
CRooDataHist	RooDataSet is a container class to hold N-dimensional binned data
CRooDataSet	RooDataSet is a container class to hold unbinned data
CRooFitResult
CRooErrorHandler
CRooFIter
CRooFunctor	Lightweight interface adaptor that exports a RooAbsPdf as a functor
CRooGlobalFunc
CRooHistError	RooHistError is a singleton class used to calculate the error bars for each bin of a RooHist object
CRooLinkedListElem	RooLinkedListElem is an link element for the RooLinkedList class
CRooMath
CRooMathCoreReg
CRooMathMoreReg
CRooMPSentinel	RooMPSentinel is a singleton class that keeps track of all parellel execution processes for goodness-of-fit calculations
CRooNormSetCache	Class RooNormSet cache manage the bookkeeping of multiple instances of sets of integration and normalization observables that effectively have the same definition
CRooNumber	Class RooNumber implements numeric constants used by RooFit
►CRooPrintable	RooPlotable is a 'mix-in' base class that define the standard RooFit plotting and printing methods
►CRooAbsArg	RooAbsArg is the common abstract base class for objects that represent a value (of arbitrary type) and "shape" that in general depends on (is a client of) other RooAbsArg subclasses
►CRooAbsCategory	RooAbsCategory is the common abstract base class for objects that represent a discrete value with a finite number of states
CRooAbsCategoryLValue	RooAbsCategoryLValue is the common abstract base class for objects that represent a discrete value that may appear on the left hand side of an equation ('lvalue')
CRooBinningCategory	Class RooBinningCategory provides a real-to-category mapping defined by a series of thresholds
CRooMappedCategory
CRooMultiCategory	RooMultiCategory consolidates several RooAbsCategory objects into a single category
CRooThresholdCategory	Class RooThresholdCategory provides a real-to-category mapping defined by a series of thresholds
►CRooAbsReal	RooAbsReal is the common abstract base class for objects that represent a real value and implements functionality common to all real-valued objects such as the ability to plot them, to construct integrals of them, the ability to advertise (partial) analytical integrals etc
CParamHistFunc
CPiecewiseInterpolation
►CRooAbsCachedReal	RooAbsCachedReal is the abstract base class for functions that need or want to cache their evaluate() output in a RooHistFunc defined in terms of the used observables
CRooAbsSelfCachedReal	RooAbsSelfCachedReal is an abstract base class for functions whose output is cached in terms of a histogram in all observables between getVal() and evaluate()
CRooCachedReal	RooCachedReal is an implementation of RooAbsCachedReal that can cache any external RooAbsReal input function provided in the constructor
►CRooNumRunningInt	Class RooNumRunningInt is an implementation of RooAbsCachedReal that represents a running integral $$RI(f(x)) = \int_{xlow}^{x} f(x') dx'$$ that is calculated internally with a numeric technique: The input function is first sampled into a histogram, which is then numerically integrated
CRooNumCdf	Class RooNumCdf is an implementation of RooNumRunningInt specialized to calculate cumulative distribution functions from p.d.f.s
►CRooAbsHiddenReal	RooAbsHiddenReal is a base class for objects that want to hide their return value from interactive use, e.g
CRooUnblindCPAsymVar	Implementation of BlindTools' CP asymmetry blinding method A RooUnblindCPAsymVar object is a real valued function object, constructed from a blind value holder and a set of unblinding parameters
CRooUnblindOffset	Implementation of BlindTools' offset blinding method A RooUnblindOffset object is a real valued function object, constructed from a blind value holder and a set of unblinding parameters
CRooUnblindPrecision	Implementation of BlindTools' precision blinding method A RooUnblindPrecision object is a real valued function object, constructed from a blind value holder and a set of unblinding parameters
CRooUnblindUniform	Implementation of BlindTools' offset blinding method A RooUnblindUniform object is a real valued function object, constructed from a blind value holder and a set of unblinding parameters
►CRooAbsMoment	RooAbsMoment represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class
CRooFirstMoment	RooFirstMoment represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class
CRooMoment	RooMoment represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class
CRooSecondMoment	RooSecondMoment represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class
►CRooAbsPdf	RooAbsPdf is the abstract interface for all probability density functions The class provides hybrid analytical/numerical normalization for its implementations, error tracing and a MC generator interface
CNuMuToNuE_Oscillation
CRoo2DKeysPdf	Two-dimensional kernel estimation PDF
►CRooAbsAnaConvPdf
CRooBCPEffDecay	PDF describing decay time distribution of B meson including effects of standard model CP violation
CRooBCPGenDecay	Implement standard CP physics model with S and C (no mention of lambda) Suitably stolen and modified from RooBCPEffDecay
CRooBDecay	Most general description of B decay time distribution with effects of CP violation, mixing and life time differences
CRooBMixDecay	Class RooBMixDecay is a RooAbsAnaConvPdf implementation that describes the decay of B mesons with the effects of B0/B0bar mixing
CRooDecay	Single or double sided decay function that can be analytically convolved with any RooResolutionModel implementation
CRooNonCPEigenDecay	Time-dependent RooAbsAnaConvPdf for CP violating decays to Non-CP eigenstates (eg, $B_0 \rightarrow \rho^\pm \pi^\mp$)
►CRooAbsCachedPdf	RooAbsCachedPdf is the abstract base class for p.d.f.s that need or want to cache their evaluate() output in a RooHistPdf defined in terms of the used observables
CRooAbsSelfCachedPdf	RooAbsSelfCachedPdf is an abstract base class for probability density functions whose output is cached in terms of a histogram in all observables between getVal() and evaluate()
CRooCachedPdf	RooCachedPdf is an implementation of RooAbsCachedPdf that can cache any external RooAbsPdf input function provided in the constructor
CRooFFTConvPdf
CRooIntegralMorph	Class RooIntegralMorph is an implementation of the histogram interpolation technique described by Alex Read in 'NIM A 425 (1999) 357-369 'Linear interpolation of histograms' for continuous functions rather than histograms
CRooAddPdf	RooAddPdf is an efficient implementation of a sum of PDFs of the form
CRooArgusBG	RooArgusBG is a RooAbsPdf implementation describing the ARGUS background shape
CRooBernstein	Bernstein basis polynomials are positive-definite in the range [0,1]
CRooBifurGauss	Bifurcated Gaussian p.d.f with different widths on left and right side of maximum value
CRooBreitWigner	Class RooBreitWigner is a RooAbsPdf implementation that models a non-relativistic Breit-Wigner shape
CRooBukinPdf	RooBukinPdf implements the NovosibirskA function
CRooCBShape	P.d.f implementing the Crystal Ball line shape
CRooCFAuto000Pdf
CRooCFunction1PdfBinding< VO, VI >
CRooCFunction2PdfBinding< VO, VI1, VI2 >
CRooCFunction3PdfBinding< VO, VI1, VI2, VI3 >
CRooCFunction4PdfBinding< VO, VI1, VI2, VI3, VI4 >
CRooChebychev	Chebychev polynomial p.d.f
CRooChiSquarePdf	The PDF of the Chi Square distribution for n degrees of freedom
CRooDstD0BG	Special p.d.f shape that can be used to model the background of D*-D0 mass difference distributions
CRooEfficiency	RooEfficiency is a PDF helper class to fit efficiencies parameterized by a supplied function F
CRooEffProd
CRooExponential	Exponential p.d.f
CRooExtendedTerm	RooExtendedTerm is a p.d.f with no observables that only introduces an extended ML term for a given number of expected events term when an extended ML is constructed
CRooExtendPdf
CRooFunctor1DPdfBinding
CRooFunctorPdfBinding
CRooGamma	Implementation of the Gamma PDF for RooFit/RooStats
CRooGaussian	Plain Gaussian p.d.f
CRooGenericPdf	RooGenericPdf is a concrete implementation of a probability density function, which takes a RooArgList of servers and a C++ expression string defining how its value should be calculated from the given list of servers
CRooHistConstraint
CRooHistPdf	RooHistPdf implements a probablity density function sampled from a multidimensional histogram
CRooJeffreysPrior	RooJeffreysPrior
CRooKeysPdf	Class RooKeysPdf implements a one-dimensional kernel estimation p.d.f which model the distribution of an arbitrary input dataset as a superposition of Gaussian kernels, one for each data point, each contributing 1/N to the total integral of the p.d.f
CRooLandau	Landau Distribution p.d.f
CRooLognormal	RooFit Lognormal PDF
CRooMomentMorph
CRooMomentMorphND
CRooMultiVarGaussian	Multivariate Gaussian p.d.f
CRooNDKeysPdf	Generic N-dimensional implementation of a kernel estimation p.d.f
CRooNonCentralChiSquare	The PDF of the Non-Central Chi Square distribution for n degrees of freedom
CRooNovosibirsk	RooNovosibirsk implements the Novosibirsk function
CRooNumConvPdf	Numeric 1-dimensional convolution operator PDF
CRooParametricStepFunction	The Parametric Step Function PDF is a binned distribution whose parameters are the heights of each bin
CRooPoisson	Poisson pdf
CRooPolynomial	RooPolynomial implements a polynomial p.d.f of the form $$f(x) = \sum_{i} a_{i} * x^i$$ By default coefficient a_0 is chosen to be 1, as polynomial probability density functions have one degree of freedom less than polynomial functions due to the normalization condition
CRooProdPdf	RooProdPdf is an efficient implementation of a product of PDFs of the form
CRooProjectedPdf	Class RooProjectedPdf is a RooAbsPdf implementation that represent a projection of a given input p.d.f and the object returned by RooAbsPdf::createProjection
CRooRealSumPdf	Class RooRealSumPdf implements a PDF constructed from a sum of functions:
►CRooResolutionModel
CRooAddModel
CRooGaussModel	Class RooGaussModel implements a RooResolutionModel that models a Gaussian distribution
CRooGExpModel	Class RooGExpModel is a RooResolutionModel implementation that models a resolution function that is the convolution of a Gaussian with a one-sided exponential
CRooTruthModel	RooTruthModel is an implementation of RooResolution model that provides a delta-function resolution model The truth model supports all basis functions because it evaluates each basis function as as a RooFormulaVar
►CRooSimultaneous	RooSimultaneous facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset
CRooStats::HistFactory::HistFactorySimultaneous
CRooTFnPdfBinding
CRooUniform	Flat p.d.f
CRooVoigtian	RooVoigtian is an efficient implementation of the convolution of a Breit-Wigner with a Gaussian, making use of the complex error function
CRooAbsRealLValue	RooAbsRealLValue is the common abstract base class for objects that represent a real value that may appear on the left hand side of an equation ('lvalue') Each implementation must provide a setVal() member to allow direct modification of the value
►CRooAbsTestStatistic	RooAbsTestStatistic is the abstract base class for all test statistics
►CRooAbsOptTestStatistic	RooAbsOptTestStatistic is the abstract base class for test statistics objects that evaluate a function or PDF at each point of a given dataset
CRooChi2Var
CRooDataWeightedAverage	Class RooDataWeightedAverage calculate a weighted average of a function or p.d.f given a dataset with observable values, i.e
CRooNLLVar	Class RooNLLVar implements a a -log(likelihood) calculation from a dataset and a PDF
CRooXYChi2Var
CRooAddition	RooAddition calculates the sum of a set of RooAbsReal terms, or when constructed with two sets, it sums the product of the terms in the two sets
CRooCFunction1Binding< VO, VI >	RooCFunction1Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions
CRooCFunction2Binding< VO, VI1, VI2 >	RooCFunction2Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions
CRooCFunction3Binding< VO, VI1, VI2, VI3 >	RooCFunction3Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions
CRooCFunction4Binding< VO, VI1, VI2, VI3, VI4 >	RooCFunction4Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions
CRooChangeTracker	RooChangeTracker is a meta object that tracks value changes in a given set of RooAbsArgs by registering itself as value client of these objects
CRooConstraintSum	RooConstraintSum calculates the sum of the -(log) likelihoods of a set of RooAbsPfs that represent constraint functions
CRooConstVar	RooConstVar represent a constant real-valued object
CRooConvCoefVar	RooConvCoefVar is an auxilary class that represents the coefficient of a RooAbsAnaConvPdf implementation as a separate RooAbsReal object to be able to interface these coefficient terms with the generic RooRealIntegral integration mechanism
CRooDerivative	RooDerivative represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class
CRooExtendedBinding
CRooFormulaVar
CRooFracRemainder	RooFracRemainder calculates the remainder fraction of a sum of RooAbsReal fraction, i.e (1 - sum_i a_i)
CRooFunctor1DBinding	RooCFunction1Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions
CRooFunctorBinding	RooCFunction1Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions
CRooGenProdProj	RooGenProdProj is an auxiliary class for RooProdPdf that calculates a general normalized projection of a product of non-factorizing PDFs, e.g
CRooHistFunc	RooHistFunc implements a real-valued function sampled from a multidimensional histogram
►CRooLegendre
CRooSpHarmonic	Implementation of the so-called real spherical harmonics, using the orthonormal normalization, which are related to spherical harmonics as: $$Y_{l0} = Y_l^0 (m=0) \\ Y_{lm} = \frac{1}{\sqrt{2}} \left( Y_l^m + (-1)^m Y_l^{-m} \right) (m>0) \\ Y_{lm} = \frac{1}{i\sqrt{2}} \left( Y_l^{|m|} - (-1)^{|m|} Y_l^{-|m|} \right) (m<0)$$
CRooMomentMorphFunc
CRooMomentMorphFuncND
CRooMultiBinomial	RooMultiBinomial is an efficiency function which makes all combinations of efficiencies given as input different efficiency functions for different categories
CRooNumConvolution	Numeric 1-dimensional convolution operator PDF
CRooParamHistFunc
CRooPolyVar	Class RooPolyVar is a RooAbsReal implementing a polynomial in terms of a list of RooAbsReal coefficients $$f(x) = \sum_{i} a_{i}x$$ Class RooPolyvar implements analytical integrals of all polynomials it can define
CRooProduct	RooProduct a RooAbsReal implementation that represent the product of a given set of other RooAbsReal objects
CRooProfileLL	Class RooProfileLL implements the profile likelihood estimator for a given likelihood and set of parameters of interest
CRooPullVar	Class RooPullVar represents the pull of measurement w.r.t to true value using the measurement value and its error
CRooRangeBoolean	RooRangeBoolean
CRooRealIntegral	RooRealIntegral performs hybrid numerical/analytical integrals of RooAbsReal objects The class performs none of the actual integration, but only manages the logic of what variables can be integrated analytically, accounts for eventual jacobian terms and defines what numerical integrations needs to be done to complement the analytical integral
CRooRealMPFE	RooRealMPFE is the multi-processor front-end for parallel calculation of RooAbsReal objects
CRooRealSumFunc
CRooRecursiveFraction	Class RooRecursiveFraction is a RooAbsReal implementation that calculates the plain fraction of sum of RooAddPdf components from a set of recursive fractions: for a given set of input fractions a_i it returns a_0 * Prod_i (1 - a_i)
CRooStats::Heaviside	Represents the Heaviside function
CRooStats::HistFactory::FlexibleInterpVar
CRooStats::HistFactory::LinInterpVar
CRooStats::HistFactory::RooBarlowBeestonLL
CRooStepFunction	The Step Function is a binned function whose parameters are the heights of each bin
CRooTFnBinding
►CRooAbsString	RooAbsString is the common abstract base class for objects that represent a string value
CRooStringVar	RooStringVar implements a string values RooAbsArg
►CRooAbsBinning	RooAbsBinning is the abstract base class for RooRealVar binning definitions This class defines the interface to retrieve bin boundaries, ranges etc
CRooBinning	Class RooBinning is an implements RooAbsBinning in terms of an array of boundary values, posing no constraints on the choice of binning, thus allowing variable bin sizes
CRooLinTransBinning	RooLinTransBinning is a special binning implementation for RooLinearVar that transforms the binning of the RooLinearVar input variable in the same way that RooLinearVar does
CRooParamBinning	Class RooParamBinning is an implementation of RooAbsBinning that constructs a binning with a range definition that depends on external RooAbsReal objects
CRooRangeBinning	RooRangeBinning is binning/range definition that only defines a range but no binning
CRooUniformBinning	RooUniformBinning is an implementation of RooAbsBinning that provides a uniform binning in 'n' bins between the range end points
►CRooAbsCollection	RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects
►CRooArgList
CRooListProxy	RooListProxy is the concrete proxy for RooArgList objects
►CRooArgSet
CRooSetProxy	RooSetProxy is the concrete proxy for RooArgSet objects
►CRooAbsData	RooAbsData is the common abstract base class for binned and unbinned datasets
CRooDataHist	RooDataSet is a container class to hold N-dimensional binned data
CRooDataSet	RooDataSet is a container class to hold unbinned data
CRooTreeData	RooTreeData is the abstract base class for data collection that use a TTree as internal storage mechanism
►CRooAbsDataStore	RooAbsDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism
CRooCompositeDataStore	RooCompositeDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism
CRooTreeDataStore	RooTreeDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism
CRooVectorDataStore	RooVectorDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism
►CRooAbsGenContext	RooAbsGenContext is the abstract base class for generator contexts of RooAbsPdf objects
CRooAddGenContext	RooAddGenContext is an efficient implementation of the generator context specific for RooAddPdf PDFs
CRooBinnedGenContext	RooBinnedGenContext is an efficient implementation of the generator context specific for binned pdfs
CRooConvGenContext	RooConvGenContext is an efficient implementation of the generator context specific for RooAbsAnaConvPdf objects
CRooEffGenContext	RooEffGenContext is a specialized generator context for p.d.fs represented by class RooEffProd, which are p.d.fs multiplied with an efficiency function
CRooGenContext	Class RooGenContext implement a universal generator context for all RooAbsPdf classes that do not have or need a specialized generator context
CRooProdGenContext	RooProdGenContext is an efficient implementation of the generator context specific for RooProdPdf PDFs
CRooSimGenContext	RooSimGenContext is an efficient implementation of the generator context specific for RooSimultaneous PDFs when generating more than one of the component pdfs
CRooSimSplitGenContext	RooSimSplitGenContext is an efficient implementation of the generator context specific for RooSimultaneous PDFs when generating more than one of the component pdfs
►CRooAbsNumGenerator	Class RooAbsNumGenerator is the abstract base class for MC event generator implementations like RooAcceptReject and RooFoam
CRooAcceptReject	Class RooAcceptReject is a generic toy monte carlo generator implement the accept/reject sampling technique on any positively valued function
CRooFoamGenerator	Class RooFoamGenerator is a generic toy monte carlo generator that implement the TFOAM sampling technique on any positively valued function
CRooCatType	RooCatType is an auxilary class for RooAbsCategory and defines a a single category state
CRooClassFactory	RooClassFactory is a clase like TTree::MakeClass() that generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names
CRooCustomizer
CRooFactoryWSTool	RooFactoryWSTool is a clase like TTree::MakeClass() that generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names
CRooFitResult
CRooFormula	RooFormula an implementation of ROOT::v5::TFormula that interfaces it to RooAbsArg value objects
CRooGrid	RooGrid is a utility class for RooMCIntegrator which implements an adaptive multi-dimensional Monte Carlo numerical integration, following the VEGAS algorithm
CRooNameSet	RooNameSet is a utility class that stores the names the objects in a RooArget
CRooNumGenConfig	RooNumGenConfig holds the configuration parameters of the various numeric integrators used by RooRealIntegral
CRooNumIntConfig	RooNumIntConfig holds the configuration parameters of the various numeric integrators used by RooRealIntegral
CRooPlot	A RooPlot is a plot frame and a container for graphics objects within that frame
►CRooPlotable	Class RooPotable is a base class for objects that can be inserted into RooPlots and take advantage of its internal normalization and axis range adjustment features
CRooCurve	A RooCurve is a one-dimensional graphical representation of a real-valued function
CRooEllipse	A RooEllipse is a two-dimensional ellipse that can be used to represent an error contour
CRooHist	A RooHist is a graphical representation of binned data based on the TGraphAsymmErrors class
CRooSimWSTool
CRooStats::LikelihoodIntervalPlot	This class provides simple and straightforward utilities to plot a LikelihoodInterval object
CRooStats::MCMCIntervalPlot	This class provides simple and straightforward utilities to plot a MCMCInterval object
►CRooStats::SamplingDistPlot	This class provides simple and straightforward utilities to plot SamplingDistribution objects
CRooStats::HypoTestPlot	This class provides the plots for the result of a study performed with any of the HypoTestCalculatorGeneric (e.g
►CRooTable	RooTable is the abstract interface for table objects
CRoo1DTable	Roo1DTable implements a one-dimensional table
CRooQuasiRandomGenerator	This 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
CRooRandom	This class provides a static interface for generating random numbers
CRooRealConstant	RooRealConstant provides static functions to create and keep track of RooRealVar constants
CRooSentinel	RooSentinel is a special purposes singleton class that terminates all other RooFit singleton services when the process exists
CRooStreamParser
CROOT::Math::RootFinder	User Class to find the Root of one dimensional functions
CRooTMathReg
CRooTrace	Class RooTrace controls the memory tracing hooks in all RooFit objects
CROOT::Math::Rotation3D	Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix
CROOT::Math::RotationX	Rotation class representing a 3D rotation about the X axis by the angle of rotation
CROOT::Math::RotationY	Rotation class representing a 3D rotation about the Y axis by the angle of rotation
CROOT::Math::RotationZ	Rotation class representing a 3D rotation about the Z axis by the angle of rotation
CROOT::Math::RotationZYX	Rotation 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::Detail::RDF::RRangeBase
CROOT::Detail::RDF::RRange< PrevData >
CROOT::RDF::RResultPtr< T >	Smart pointer for the return type of actions
Crsa_KEY
Crsa_KEY_export
Crsa_NUMBER
CROOT::RDF::RSnapshotOptions	A collection of options to steer the creation of the dataset on file
CTMVA::Rule	Implementation of a rule
CTMVA::RuleCut	A class describing a 'rule cut'
CTMVA::RuleEnsemble
CTMVA::RuleFit	A class implementing various fits of rule ensembles
CTMVA::RuleFitAPI	J Friedman's RuleFit method
CTMVA::RuleFitParams	A class doing the actual fitting of a linear model using rules as base functions
CROOT::VecOps::RVec< T >	A "std::vector"-like collection of values implementing handy operation to analyse them
CROOT::VecOps::RVec< ColumnValue_t >
CRooStats::HistFactory::Sample
CROOT::Experimental::TPadExtent::ScaleFactor	A scale factor (separate factors for horizontal and vertical) for scaling a TPadLength
CROOT::Experimental::TPadPos::ScaleFactor	A scale factor (separate factors for horizontal and vertical) for scaling a TPadLength
CROOT::MacOSX::Util::ScopedArray< T >
CMemstat::SCustomDigest
CROOT::Math::SDeterminant< n, idim >	Dsfact
CSegment_t
CROOT::Meta::Selection::SelectNoInstance	Used to avoid to select all instances of a template
►CTMVA::SeparationBase	An interface to calculate the "SeparationGain" for different separation criteria used in various training algorithms
CTMVA::CrossEntropy	Implementation of the CrossEntropy as separation criterion
CTMVA::GiniIndex	Implementation of the GiniIndex as separation criterion
CTMVA::GiniIndexWithLaplace	Implementation of the GiniIndex With Laplace correction as separation criterion
CTMVA::MisClassificationError	Implementation of the MisClassificationError as separation criterion
CTMVA::SdivSqrtSplusB	Implementation of the SdivSqrtSplusB as separation criterion
CTStreamerInfoActions::TActionSequence::SequencePtr
CXrdClientConn::SessionIDInfo
►CTMVA::DNN::Settings	Settings for the training of the neural net
CTMVA::DNN::ClassificationSettings	Settings for classificationused to distinguish between different function signatures
CSetWindowAttributes_t
CROOT::Detail::TCollectionProxyInfo::SfinaeHelper
CROOT::Internal::SHA256::sha256_t
CRooStats::HistFactory::ShapeFactor
CRooStats::HistFactory::EstimateSummary::ShapeSys
CRooStats::HistFactory::ShapeSys
CTString::ShortStr_t
CSHtmlExtensions_t
CSHtmlIndex_t
CSHtmlMargin_t
CSHtmlStyle_t
CSHtmlStyleStack_t
CSHtmlTokenMap_t
CROOT::Minuit2::SimplexParameters	Class describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process
CTMVA::SimulatedAnnealing	Base implementation of simulated annealing fitting procedure
CROOT::Minuit2::SinParameterTransformation	Class 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 >
CTEveCaloData::SliceInfo_t
CROOT::Math::SMatrix< T, D1, D2, R >	SMatrix: a generic fixed size D1 x D2 Matrix class
CROOT::Math::SMatrixIdentity
CROOT::Math::SMatrixNoInit
CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow
CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow_const
CRooNDKeysPdf::SorterTV_L2H	Do not persist
Cstd::__ROOT::span< T >
CSQLite3_Stmt_t
CROOT::Math::Sqr< T >	Unary Square Operation Class
CROOT::Math::Sqrt< T >	Unary Square Root Operation Class
CROOT::Minuit2::SqrtLowParameterTransformation	Transformation from external to internal Parameter based on sqrt(1 + x**2)
CROOT::Minuit2::SqrtUpParameterTransformation	Transformation from external to internal Parameter based on sqrt(1 + x**2)
CROOT::Minuit2::StackAllocator	StackAllocator controls the memory allocation/deallocation of Minuit
CROOT::Minuit2::StackAllocatorHolder
CROOT::Minuit2::StackError
CROOT::Minuit2::StackOverflow	Define stack allocator symbol
►CSTAT
CROOT::Experimental::Detail::THistData< DIMENSIONS, PRECISION, STORAGE, STAT >	A THistImplBase's data, provides accessors to all its statistics
CTMVA::StatDialogBDT
CTMVA::StatDialogBDTReg
CTMVA::StatDialogMVAEffs
CROOT::TVirtualRWMutex::State	Earlier lock state as returned by GetState() that can be passed to Restore()
CROOT::TVirtualRWMutex::StateDelta	State as returned by GetStateDelta() that can be passed to Restore()
CRooStats::HistFactory::StatError
CRooStats::HistFactory::StatErrorConfig
Cnlohmann::detail::static_const< T >
CROOT::Math::StdEngine< Generator >	Class to wrap engines fron the C++ standard random library in the ROOT Random interface
CROOT::Math::StdEngineType< Generator >
CROOT::Math::StdEngineType< std::knuth_b >
CROOT::Math::StdEngineType< std::minstd_rand >
CROOT::Math::StdEngineType< std::mt19937 >
CROOT::Math::StdEngineType< std::mt19937_64 >
CROOT::Math::StdEngineType< std::random_device >
CROOT::Math::StdEngineType< std::ranlux24 >
CROOT::Math::StdEngineType< std::ranlux48 >
CROOT::Math::StdRandomEngine
CTMVA::DNN::Steepest	Steepest Gradient Descent algorithm (SGD)
►Cstreambuf
CTGTextViewStreamBuf
CRooMsgService::StreamConfig
CTGenCollectionProxy::StreamHelper	Helper class to facilitate I/O
Cnlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::lexer::strtonum	Parse string into a built-in arithmetic type as if the current locale is POSIX
CTGDMLWrite::StructLst
CTGL5DPainter::Surf_t
CTInterpreter::SuspendAutoParsing
CROOT::Math::SVector< T, D >	SVector: a generic fixed size Vector class
CTMVA::SVEvent	Event class for Support Vector Machine
CTMVA::SVKernelFunction	Kernel for Support Vector Machine
CTMVA::SVKernelMatrix	Kernel matrix for Support Vector Machine
CTMVA::SVWorkingSet	Working class for Support Vector Machine
CROOT::Minuit2::sym
CSysInfo_t
CTGTableLayout::TableData_t
CtableDescriptor_st
►CTMVA::TActivation	Interface for TNeuron activation function classes
CTMVA::TActivationIdentity	Identity activation function for TNeuron
CTMVA::TActivationRadial	Radial basis activation function for ANN
CTMVA::TActivationReLU	Rectified Linear Unit activation function for TNeuron
CTMVA::TActivationSigmoid	Sigmoid activation function for TNeuron
CTMVA::TActivationTanh	Tanh activation function for ANN
CTMVA::TActivationChooser	Class for easily choosing activation functions
CROOT::TypeTraits::TakeFirstParameter< T >	Return first of possibly many template parameters
CROOT::TypeTraits::TakeFirstParameter< Template< T, Rest... > >
CROOT::TypeTraits::TakeFirstType< T, Rest >
CTAlienPackage
CTAnyPtr	Models a shared pointer or a unique pointer
►CTApplicationImp	ABC describing GUI independent application implementation protocol
CTRootApplication
CTArcBall	Implements the arc-ball rotation manipulator
►CTArray	Abstract array base class
►CTArrayC	Array of chars or bytes (8 bits per element)
CTH1C	1-D histogram with a byte per channel (see TH1 documentation)
CTH2C	2-D histogram with a byte per channel (see TH1 documentation)
►CTH3C	3-D histogram with a byte per channel (see TH1 documentation)
CTGLTH3Composition
►CTArrayD	Array of doubles (64 bits per element)
►CTH1D	1-D histogram with a double per channel (see TH1 documentation)}
CTProfile	Profile Histogram
►CTH2D	2-D histogram with a double per channel (see TH1 documentation)}
CTProfile2D	Profile2D histograms are used to display the mean value of Z and its RMS for each cell in X,Y
►CTH3D	3-D histogram with a double per channel (see TH1 documentation)}
CTProfile3D	Profile3D histograms are used to display the mean value of T and its RMS for each cell in X,Y,Z
►CTArrayF	Array of floats (32 bits per element)
CTH1F	1-D histogram with a float per channel (see TH1 documentation)}
CTH1K	TH1K class supports the nearest K Neighbours method, widely used in cluster analysis
CTH2F	2-D histogram with a float per channel (see TH1 documentation)}
CTH3F	3-D histogram with a float per channel (see TH1 documentation)}
►CTArrayI	Array of integers (32 bits per element)
CTH1I	1-D histogram with an int per channel (see TH1 documentation)}
CTH2I	2-D histogram with an int per channel (see TH1 documentation)}
CTH3I	3-D histogram with an int per channel (see TH1 documentation)}
CTArrayL	Array of longs (32 or 64 bits per element)
CTArrayL64	Array of long64s (64 bits per element)
►CTArrayS	Array of shorts (16 bits per element)
CTH1S	1-D histogram with a short per channel (see TH1 documentation)
CTH2S	2-D histogram with a short per channel (see TH1 documentation)
CTH3S	3-D histogram with a short per channel (see TH1 documentation)
CROOT::Internal::TArrayType< T, d >
CROOT::Internal::TArrayType< T, 0 >
CTASLogHandlerGuard
CTAtomicCount
CROOT::Internal::TAtomicPointer< T >	Helper class to manage atomic pointers
CROOT::Internal::TAtomicPointer< TObjArray *>
►CTAtt3D	Use this attribute class when an object should have 3D capabilities
CTEveArrow	Class used for display of a thick arrow
►CTEveCaloViz	Base class for calorimeter data visualization
CTEveCalo2D	Visualization of a calorimeter event data in 2D
CTEveCalo3D	Visualization of a calorimeter event data in 3D
CTEveCaloLego	Visualization of calorimeter data as eta/phi histogram
►CTEveDigitSet	Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox)
CTEveBoxSet	Collection of 3D primitives (fixed-size boxes, boxes of different sizes, or arbitrary sexto-epipeds, cones)
CTEveQuadSet	Supports various internal formats that result in rendering of a set of planar (lines, rectangles, hexagons with shared normal) objects
CTEveProjectionAxes	Axes for non-linear projections
►CTEveShape	Abstract base-class for 2D/3D shapes
CTEveBox	3D box with arbitrary vertices (cuboid)
CTEveBoxProjected	Projection of TEveBox
CTEveGeoShape	Wrapper 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)
CTEveGeoShapeProjected	A 3D projected TEveGeoShape
CTEveJetCone	Draws a jet cone with leading particle is specified in (eta,phi) and cone radius is given
CTEveJetConeProjected	Projection of TEveJetCone
CTEvePolygonSetProjected	A set of projected polygons
►CTEveStraightLineSet	Set of straight lines with optional markers along the lines
CTEveScalableStraightLineSet	Straight-line-set with extra scaling, useful for projectables that need to be scaled in accordance with an external object
CTEveStraightLineSetProjected	Projected replica of a TEveStraightLineSet
CTEveText	TEveElement class used for displaying FreeType GL fonts
CTEveTriangleSet	Made from a list of vertices and a list of triangles (triplets of vertex indices)
CTGeoOverlap	Base class describing geometry overlaps
►CTGeoVolume	TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes
CTGeoVolumeAssembly	Volume assemblies
CTGeoVolumeMulti	Volume families
►CTH3	The 3-D histogram classes derived from the 1-D histogram classes
CTH3C	3-D histogram with a byte per channel (see TH1 documentation)
CTH3D	3-D histogram with a double per channel (see TH1 documentation)}
CTH3F	3-D histogram with a float per channel (see TH1 documentation)}
CTH3I	3-D histogram with an int per channel (see TH1 documentation)}
CTH3S	3-D histogram with a short per channel (see TH1 documentation)
CTMarker3DBox	A special 3-D marker designed for event display
►CTNode	TNode description
CTNodeDiv	Description of parameters to divide a 3-D geometry object
►CTParticle	Description of the dynamic properties of a particle
CTEveMCTrack
►CTPolyLine3D	A 3-dimensional polyline
CTHelix	THelix has two different constructors
►CTPolyMarker3D	A 3D polymarker
►CTPointSet3D	TPolyMarker3D using TPointSet3DGL for direct OpenGL rendering
►CTEvePointSet	TEvePointSet 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)
►CTEveLine	An arbitrary polyline with fixed line and marker attributes
CTEveLineProjected	Projected copy of a TEveLine
►CTEveTrack	Visual representation of a track
CTEveTrackProjected	Projected copy of a TEveTrack
CTEvePointSetProjected	Projected copy of a TEvePointSet
CTPrimary	Old version of a dynamic particle class created by event generators
►CTShape	This is the base class for all geometry shapes
►CTBRIK	A box with faces perpendicular to the axes
CTGTRA	A general twisted trapezoid
CTPARA	A parallelepiped
CTTRAP	A general trapezoid
CTTRD1	A trapezoid with the x dimension varying along z
CTTRD2	A trapezoid with both x and y dimensions varying along z
►CTPCON	A polycone
CTPGON	A polygon
CTPolyLineShape
CTSPHE	A Sphere
►CTTUBE	A tube
CTCONE	A conical tube
CTELTU	A cylinder with an elliptical section
CTHYPE	An hyperboloid (not implemented)
►CTTUBS	A segment of a tube
CTCONS	A segment of a conical tube
CTCTUB	A cut tube with 11 parameters
CTXTRU	A poly-extrusion
CTVolume
CTVolumeView
►CTAttAxis	Manages histogram axis attributes
CTAxis	Class to manage histogram axis
CTEveProjectionAxes	Axes for non-linear projections
►CTAttBBox	Helper for management of bounding-box information
CTEveArrow	Class used for display of a thick arrow
CTEveCaloViz	Base class for calorimeter data visualization
CTEveDigitSet	Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox)
CTEveProjectionAxes	Axes for non-linear projections
CTEveProjectionManager	Manager class for steering of projections and managing projected objects
CTEveShape	Abstract base-class for 2D/3D shapes
CTEveStraightLineSet	Set of straight lines with optional markers along the lines
CTEveText	TEveElement class used for displaying FreeType GL fonts
CTEveTriangleSet	Made from a list of vertices and a list of triangles (triplets of vertex indices)
CTPointSet3D	TPolyMarker3D using TPointSet3DGL for direct OpenGL rendering
►CTAttBBox2D	Abstract base class for elements drawn in the editor
►CTBox	Create a Box
►CTPave	A TBox with a bordersize and a shadow option
CTLegend	This class displays a legend box (TPaveText) containing several legend entries
CTPaletteAxis	The palette painting class
►CTPaveLabel	A Pave (see TPave) with a text centered in the Pave
CTPaveClass	A TPaveLabel specialized to process classes inside a TClassTree
►CTPaveText	A Pave (see TPave) with text, lines or/and boxes inside
CTDiamond	Draw a Diamond
CTPaveStats	The histogram statistics painter class
CTPavesText	A PaveText (see TPaveText) with several stacked paves
►CTWbox	A TBox with a bordersize and a bordermode
CTFrame	Define a Frame
CTSliderBox	The moving box in a TSlider
►CTCurlyLine	Implements curly or wavy polylines used to draw Feynman diagrams
CTCurlyArc	Implements curly or wavy arcs used to draw Feynman diagrams
►CTEllipse	Draw Ellipses
CTArc	Create an Arc
CTCrown	To draw a Crown
►CTLine	A simple line
CTArrow	Draw all kinds of Arrows
CTASPaletteEditor::LimitLine
CTGaxis	The axis painter class
CTMarker	Manages Markers
►CTPad	The most important graphics class in the ROOT system
►CTButton	A TButton object is a user interface object
CTGroupButton	A specialized TButton used in a group of Buttons
►CTCanvas	The Canvas class
CTDialogCanvas	A canvas specialized to set attributes
CTInspectCanvas	A TInspectCanvas is a canvas specialized to inspect Root objects
CTEvePad	This was intended as a TPad wrapper to allow smart updates of groups of pads
CTSlider	A specialized TPad including a TSliderBox object
►CTText	Base class for several text objects
CTLatex	To draw Mathematical Formula
CTLink	Special TText object used to show hyperlinks
CTMathText	To draw TeX Mathematical Formula
CTAttCanvas	Manages canvas attributes
►CTAttFill	Fill Area Attributes class
CROOT::v5::TF1Data
CTArrow	Draw all kinds of Arrows
CTBox	Create a Box
►CTBranch	A TTree is a list of TBranches
CTBranchClones	A Branch for the case of an array of clone objects
CTBranchElement	A Branch for the case of an object
CTBranchObject	A Branch for the case of an object
CTBranchRef	A branch containing and managing a TRefTable for TRef autoloading
CTBranchSTL	A Branch handling STL collection of pointers (vectors, lists, queues, sets and multisets) while storing them in split mode
CTHbookBranch	HBOOK Branch
CTCandle	The candle plot painter class
CTEfficiency	Class to handle efficiency histograms
CTEllipse	Draw Ellipses
►CTF1	1-Dim function class
CTF12	A projection of a TF2 along X or Y
►CTF2	A 2-Dim function with parameters
CTF3	A 3-Dim function with parameters
CTGeoBatemanSol
►CTGeoMaterial	Base class describing materials
CTGeoMixture	Mixtures of elements
CTGeoOverlap	Base class describing geometry overlaps
CTGeoVolume	TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes
►CTGraph	A Graph is a graphics object made of two arrays X and Y with npoints each
CRooCurve	A RooCurve is a one-dimensional graphical representation of a real-valued function
CRooEllipse	A RooEllipse is a two-dimensional ellipse that can be used to represent an error contour
CTCutG	Graphical cut class
►CTGraphAsymmErrors	TGraph with asymmetric error bars
CRooHist	A RooHist is a graphical representation of binned data based on the TGraphAsymmErrors class
CTGraphBentErrors	A TGraphBentErrors is a TGraph with bent, assymetric error bars
►CTGraphErrors	A TGraphErrors is a TGraph with error bars
CTGraphPolar	To draw a polar graph
CTGraphQQ	This class allows to draw quantile-quantile plots
►CTGraph2D	Graphics object made of three arrays X, Y and Z with the same number of points each
CTGraph2DErrors	Graph 2D class with errors
CTGraphNode	A graph node object which can be added in a TGraphStruct
►CTH1	The TH1 histogram class
CTH1C	1-D histogram with a byte per channel (see TH1 documentation)
CTH1D	1-D histogram with a double per channel (see TH1 documentation)}
CTH1F	1-D histogram with a float per channel (see TH1 documentation)}
CTH1I	1-D histogram with an int per channel (see TH1 documentation)}
CTH1K	TH1K class supports the nearest K Neighbours method, widely used in cluster analysis
CTH1S	1-D histogram with a short per channel (see TH1 documentation)
►CTH2	Service class for 2-Dim histogram classes
CTH2C	2-D histogram with a byte per channel (see TH1 documentation)
CTH2D	2-D histogram with a double per channel (see TH1 documentation)}
CTH2F	2-D histogram with a float per channel (see TH1 documentation)}
CTH2I	2-D histogram with an int per channel (see TH1 documentation)}
►CTH2Poly	2D Histogram with Polygonal Bins
CTProfile2Poly	2D Profile Histogram with Polygonal Bins
CTH2S	2-D histogram with a short per channel (see TH1 documentation)
CTH3	The 3-D histogram classes derived from the 1-D histogram classes
CTLegendEntry	Storage class for one entry of a TLegend
CTMarker3DBox	A special 3-D marker designed for event display
►CTMaterial	Manages a detector material
CTMixture	Manages a detector mixture
CTMathText	To draw TeX Mathematical Formula
CTNode	TNode description
CTPainter3dAlgorithms	The Legos and Surfaces painter class
CTParallelCoordVar	TParallelCoord axes
CTPieSlice	A slice of a piechart, see the TPie class
►CTPolyLine	Defined by an array on N points in a 2-D space
CTCurlyLine	Implements curly or wavy polylines used to draw Feynman diagrams
CTShape	This is the base class for all geometry shapes
CTSpider	Spider class
►CTSpline	Base class for spline implementation containing the Draw/Paint methods
CTMVA::TSpline1	Linear interpolation of TGraph
CTMVA::TSpline2	Quadratic interpolation of TGraph
CTSpline3	Class to create third splines to interpolate knots Arbitrary conditions can be introduced for first and second derivatives at beginning and ending points
CTSpline5	Class to create quintic natural splines to interpolate knots Arbitrary conditions can be introduced for first and second derivatives using double knots (see BuildCoeff) for more on this
CTStyle	TStyle objects may be created to define special styles
►CTTree	A TTree object has a header with a name and a title
►CTChain	A chain is a collection of files containing TTree objects
CTProofChain
CTHbookTree	A wrapper class supporting Hbook ntuples (CWN and RWN)
CTNtuple	A simple TTree restricted to a list of float variables only
CTNtupleD	A simple TTree restricted to a list of double variables only
CTTreeSQL	Implement TTree for a SQL backend
►CTVirtualPad	TVirtualPad is an abstract base class for the Pad and Canvas classes
CTPad	The most important graphics class in the ROOT system
►CTVirtualPS	TVirtualPS is an abstract interface to Postscript, PDF, SVG
CTImageDump	Save canvas as an image (GIF, JPEG, PNG, XPM, TIFF etc.)
CTPDF	Interface to PDF
CTPostScript	Interface to PostScript
CTSVG	Interface to SVG
CTTeXDump	Interface to TeX
►CTVirtualX	Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...)
►CTGCocoa	This class implements TVirtualX interface for MacOS X, using Cocoa and Quartz 2D
CTGQuartz	This is non-GUI part of TVirtualX interface, implemented for MacOS X, using CoreGraphics (Quartz)
CTGWin32	This class is the basic interface to the Win32 graphics system
CTGWin32VirtualXProxy
►CTGX11	This class is the basic interface to the X11 (Xlib) graphics system
CTGX11TTF	Interface to low level X11 (Xlib)
CTVolume
►CTAttImage	TImage attributes
►CTImage	An abstract interface to image processing library
CTASImage	Image class
►CTAttLine	Line Attributes class
CROOT::v5::TF1Data
CTBox	Create a Box
CTCandle	The candle plot painter class
CTEfficiency	Class to handle efficiency histograms
CTEllipse	Draw Ellipses
CTEveLine	An arbitrary polyline with fixed line and marker attributes
CTEveStraightLineSet	Set of straight lines with optional markers along the lines
►CTEveTrackList	A list of tracks supporting change of common attributes and selection based on track parameters
CTEveTrackListProjected	Specialization of TEveTrackList for holding TEveTrackProjected objects
CTF1	1-Dim function class
CTGeoBatemanSol
CTGeoOverlap	Base class describing geometry overlaps
CTGeoPhysicalNode	Physical nodes are the actual 'touchable' objects in the geometry, representing a path of positioned volumes starting with the top node: path=/TOP/A_1/B_4/C_3 , where A, B, C represent names of volumes
CTGeoVolume	TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes
CTGLAxis	GL Axis
CTGraph	A Graph is a graphics object made of two arrays X and Y with npoints each
CTGraph2D	Graphics object made of three arrays X, Y and Z with the same number of points each
CTGraphEdge	An edge object connecting two nodes which can be added in a TGraphStruct
CTGraphNode	A graph node object which can be added in a TGraphStruct
CTGraphPolargram	To draw polar axis
CTH1	The TH1 histogram class
CTLatex	To draw Mathematical Formula
CTLegendEntry	Storage class for one entry of a TLegend
CTLine	A simple line
CTMarker3DBox	A special 3-D marker designed for event display
CTMCParticle	This class serves as a data storage for description of one particle
CTNode	TNode description
CTPainter3dAlgorithms	The Legos and Surfaces painter class
CTParallelCoordRange	A TParallelCoordRange is a range used for parallel coordinates plots
CTParallelCoordSelect	A TParallelCoordSelect is a specialised TList to hold TParallelCoordRanges used by TParallelCoord
CTParallelCoordVar	TParallelCoord axes
CTParticle	Description of the dynamic properties of a particle
CTPieSlice	A slice of a piechart, see the TPie class
CTPolyLine	Defined by an array on N points in a 2-D space
CTPolyLine3D	A 3-dimensional polyline
CTPrimary	Old version of a dynamic particle class created by event generators
CTShape	This is the base class for all geometry shapes
CTSpider	Spider class
CTSpline	Base class for spline implementation containing the Draw/Paint methods
CTStyle	TStyle objects may be created to define special styles
CTTree	A TTree object has a header with a name and a title
►CTView	See TView3D
CTView3D	The 3D view class
►CTVirtualGeoTrack	Base class for user-defined tracks attached to a geometry
CTGeoTrack	Class for user-defined tracks attached to a geometry
CTVirtualPad	TVirtualPad is an abstract base class for the Pad and Canvas classes
CTVirtualPS	TVirtualPS is an abstract interface to Postscript, PDF, SVG
CTVirtualX	Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...)
CTVolume
►CTAttMarker	Marker Attributes class
CROOT::v5::TF1Data
CTCandle	The candle plot painter class
CTEfficiency	Class to handle efficiency histograms
CTEvePointSetArray	An array of point-sets with each point-set playing a role of a bin in a histogram
CTEveStraightLineSet	Set of straight lines with optional markers along the lines
CTEveTrackList	A list of tracks supporting change of common attributes and selection based on track parameters
CTF1	1-Dim function class
CTGeoBatemanSol
CTGraph	A Graph is a graphics object made of two arrays X and Y with npoints each
CTGraph2D	Graphics object made of three arrays X, Y and Z with the same number of points each
CTH1	The TH1 histogram class
CTLegendEntry	Storage class for one entry of a TLegend
CTMarker	Manages Markers
CTPolyLineShape
CTPolyMarker	A PolyMarker is defined by an array on N points in a 2-D space
CTPolyMarker3D	A 3D polymarker
CTSpline	Base class for spline implementation containing the Draw/Paint methods
CTStyle	TStyle objects may be created to define special styles
CTTree	A TTree object has a header with a name and a title
CTVirtualGeoTrack	Base class for user-defined tracks attached to a geometry
CTVirtualPS	TVirtualPS is an abstract interface to Postscript, PDF, SVG
CTVirtualX	Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...)
►CTAttPad	Manages default Pad attributes
CTVirtualPad	TVirtualPad is an abstract base class for the Pad and Canvas classes
►CTAttText	Text Attributes class
CTAxisModLab	TAxis helper class used to store the modified labels
CTButton	A TButton object is a user interface object
CTDialogCanvas	A canvas specialized to set attributes
CTGaxis	The axis painter class
CTGLAxis	GL Axis
CTGLText	GL Text
CTGraphNode	A graph node object which can be added in a TGraphStruct
CTGraphPolargram	To draw polar axis
CTInspectCanvas	A TInspectCanvas is a canvas specialized to inspect Root objects
CTLegend	This class displays a legend box (TPaveText) containing several legend entries
CTLegendEntry	Storage class for one entry of a TLegend
CTPaveLabel	A Pave (see TPave) with a text centered in the Pave
CTPaveText	A Pave (see TPave) with text, lines or/and boxes inside
CTPie	Draw a Pie Chart,
CTStyle	TStyle objects may be created to define special styles
CTText	Base class for several text objects
CTVirtualPS	TVirtualPS is an abstract interface to Postscript, PDF, SVG
CTVirtualX	Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...)
►CROOT::Experimental::TAxisBase	Histogram axis base class
CROOT::Experimental::TAxisConfig	Objects used to configure the different axis types
►CROOT::Experimental::TAxisEquidistant	Axis with equidistant bin borders
►CROOT::Experimental::TAxisGrow	An axis that can extend its range, keeping the number of its bins unchanged
CROOT::Experimental::TAxisLabels	A TAxisGrow that has a label assigned to each bin and a bin width of 1
CROOT::Experimental::TAxisIrregular	An axis with non-equidistant bins (also known as "variable binning")
CROOT::Experimental::TAxisView	Common view on a TAxis, no matter what its kind
CTBase64	This code implements the Base64 encoding and decoding
CTMVA::DNN::TBatch< AArchitecture >	TBatch
CTMVA::DNN::TBatchIterator< Data_t, AArchitecture >	TBatchIterator
CROOT::Experimental::THistStatTotalSumOfWeights< DIMENSIONS, PRECISION, STORAGE >::TBinStat	No-op; this class does not provide per-bin statistics
CROOT::Experimental::THistStatUncertainty< DIMENSIONS, PRECISION, STORAGE >::TBinStat	Modifying view on a THistStatUncertainty for a given bin
CROOT::Experimental::THistDataMomentUncert< DIMENSIONS, PRECISION, STORAGE >::TBinStat	No-op; this class does not provide per-bin statistics
CROOT::Experimental::THistStatRuntime< DIMENSIONS, PRECISION, STORAGE >::TBinStat	No-op; this class does not provide per-bin statistics
CROOT::Experimental::THistStatContent< DIMENSIONS, PRECISION, STORAGE >::TBinStat	Modifying view on a THistStatContent for a given bin
CROOT::Experimental::THistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION, STORAGE >::TBinStat	No-op; this class does not provide per-bin statistics
CROOT::Internal::TBranchCacheInfo
CROOT::Internal::TBranchIMTHelper
►CROOT::Detail::TBranchProxy	Base class for all the proxy object
CROOT::Internal::TArrayCharProxy
CROOT::Internal::TArrayProxy< T >
►CROOT::Internal::TClaProxy
CROOT::Internal::TClaArrayProxy< T >
CROOT::Internal::TClaImpProxy< T >
CROOT::Internal::TImpProxy< T >
►CROOT::Internal::TStlProxy
CROOT::Internal::TStlArrayProxy< T >
CROOT::Internal::TStlImpProxy< T >
CROOT::Internal::TBranchProxyDirector
CROOT::Internal::TBranchProxyHelper
►CTBrowserImp	ABC describing GUI independent browser implementation protocol
CTGFileBrowser
►CTRootBrowser
CTEveBrowser	Specialization of TRootBrowser for Eve
CTRootBrowserLite
CTBtItem	Item stored in inner nodes of a TBtree
►CTBtNode	Abstract base class (ABC) of a TBtree node
CTBtInnerNode	Inner node of a TBtree
CTBtLeafNode	Leaf node of a TBtree
CTBuffer3DTypes
CROOT::Experimental::TBufferMerger	TBufferMerger is a class to facilitate writing data in parallel from multiple threads, while writing to a single output file
CTOracleStatement::TBufferRec
CROOT::Detail::RDF::RLoopManager::TCallback
CPyROOT::TCallContext
►CTCanvasImp	ABC describing GUI independent main window (with menubar, scrollbars and a drawing area)
CTQCanvasImp
CTRootCanvas
►CROOT::Internal::TCDGIILIBase
CROOT::Internal::ClassDefGenerateInitInstanceLocalInjector< T >
CRgl::Mc::TCell< V >
CRgl::Mc::TCell< ElementType_t >
CTChainIndex::TChainIndexEntry	Holds a description of indices of trees in the chain
CTCL
CROOT::Internal::TClaObjProxy< T >
CTClassRef	TClassRef is used to implement a permanent reference to a TClass object
►CTClassStreamer
CTCollectionClassStreamer	Class streamer object to implement TClassStreamer functionality for I/O emulation
CTProofPlayer::TCleanup
CTTree::TClusterIterator	Helper class to iterate over cluster of baskets
CTCollectionProxyFactory	TCollectionProxyFactory Interface to collection proxy and streamer generator
CROOT::Detail::TCollectionProxyInfo
►CTCollectionStreamer	Class streamer object to implement TClassStreamer functionality for I/O emulation
CTCollectionClassStreamer	Class streamer object to implement TClassStreamer functionality for I/O emulation
CTCollectionMemberStreamer	Class streamer object to implement TMemberStreamer functionality for I/O emulation
CTGLUtil::TColorLocker
CROOT::Internal::RDF::TColumnValue< T, MustUseRVec >	Helper class that updates and returns TTree branches as well as RDataFrame temporary columns
CTStreamerInfo::TCompInfo
CTComplex
CTStreamerInfoActions::TConfiguration	Base class of the Configurations
CROOT::Experimental::THistStatUncertainty< DIMENSIONS, PRECISION, STORAGE >::TConstBinStat	Const view on a THistStatUncertainty for a given bin
CROOT::Experimental::THistStatContent< DIMENSIONS, PRECISION, STORAGE >::TConstBinStat	Const view on a THistStatContent for a given bin
CTDirectory::TContext
►CTContextMenuImp	This class provides an interface to GUI independent context sensitive popup menus
CTRootContextMenu
►CTControlBarImp	ABC describing GUI independent control bar
CTRootControlBar
►CPyROOT::TConverter
►CPyROOT::TCStringConverter
►CPyROOT::TNonConstCStringConverter
CPyROOT::TNonConstUCStringConverter
CPyROOT::TNotImplementedConverter
CPyROOT::TRefCppObjectConverter
CPyROOT::TSmartPtrCppObjectConverter
CPyROOT::TSTLIteratorConverter
►CPyROOT::TVoidArrayConverter
►CPyROOT::TCppObjectConverter
CPyROOT::TCppObjectArrayConverter
CPyROOT::TCppObjectPtrConverter< ISREFERENCE >
►CPyROOT::TStrictCppObjectConverter
CPyROOT::TValueCppObjectConverter
CPyROOT::TLongLongArrayConverter
CPyROOT::TVoidConverter
CPyROOT::TVoidPtrPtrConverter
CPyROOT::TVoidPtrRefConverter
CTMVA::DNN::TCpu< AReal >	The TCpu architecture class
CTMVA::DNN::TCpuBuffer< AFloat >	TCpuBuffer
CTMVA::DNN::TCpuMatrix< AFloat >	The TCpuMatrix class
CTCreatePrimitives	Creates new primitives
CTMVA::DNN::TCuda< AFloat >	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
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 >
CTDatime	This 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::TCudaDeviceBuffer< AFloat >::TDestructor
CTMVA::DNN::TCpuBuffer< AFloat >::TDestructor
CTMVA::DNN::TCudaHostBuffer< AFloat >::TDestructor
CTMVA::DNN::TDevice	TDevice
►CROOT::Experimental::TDirectory	Key/value store of objects
CROOT::Experimental::TFile	A ROOT file
CROOT::Experimental::Internal::TDirectoryEntry
►CTDisplayItem
CROOT::Experimental::TObjectDisplayItem
CROOT::Experimental::TPadDisplayItem	Display item for the pad Includes different graphical properties of the pad itself plus list of created items for all primitives
CTMVA::DNN::TDLGradientDescent< Architecture_t >
►CROOT::Experimental::TDrawable	Base class for drawable entities: objects that can be painted on a TPad
►CROOT::Experimental::TDrawableBase< DERIVED >
CROOT::Experimental::THistDrawableBase< DERIVED >
►CROOT::Experimental::TDrawableBase< THistDrawable< DIMENSIONS > >
►CROOT::Experimental::THistDrawableBase< THistDrawable< DIMENSIONS > >
CROOT::Experimental::THistDrawable< DIMENSIONS >
►CROOT::Experimental::TDrawableBase< TObjectDrawable >
CROOT::Experimental::TObjectDrawable
►CROOT::Experimental::TDrawableBase< TPadDrawable >
CROOT::Experimental::TPadDrawable	Draw a TPad, by drawing its contained graphical elements at the pad offset in the parent pad
►CTDrawingOptsBase
CROOT::Experimental::TFrame::DrawingOpts
CROOT::Experimental::THistDrawingOpts< 1 >	Drawing options for a 1D histogram
CROOT::Experimental::THistDrawingOpts< 2 >	Drawing options for a 2D histogram
CROOT::Experimental::THistDrawingOpts< 3 >	Drawing options for a 3D histogram
CROOT::Experimental::TObjectDrawingOpts
CROOT::Experimental::TPadDrawingOpts	Drawing options for a TPad
CTGLUtil::TDrawQualityModifier
CTGLUtil::TDrawQualityScaler
CTDsKey
CTElementActionT< Element >
CTElementPosActionT< Element >
►Ctemplate __pmake< _Np >
CROOT::Detail::__make< _Np >
CPyROOT::TemplateProxy	Template proxy object to return functions and methods
CROOT::Math::TensorMulOp< Vector1, Vector2 >	Class for Tensor Multiplication (outer product) of two vectors giving a matrix
CRgl::Pad::Tesselator
Ctest.test
►CRooStats::TestStatistic	TestStatistic is an interface class to provide a facility for construction test statistics distributions to the NeymanConstruction class
CRooStats::DebuggingTestStat
CRooStats::MaxLikelihoodEstimateTestStat	MaxLikelihoodEstimateTestStat: TestStatistic that returns maximum likelihood estimate of a specified parameter
CRooStats::MinNLLTestStat	MinNLLTestStat is an implementation of the TestStatistic interface that calculates the minimum value of the negative log likelihood function and returns it as a test statistic
CRooStats::NumEventsTestStat	NumEventsTestStat is a simple implementation of the TestStatistic interface used for simple number counting
CRooStats::ProfileLikelihoodTestStat	ProfileLikelihoodTestStat is an implementation of the TestStatistic interface that calculates the profile likelihood ratio at a particular parameter point given a dataset
CRooStats::RatioOfProfiledLikelihoodsTestStat	TestStatistic that returns the ratio of profiled likelihoods
CRooStats::SimpleLikelihoodRatioTestStat	TestStatistic class that returns -log(L[null] / L[alt]) where L is the likelihood
►CRooStats::TestStatSampler	TestStatSampler is an interface class for a tools which produce RooStats SamplingDistributions
CRooStats::DebuggingSampler
►CRooStats::ToyMCSampler	ToyMCSampler is an implementation of the TestStatSampler interface
CRooStats::ToyMCImportanceSampler	ToyMCImportanceSampler is an extension of the ToyMCSampler for Importance Sampling
►CTEveChunkManager	Vector-like container with chunked memory allocation
CTEveChunkVector< T >
►CTEveElement	Base class for TEveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management
CTEveArrow	Class used for display of a thick arrow
►CTEveCaloData	A central manager for calorimeter event data
CTEveCaloDataHist	A central manager for calorimeter data of an event written in TH2F
CTEveCaloDataVec	Calo data for universal cell geometry
CTEveCaloViz	Base class for calorimeter data visualization
CTEveDigitSet	Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox)
►CTEveElementList	A list of TEveElements
►CTEveCompound	Description of TEveCompound
CTEveCompoundProjected	Description of TEveCompoundProjected
CTEveElementListProjected	A projected element list – required for proper propagation of render state to projected views
CTEveEventManager	Base class for event management and navigation
CTEvePlot3D	Description of TEvePlot3D
CTEveProjectionManager	Manager class for steering of projections and managing projected objects
CTEveScene	Eve representation of TGLScene
CTEveSceneList	List of Scenes providing common operations on TEveScene collections
CTEveSelection	Make sure there is a SINGLE running TEveSelection for each selection type (select/highlight)
CTEveShape	Abstract base-class for 2D/3D shapes
CTEveTrackList	A list of tracks supporting change of common attributes and selection based on track parameters
CTEveTrackPropagator	Holding structure for a number of track rendering parameters
CTEveTriangleSet	Made from a list of vertices and a list of triangles (triplets of vertex indices)
CTEveViewerList	List of Viewers providing common operations on TEveViewer collections
►CTEveWindow	Abstract base-class for representing eve-windows
►CTEveWindowFrame	Encapsulates TGFrame into an eve-window
CTEveViewer	Eve representation of TGLViewer
CTEveWindowPack	Encapsulates TGPack into an eve-window
CTEveWindowSlot	Description of TEveWindowSlot
CTEveWindowTab	Encapsulates TGTab into an eve-window
CTEveWindowManager	Manager for EVE windows
CTEveElementObjectPtr	TEveElement with external TObject as a holder of visualization data
►CTEveGeoNode	Wrapper for TGeoNode that allows it to be shown in GUI and controlled as a TEveElement
CTEveGeoTopNode	A wrapper over a TGeoNode, possibly displaced with a global trasformation stored in TEveElement
CTEveParamList	Collection of named parameters
CTEvePointSet	TEvePointSet 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)
CTEvePointSetArray	An array of point-sets with each point-set playing a role of a bin in a histogram
CTEveProjectionAxes	Axes for non-linear projections
CTEveSceneInfo	TEveUtil representation of TGLSceneInfo
CTEveStraightLineSet	Set of straight lines with optional markers along the lines
CTEveText	TEveElement class used for displaying FreeType GL fonts
CTEveFrameBoxGL	A class encapsulating GL rendering of TEveFrameBox via a static member function
CTEveGeoManagerHolder	Exception safe wrapper for setting gGeoManager
CTEveElement::TEveListTreeInfo	Structure holding information about TGListTree and TGListTreeItem that represents given TEveElement
►CTEveMagField	Abstract base-class for interfacing to magnetic field needed by the TEveTrackPropagator
CTEveMagFieldConst	Implements constant magnetic field, given by a vector fB
CTEveMagFieldDuo	Implements constant magnetic filed that switches on given axial radius fR2 from vector fBIn to fBOut
CTEveManager	Central application manager for Eve
CTEvePadHolder	Exception safe wrapper for setting gPad
CTEvePathMarkT< TT >	Special-point on track:
►CTEvePointSelectorConsumer	TEvePointSelectorConsumer is a virtual base for classes that can be filled from TTree data via the TEvePointSelector class
CTEvePointSet	TEvePointSet 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)
CTEvePointSetArray	An array of point-sets with each point-set playing a role of a bin in a histogram
►CTEveProjectable	Abstract base-class for non-linear projectable objects
CTEveCaloViz	Base class for calorimeter data visualization
CTEveElementList	A list of TEveElements
CTEvePointSet	TEvePointSet 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)
CTEveStraightLineSet	Set of straight lines with optional markers along the lines
►CTEveProjected	Abstract base class for classes that hold results of a non-linear projection transformation
CTEveBoxProjected	Projection of TEveBox
CTEveCalo2D	Visualization of a calorimeter event data in 2D
CTEveCompoundProjected	Description of TEveCompoundProjected
CTEveElementListProjected	A projected element list – required for proper propagation of render state to projected views
CTEveGeoShapeProjected	A 3D projected TEveGeoShape
CTEveJetConeProjected	Projection of TEveJetCone
CTEveLineProjected	Projected copy of a TEveLine
CTEvePointSetProjected	Projected copy of a TEvePointSet
CTEvePolygonSetProjected	A set of projected polygons
CTEveStraightLineSetProjected	Projected replica of a TEveStraightLineSet
CTEveTrackListProjected	Specialization of TEveTrackList for holding TEveTrackProjected objects
CTEveTrackProjected	Projected copy of a TEveTrack
►CTEveProjection	Base-class for non-linear projections
CTEve3DProjection	3D scaling projection
CTEveRhoZProjection	Transformation from 3D to 2D
CTEveRPhiProjection	XY projection with distortion around given center
►CTEveRefCnt	Base-class for reference-counted objects
►CTEveRefBackPtr	Base-class for reference-counted objects with reverse references to TEveElement objects
CTEveFrameBox	Description of a 2D or 3D frame that can be used to visually group a set of objects
CTEveTrackPropagator	Holding structure for a number of track rendering parameters
CTEveRGBAPalette	A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes
►CTEveSecondarySelectable	Semi-abstract interface for classes supporting secondary-selection
CTEveDigitSet	Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox)
CTEveUtil	Standard utility functions for Eve
CTEveVector2T< TT >	Minimal, templated two-vector
►CTEveVectorT< TT >	Minimal, templated three-vector
CTEveVector4T< TT >	Minimal, templated four-vector
CTEveVectorT< Double_t >
CTEveVectorT< Float_t >
►CPyROOT::TExecutor
►CPyROOT::TCppObjectBySmartPtrExecutor
CPyROOT::TCppObjectBySmartPtrPtrExecutor
►CPyROOT::TCppObjectExecutor
CPyROOT::TCppObjectArrayExecutor
CPyROOT::TCppObjectByValueExecutor
CPyROOT::TCppObjectPtrPtrExecutor
CPyROOT::TCppObjectPtrRefExecutor
►CPyROOT::TRefExecutor
CPyROOT::TCppObjectBySmartPtrRefExecutor
CPyROOT::TCppObjectRefExecutor
CROOT::TExecutor< subc >	This class defines an interface to execute the same task multiple times in parallel, possibly with different arguments every time
►CROOT::TExecutor< TProcessExecutor >
CROOT::TProcessExecutor	This class provides a simple interface to execute the same task multiple times in parallel, possibly with different arguments every time
►CROOT::TExecutor< TSequentialExecutor >
CROOT::TSequentialExecutor
►CROOT::TExecutor< TThreadExecutor >
CROOT::TThreadExecutor	This class provides a simple interface to execute the same task multiple times in parallel, possibly with different arguments every time
CTExMapIter
CROOT::Quartz::TextLine
CTLatex::TextSpec_t	TLatex 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 * >
►CTF1::TF1FunctorPointer
CTF1::TF1FunctorPointerImpl< T >
CTF1Parameters	TF1 Parameters class
CTFileMergeInfo
CROOT::Experimental::TFilePtr	Points to an object that stores or reads objects in ROOT's binary format
CROOT::Experimental::Internal::TFillBinCoord< I, COORD, AXES >	Fill coord with low bin edge or center or high bin edge of all axes
CROOT::Experimental::Internal::TFillBinCoord<-1, COORD, AXES >
CROOT::Experimental::Internal::TFillIterRange< I, AXES >	Fill range with begin() and end() of all axes, including under/overflow as specified by over
CROOT::Experimental::Internal::TFillIterRange<-1, AXES >
CROOT::Experimental::TFitResult
CTFitResultPtr	Provides an indirection to the TFitResult class and with a semantics identical to a TFitResult pointer, i.e
CTFormulaFunction	Helper class for TFormula
CTFormulaParamOrder	Functor defining the parameter order
CTFormulaVariable	Another helper class for TFormula
CROOT::Experimental::TFrame	Holds a user coordinate system with a palette
CTTree::TFriendLock	Helper class to prevent infinite recursion in the usage of TTree Friends
CROOT::Internal::TFriendProxy
CROOT::Experimental::TFunction< DIMENSION >
►CROOT::Detail::TFutureImpl< T >
CROOT::Experimental::TFuture< T >	A TFuture class. It can wrap an std::future
CTGDimension
CTGDMAssignmentHelper< T >
CROOT::TGenericClassInfo
►CTGenericCollectionIterator
CTGenericCollectionIterator::RegularIterator
CTGenericCollectionIterator::VectorIterator
►CTGeoAtt	Visualization and tracking attributes for volumes and nodes
►CTGeoNode	A node represent a volume positioned inside another.They store links to both volumes and to the TGeoMatrix representing the relative positioning
CTGeoNodeMatrix	A node containing local transformation
CTGeoNodeOffset	Node containing an offset
CTGeoVolume	TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes
CTVirtualGeoTrack	Base class for user-defined tracks attached to a geometry
CTGeoElemIter	Iterator for decay branches
CTGeoIterator	A geometry iterator
CTGeoRCPtr< T >	A reference counting-managed pointer for classes derived from TGeoExtension which can be used as C pointer
CTGeoStateInfo	Statefull info for the current geometry level
CTGeoToOCC	This class contains implementation of converting ROOT's geometry shapes to OpenCascade shapes
CROOT::Experimental::Internal::TGetBinCount< I, AXES >
CROOT::Experimental::Internal::TGetBinCount< 0, AXES >
CROOT::Experimental::Internal::TGetBinIndex< I, HISTIMPL, AXES, GROW >
CROOT::Experimental::Internal::TGetBinIndex<-1, HISTIMPL, AXES, GROW >
CTGFileInfo
CTGInsets
►CTGLAxisPainter
CTGLAxisPainterBox	Utility class to paint axis in GL
CTGLBoundingBox	Concrete class describing an orientated (free) or axis aligned box of 8 vertices
CTGLBoxCut	Used by plot-painters to determine the area of the plot that is cut away
CTGLCapabilityEnabler
CTGLCapabilitySwitch
CTGLColor	Class encapsulating color information in preferred GL format - an array of four unsigned bytes
CTGLColorSet	Class encapsulating a set of colors used throughout standard rendering
CTGLContext	This class encapsulates window-system specific information about a GL-context and alows their proper management in ROOT
CTGLContextIdentity	Identifier of a shared GL-context
CTGLContextPrivate
CTGLDisableGuard
CTGLEnableGuard
CTGLFaderHelper
CTGLFBO	Frame-buffer object
CTGLFloatHolder
CTGLFont	A wrapper class for FTFont
CTGLFontManager	A FreeType GL font manager
CTGLFormat	Encapsulation of format / contents of an OpenGL buffer
►CTGListTreeItem
CTEveListTreeItem	Special list-tree-item for Eve
CTGListTreeItemStd
CTGLLevelPalette
CTGLLine3	3D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex'
►CTGLLockable	Simple locking interface used by viewer and scene
►CTGLSceneBase	Scene base-class – provides basic interface expected by the TGLViewer or its sub-classes:
►CTGLScene	TGLScene provides management and rendering of ROOT's default 3D /object representation as logical and physical shapes
CTGLScenePad	Implements VirtualViewer3D interface and fills the base-class visualization structures from pad contents
►CTGLViewerBase	Base class for GL viewers
►CTGLViewer	Base GL viewer object - used by both standalone and embedded (in pad) GL
CTGLEmbeddedViewer	Minimal GL-viewer that can be embedded in a standard ROOT frames
CTGLSAViewer	The top level standalone GL-viewer - created via plugin manager
►CTGLLogicalShape	Abstract logical shape - a GL 'drawable' - base for all shapes - faceset sphere etc
CTGLCylinder	Implements a native ROOT-GL cylinder that can be rendered at different levels of detail
CTGLFaceSet	Implements a native ROOT-GL representation of an arbitrary set of polygons
►CTGLObject	Base-class for direct OpenGL renderers
CTEveArrowGL	OpenGL renderer class for TEveArrow
CTEveBoxGL	OpenGL renderer class for TEveBox
CTEveBoxProjectedGL	OpenGL renderer class for TEveBoxProjected
CTEveCalo2DGL	OpenGL renderer class for TEveCalo2D
CTEveCalo3DGL	OpenGL renderer class for TEveCalo3D
CTEveCaloLegoGL	OpenGL renderer class for TEveCaloLego
►CTEveDigitSetGL	OpenGL renderer class for TEveDigitSet
CTEveBoxSetGL	A GL rendering class for TEveBoxSet
CTEveQuadSetGL	GL-renderer for TEveQuadSet class
►CTEveJetConeGL	OpenGL renderer class for TEveJetCone
CTEveJetConeProjectedGL	OpenGL renderer class for TEveJetConeProjected
CTEvePlot3DGL	OpenGL renderer class for TEvePlot3D
CTEvePolygonSetProjectedGL	GL-renderer for TEvePolygonSetProjected class
CTEveProjectionAxesGL	OpenGL renderer class for TEveProjectionAxes
CTEveStraightLineSetGL	GL-renderer for TEveStraightLineSet class
CTEveTextGL	OpenGL renderer class for TEveText
CTEveTriangleSetGL	GL-renderer for TEveTriangleSet class
►CTGLPlot3D	Description of TGLPlot3D
CTF2GL	GL renderer for TF2
CTGLParametricEquationGL	GL-renderer wrapper for TGLParametricEquation
CTH2GL	Rendering of TH2 and derived classes
CTH3GL	OpenGL renderer class for TH3
►CTPointSet3DGL	Direct OpenGL renderer for TPointSet3D
►CTEveLineGL	GL-renderer for TEveLine class
►CTEveTrackGL	GL-renderer for TEveTrack class
CTEveTrackProjectedGL	GL-renderer for TEveTrackProjected class
CTGLPolyLine	To draw a 3D polyline in a GL window
CTGLPolyMarker	To draw a 3D polymarker in a GL window
CTGLSphere	Implements a native ROOT-GL sphere that can be rendered at different levels of detail
CTGLMatrix	16 component (4x4) transform matrix - column MAJOR as per GL
CTGLongPosition
CTGLOutput	Wrapper class for GL capture & output routines
►CTGLOverlayElement	An overlay element
CTEveRGBAPaletteOverlay	Description of TEveRGBAPaletteOverlay
CTGLAnnotation	GL-overlay annotation
CTGLCameraGuide	Draws arrows showing camera orientation in the overlay
►CTGLCameraOverlay	A GL overlay element which displays camera furstum
CTEveCaloLegoOverlay	GL-overlay control GUI for TEveCaloLego
CTGLClipSet	A collection of concrete TGLClip objects to be selected from
CTGLManipSet	Combine all available manipulators in a collection
CTGLOverlayButton	GL-overlay button
CTGLOverlayList	Manage a collection of overlay elements
►CTGLPaintDevice
CTGLAdapter	Allow plot-painters to be used for gl-inpad and gl-viewer
CTGLWidget	GL window with context
►CTGLPhysicalShape	Concrete physical shape - a GL drawable
►CTGLClip	Abstract clipping shape - derives from TGLPhysicalShape Adds clip mode (inside/outside) and pure virtual method to approximate shape as set of planes
CTGLClipBox	Concrete clip box object
CTGLClipPlane	Concrete clip plane object
CTGLPlane	3D plane class - of format Ax + By + Cz + D = 0
CTGLPlotBox	Implementation of a box around a histogram/function for plot-painters
CTGLPlotCamera	Camera for TGLPlotPainter and sub-classes
CTGLPlotCoordinates	Helper class for plot-painters holding information about axis ranges, numbers of bins and flags if certain axis is logarithmic
►CTGLPShapeRef	Base class for references to TGLPysicalShape that need to be notified when the shape is destroyed
CTGLManipSet	Combine all available manipulators in a collection
CTGLPShapeObjEditor	GUI editor for TGLPShapeObj
CTGLQuadric	Wrapper class for GLU quadric shape drawing object
CTGLRect	Viewport (pixel base) 2D rectangle class
CTGLRnrCtx	Aggregates data for a given redering context as needed by various parts of the ROOT's OpenGL infrastructure
►CTGLSceneInfo	Base class for extended scene context
CTGLScene::TSceneInfo
CTGLSelectBuffer	Encapsulates OpenGL select buffer
CTGLSelectionBuffer
►CTGLSelectRecordBase	Base class for select records
CTGLOvlSelectRecord	Selection record for overlay objects
CTGLSelectRecord	Standard selection record including information about containing scene and details ob out selected object (TGLPhysicalShape*, TObject* or simply a void* for foreign scenes)
CTGLStopwatch	Stopwatch object for timing GL work
CTGLUtil	Wrapper class for various misc static functions - error checking, draw helpers etc
►CTGLVertex3	3 component (x/y/z) vertex class
CTGLVector3	3 component (x/y/z) vector class
CTGMdiFrameList
CTGMdiGeometry
►CTGNumberFormat
CTGNumberEntry
CTGNumberEntryField
CTGPasswdDialog
CTGPosition
CTMVA::DNN::TGradientDescent< Architecture_t >
CROOT::TF1Helper::TGradientParFunction	Function class representing the derivative with respect a parameter of a given TF1
CTGRectangle
CTGRedirectOutputGuard
►CRgl::Mc::TGridGeometry< V >
CRgl::Mc::TDefaultSplitter< H, E, V >
►CRgl::Mc::TGridGeometry< Double_t >
CRgl::Mc::TF3Adapter
CRgl::Mc::TF3EdgeSplitter
►CRgl::Mc::TGridGeometry< Float_t >
CRgl::Fgt::TKDEAdapter
CTGSearchType
CTGText
CTGTextBuffer
CTGTextLine
►CRgl::TGuardBase
CRgl::TOneArgGuard< Func, Arg >
CRgl::TTwoArgsGuard< Func, Arg1, Arg2 >
►CTGuiBuilder
CTRootGuiBuilder
►CTGWidget
CTEveGTriVecValuator	Composite GUI element for setting three numerical values (label, three number-entries)
►CTEveGValuatorBase	Base class for composite GUI elements for setting of numeric values
CTEveGDoubleValuator	Composite GUI element for selection of range (label, two number-entries and double-slider)
CTEveGValuator	Composite GUI element for single value selection (supports label, number-entry and slider)
►CTGButton
►CTGDockButton
CTGDockHideButton
►CTGPictureButton
CTGImageMap
►CTGTextButton
CTEveGedNameTextButton	Specialization of TGTextButton for EVE name frame
►CTGCheckButton
CTGColorSelect
►CTGedSelect
CTGedMarkerSelect
CTGedPatternSelect
CTGRadioButton
CTGSplitButton
CTGuiBldHintsButton
CTGColorPalette
CTGColorPick
►CTGComboBox
CTGFontTypeComboBox
CTGFSComboBox
CTGLineStyleComboBox
CTGLineWidthComboBox
CTGDockableFrame
►CTGDoubleSlider
►CTGDoubleHSlider
CTGTripleHSlider
►CTGDoubleVSlider
CTGTripleVSlider
CTGeoPconSection	Utility frame used by TGeoPcon editor
CTGListBox
►CTGMdiWinResizer
CTGMdiCornerWinResizer
CTGMdiHorizontalWinResizer
CTGMdiVerticalWinResizer
CTGNumberEntry
►CTGScrollBar
CTGHScrollBar
CTGVScrollBar
CTGShutterItem
►CTGSlider
CTGHSlider
CTGVSlider
CTGSpeedo
CTGTab
►CTGTable
CTGSimpleTable
CTGTreeTable	TGTreeTable is a TGTable that owns it's own interface
►CTGTextEntry
CTGNumberEntryField
►CTGView
CTGHtml
►CTGTextView
CTGTextEdit
CTGTextViewostream
CTGWin32InterpreterProxy	This class defines thread-safe interface to a command line interpreter
►CTGWin32ProxyBase	Proxy classes provide thread-safe interface to global objects
CTGWin32GLManagerProxy
CTGWin32VirtualXProxy
CROOT::RDF::TH1DModel	A struct which stores the parameters of a TH1D
CTH1Merger
CROOT::RDF::TH2DModel	A struct which stores the parameters of a TH2D
CRgl::Mc::TH3Adapter< H, E >
CROOT::RDF::TH3DModel	A struct which stores the parameters of a TH3D
CROOT::Internal::THashConsistencyHolder< T >
CROOT::Experimental::THist< DIMENSIONS, PRECISION, STAT >	Histogram class for histograms with DIMENSIONS dimensions, where each bin count is stored by a value of type PRECISION
►CROOT::Experimental::THist< DIMENSIONS, PRECISION, THistStatContent >
CROOT::Experimental::THist< DIMENSIONS, PRECISION >	THist with no STAT parameter uses THistStatContent by default
CROOT::Experimental::Detail::THistBinPtr< HISTIMPL >	Points to a histogram bin (or actually a THistBinRef)
CROOT::Experimental::Detail::THistBinRef< HISTIMPL >	Represents a bin reference
CROOT::Experimental::Internal::THistBufferedFillBase< DERIVED, HIST, SIZE >
►CROOT::Experimental::Internal::THistBufferedFillBase< THistBufferedFill< HIST, SIZE >, HIST, SIZE >
CROOT::Experimental::THistBufferedFill< HIST, SIZE >	Buffers calls to Fill()
►CROOT::Experimental::Internal::THistBufferedFillBase< THistConcurrentFiller< HIST, SIZE >, HIST, SIZE >
CROOT::Experimental::THistConcurrentFiller< HIST, SIZE >	Buffers a thread's Fill calls and submits them to the THistConcurrentFillManager
CROOT::Experimental::THistConcurrentFillManager< HIST, SIZE >	Manages the synchronization of calls to FillN()
CROOT::Experimental::THistDataMomentUncert< DIMENSIONS, PRECISION, STORAGE >	For now do as TH1: calculate first (xw) and second (x^2w) moment
CROOT::Experimental::THistDrawingOpts< DIMENSION >
CROOT::Experimental::THistDrawingOpts< DIMENSIONS >
CROOT::Experimental::Internal::THistImplGen< NDIM, IDIM, DATA, PROCESSEDAXISCONFIG >	Generate THist::fImpl from THist constructor arguments
CROOT::Experimental::Internal::THistImplGen< NDIM, NDIM, DATA, PROCESSEDAXISCONFIG... >	Generate THist::fImpl from constructor arguments; recursion end
CROOT::Experimental::Detail::THistImplPrecisionAgnosticBase< DIMENSIONS >	Base class for THistImplBase that abstracts out the histogram's PRECISION
►CROOT::Experimental::Detail::THistImplPrecisionAgnosticBase< DATA::GetNDim()>
►CROOT::Experimental::Detail::THistImplBase< DATA >	Interface class for THistImpl
CROOT::Experimental::Detail::THistImpl< DATA, AXISCONFIG >
CROOT::Experimental::Internal::THistPainterBase< DIMENSION >
CTHistRenderingRegion
CROOT::Experimental::THistStatContent< DIMENSIONS, PRECISION, STORAGE >	Basic histogram statistics, keeping track of the bin content and the total number of calls to Fill()
CROOT::Experimental::THistStatRuntime< DIMENSIONS, PRECISION, STORAGE >	Interface implementing a pure virtual functions DoFill(), DoFillN()
CROOT::Experimental::THistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION, STORAGE >	Keeps track of the histogram's total sum of squared weights
CROOT::Experimental::THistStatTotalSumOfWeights< DIMENSIONS, PRECISION, STORAGE >	Keeps track of the histogram's total sum of weights
CROOT::Experimental::THistStatUncertainty< DIMENSIONS, PRECISION, STORAGE >	Histogram statistics to keep track of the Poisson uncertainty per bin
CROOT::Experimental::THistView< DIMENSIONS, PRECISION, STAT >	A view on a histogram, selecting a range on a subset of dimensions
CROOT::Experimental::THistViewOutOfRange< HISTVIEW >
CROOT::Internal::THnBaseBinIter	Iterator over THnBase bins (internal implementation)
CTGeoPatternFinder::ThreadData_t
CTGeoBoolNode::ThreadData_t
CTGeoPgon::ThreadData_t
CTGeoVolumeAssembly::ThreadData_t
CTGeoXtru::ThreadData_t
►CTHttpWSEngine
CTHttpLongPollEngine
CTIdleTOTimerGuard
CTStreamerInfoActions::TIDNode
CTIndArray
►CROOT::Internal::TInitBehavior
►CROOT::Internal::TDefaultInitBehavior
CROOT::Internal::TQObjectInitBehavior
CROOT::Internal::TTableInitBehavior< T >
CTInspectorImp	ABC describing GUI independent object inspector (abstraction mainly needed for Win32
CTVirtualCollectionPtrIterators::TInternalIterator
CTClassEdit::TInterpreterLookupHelper
CTInterpreterValue
CROOT::TIOFeatures	TIOFeatures 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_t >
CRgl::Mc::TIsoMesh< Float_t >
►CTIter
CROOT::Detail::TTypedIter< Containee >	TTypedIter is a typed version of TIter
CROOT::Internal::TRangeDynCastIterator< Containee >	Internal help class implmenting an iterator for TRangeDynCast
CTIterCategory< T >
►CTIterator	Iterator abstract base class
CRooDataHistSliceIter	RooDataHistSliceIter iterates over all bins in a RooDataHist that occur in a slice defined by the bin coordinates of the input sliceSet
CRooLinkedListIter	RooLinkedListIter is the TIterator implementation for RooLinkedList
CRooMultiCatIter	RooMultiCatIter iterators over all state permutations of a list of categories
CTBtreeIter	Iterator of btree
CTHashTableIter	Iterator of hash table
CTListIter	Iterator of linked list
CTMapIter	Iterator of map
CTObjArrayIter	Iterator of object array
CTOrdCollectionIter	Iterator of ordered collection
CTRefArrayIter	Iterator of object array
CTTreeFriendLeafIter	Iterator on all the leaves in a TTree and its friend
CTViewPubDataMembersIter	Iterator of over the view's content
CTViewPubFunctionsIter	Iterator of over the view's content
CTKDEFGT
CTLatex::TLatexFormSize	TLatex helper class used to compute the size of a portion of a formula
CTMVA::DNN::TLayer< Architecture_t >	Generic layer class
CTLimit	Algorithm to compute 95% C.L
CTLockGuard
CTLockPathGuard
CROOT::Experimental::TLogDiagCounter	Object to count the number of warnings and errors emitted by a section of code, after construction of this type
►CROOT::Experimental::TLogHandler	Abstract TLogHandler base class
CROOT::Experimental::TLogManager	A TLogHandler that multiplexes diagnostics to different client TLogHandlers
CTStreamerInfoActions::TLoopConfiguration	Base class of the Configurations for the member wise looping routines
CTLorentzRotation::TLorentzRotationRow
CTMakeProject
CTMapRec	Keep track of an object in the mapped file
CTMatrixDEigen	TMatrixDEigen
CTMatrixDSymEigen	TMatrixDSymEigen
►CTMatrixTColumn_const< Element >
CTMatrixTColumn< Element >
►CTMatrixTDiag_const< Element >
CTMatrixTDiag< Element >
►CTMatrixTFlat_const< Element >
CTMatrixTFlat< Element >
►CTMatrixTRow_const< Element >
CTMatrixTRow< Element >
►CTMatrixTSparseDiag_const< Element >
CTMatrixTSparseDiag< Element >
►CTMatrixTSparseRow_const< Element >
CTMatrixTSparseRow< Element >
►CTMatrixTSub_const< Element >
CTMatrixTSub< Element >
CTMCTemplateAutoLock< M, L, U >	Template classe which provides a mechanism to create a mutex and locks/unlocks it
►CTMCTemplateAutoLock< TMCMutex, TMCthread_lock, TMCthread_unlock >
CTMCImpMutexAutoLock	Realization of TMCTemplateAutoLock with TMCMutex
CTMD5	This code implements the MD5 message-digest algorithm
CTMemberInspector	Abstract base class for accessing the data-members of a class
►CTMemberStreamer
CTCollectionMemberStreamer	Class streamer object to implement TMemberStreamer functionality for I/O emulation
CTConvertClonesArrayToProxy	Small helper to read a TBuffer containing a TClonesArray into any valid collection
CTConvertMapToProxy
CTMemFile::TMemBlock
CMemstat::TMemStatFAddrContainer
CTMemStatHook
CROOT::Experimental::Detail::TMenuArgument
►CROOT::Experimental::Detail::TMenuItem	Class contains info for producing menu item on the JS side
CROOT::Experimental::Detail::TArgsMenuItem
CROOT::Experimental::Detail::TCheckedMenuItem
CROOT::Experimental::TMenuItems
►CTMPClient	Base class for multiprocess applications' clients
CROOT::TProcessExecutor	This class provides a simple interface to execute the same task multiple times in parallel, possibly with different arguments every time
CROOT::TTreeProcessorMP	This class provides an interface to process a TTree dataset in parallel with multi-process technology
►CTMPWorker	This class works in conjuction with TMPClient, reacting to messages received from it as specified by the Notify and HandleInput methods
CTMPWorkerExecutor< F, T, R >	This class works together with TProcessExecutor to allow the execution of functions in server processes
CTMPWorkerExecutor< F, T, void >
CTMPWorkerExecutor< F, void, R >
►CTMPWorkerTree	This class works in conjuction with TTreeProcessorMP, reacting to messages received from it as specified by the Notify and HandleInput methods
CTMPWorkerTreeFunc< F >	Templated derivation of TMPWorkerTree handlign generic function tree processing
CTMPWorkerTreeSel	Templated derivation of TMPWorkerTree handlign selector tree processing
CROOT::Internal::TMultiArrayType< T, d >
CTMVA::TMVAGaussPair
CTMVA::TMVAGUI
CROOT::Internal::TNamedBranchProxy
CTNDArrayRef< T >
CTStreamerInfoActions::TNestedIDs
CTMVA::DNN::TNet< Architecture_t, Layer_t >	Generic neural network class
CTMVA::DNN::TNet< Architecture_t >
►CTMVA::TNeuronInput	Interface for TNeuron input calculation classes
CTMVA::TNeuronInputAbs	TNeuron input calculator – calculates the sum of the absolute values of the weighted inputs
CTMVA::TNeuronInputSqSum	TNeuron input calculator – calculates the squared weighted sum of inputs
CTMVA::TNeuronInputSum	TNeuron input calculator – calculates the weighted sum of inputs
CTMVA::TNeuronInputChooser	Class for easily choosing neuron input functions
►CTNonCopyable
CTThreadPool< aTask, aParam >
Cnlohmann::detail::to_json_fn
►CTObject	Mother of all ROOT objects
CHit
CJet
CJetEvent
CMemstat::TMemStatMng
CPyROOT::TMemoryRegulator
CRooAbsCollection	RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects
►CRooAbsIntegrator	RooAbsIntegrator is the abstract interface for integrators of real-valued functions that implement the RooAbsFunc interface
CRooAdaptiveGaussKronrodIntegrator1D	RooAdaptiveGaussKronrodIntegrator1D implements the Gauss-Kronrod integration algorithm
CRooAdaptiveIntegratorND	RooAdaptiveIntegratorND implements an adaptive one-dimensional numerical integration algorithm
CRooBinIntegrator	RooBinIntegrator implements an adaptive one-dimensional numerical integration algorithm
CRooGaussKronrodIntegrator1D	RooGaussKronrodIntegrator1D implements the Gauss-Kronrod integration algorithm
CRooImproperIntegrator1D	Special numeric integrator that can handle integrals over open domains
►CRooIntegrator1D	RooIntegrator1D implements an adaptive one-dimensional numerical integration algorithm
CRooIntegrator2D	RooIntegrator2D implements a numeric two-dimensiona integrator in terms of a recursive application of RooIntegrator1D
CRooMCIntegrator	RooMCIntegrator implements an adaptive multi-dimensional Monte Carlo numerical integration, following the VEGAS algorithm originally described in G
►CRooSegmentedIntegrator1D	RooSegmentedIntegrator1D implements an adaptive one-dimensional numerical integration algorithm
CRooSegmentedIntegrator2D	RooSegmentedIntegrator2D implements an adaptive one-dimensional numerical integration algorithm
CRooCatType	RooCatType is an auxilary class for RooAbsCategory and defines a a single category state
CRooCFunction1Ref< VO, VI >
CRooCFunction2Ref< VO, VI1, VI2 >
CRooCFunction3Ref< VO, VI1, VI2, VI3 >
CRooCFunction4Ref< VO, VI1, VI2, VI3, VI4 >
CRooCmdConfig	Class RooCmdConfig is a configurable parser for RooCmdArg named arguments
CRooExpensiveObjectCache	RooExpensiveObjectCache is a singleton class that serves as repository for objects that are expensive to calculate
CRooGrid	RooGrid is a utility class for RooMCIntegrator which implements an adaptive multi-dimensional Monte Carlo numerical integration, following the VEGAS algorithm
CRooHashTable	RooHashTable implements a hash table for TObjects
►CRooLinkedList	RooLinkedList is an collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list
CRooRefCountList	A RooRefCountList is a RooLinkedList that keeps a reference counter with each added node
CRooMinimizer	RooMinimizer is a wrapper class around ROOT::Fit:Fitter that provides a seamless interface between the minimizer functionality and the native RooFit interface
CRooMinuit	RooMinuit is a wrapper class around TFitter/TMinuit that provides a seamless interface between the MINUIT functionality and the native RooFit interface
CRooMsgService	Singleton class that organizes informational, debugging, warning and errors messages generated by the RooFit core code
CRooNameSet	RooNameSet is a utility class that stores the names the objects in a RooArget
CRooNumGenConfig	RooNumGenConfig holds the configuration parameters of the various numeric integrators used by RooRealIntegral
CRooNumGenFactory	RooNumGenFactory is a factory to instantiate numeric integrators from a given function binding and a given configuration
CRooNumIntConfig	RooNumIntConfig holds the configuration parameters of the various numeric integrators used by RooRealIntegral
CRooNumIntFactory	RooNumIntFactory is a factory to instantiate numeric integrators from a given function binding and a given configuration
CRooSetPair	RooSetPair is a utility class that stores a pair of RooArgSets
►CRooSharedProperties	Class RooSharedProperties is the base class for shared properties that can be stored in RooSharedPropertiesList
CRooCategorySharedProperties	RooCategorySharedProperties is the container for all properties that are shared between instance of RooCategory objects that are clones of each other
CRooRealVarSharedProperties	Class RooRealVarSharedProperties is an implementation of RooSharedProperties that stores the properties of a RooRealVar that are shared among clones
CRooSharedPropertiesList	Class RooSharedPropertiesList maintains the properties of RooRealVars and RooCategories that are clones of each other
CRooSimPdfBuilder
CRooStats::AcceptanceRegion
CRooStats::HistFactory::EstimateSummary
CRooStats::HistFactory::HistoToWorkspaceFactory
CRooStats::HistFactory::HistoToWorkspaceFactoryFast
CRooStats::MetropolisHastings	This class uses the Metropolis-Hastings algorithm to construct a Markov Chain of data points using Monte Carlo
►CRooStats::ProposalFunction	ProposalFunction is an interface for all proposal functions that would be used with a Markov Chain Monte Carlo algorithm
CRooStats::PdfProposal	PdfProposal is a concrete implementation of the ProposalFunction interface
CRooStats::SequentialProposal	Class implementing a proposal function that samples the parameter space by moving only in one coordinate (chosen randomly) at each step
CRooStats::UniformProposal	UniformProposal is a concrete implementation of the ProposalFunction interface for use with a Markov Chain Monte Carlo algorithm
CRooStats::ProposalHelper
CRooStats::SamplingSummary
CRooStats::SamplingSummaryLookup
CROOT::Detail::TSchemaRuleSet
CROOT::Internal::TCheckHashRecursiveRemoveConsistency
CROOT::Internal::TTreeReaderDescriptor
CROOT::R::TRDataFrame	This is a class to create DataFrames from ROOT to R
CROOT::R::TRFunctionExport	This is a class to pass functions from ROOT to R
CROOT::R::TRFunctionImport	This is a class to pass functions from ROOT to R
CROOT::R::TRInterface
CROOT::R::TRObject	This is a class to get ROOT's objects from R's objects
CROOT::TSchemaRule
CRooThreshEntry	Class RooThreshEntry is a utility class for RooThresholdCategory
CRooWorkspace::CodeRepo
CTAFS
CTAliEnFind
►CTApplication	This class creates the ROOT Application Environment that interfaces to the windowing system eventloop and eventhandlers
CPyROOT::TPyROOTApplication
CTApplicationRemote
CTApplicationServer
CTGApplication
►CTProofServ	Class providing the PROOF server
CTProofServLite	Version of the PROOF worker server for local running
CTXProofServ	This class implements the XProofD version of TProofServ, with respect to which it differs only for the underlying connection technology
CTQApplication
CTRint
►CTArchiveFile	Class describing an archive file containing multiple sub-files, like a ZIP or TAR archive
CTZIPFile	Describes a ZIP archive file containing multiple sub-files
►CTArchiveMember
CTZIPMember	A ZIP archive consists of files compressed with the popular ZLIB compression algorithm; this class records the information about a single archive member
CTASPaletteEditor::PaintPalette
CTAuthenticate
CTAxisModLab	TAxis helper class used to store the modified labels
CTBinomialEfficiencyFitter	Binomial fitter for the division of two histograms
CTBits	Container of bits
CTBonjourBrowser
CTBonjourRecord
CTBonjourRegistrar
CTBonjourResolver
CTBox	Create a Box
►CTBuffer	Buffer base class used for serializing objects
►CTBufferIO	Direct subclass of TBuffer, implements common methods for TBufferFile and TBufferText classes
►CTBufferFile	The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket
CTBufferSQL	Implement TBuffer for a SQL backend
CTMessage
►CTBufferText	Base class for text-based streamers like TBufferJSON or TBufferXML Special actions list will use methods, introduced in this class
CTBufferJSON	Class for serializing object to and from JavaScript Object Notation (JSON) format
CTBufferSQL2	Converts data to SQL statements or read data from SQL tables
CTBufferXML	Class for serializing/deserializing object to/from xml
►CTBuffer3D	Generic 3D primitive description class
CTBuffer3DSphere	Sphere description class - see TBuffer3DTypes for producer classes Supports hollow and cut spheres
►CTBuffer3DTube	Complete tube description class - see TBuffer3DTypes for producer classes
►CTBuffer3DTubeSeg	Tube segment description class - see TBuffer3DTypes for producer classes
CTBuffer3DCutTube	Cut tube segment description class - see TBuffer3DTypes for producer classes
CTClassDocInfo
►CTClassGenerator	Objects following this interface can be passed onto the TROOT object to implement a user customized way to create the TClass objects
CTPyClassGenerator
CTClassMenuItem	Describes one element of the context menu associated to a class The menu item may describe
CTClassTable	This class registers for all classes their name, id and dictionary function in a hash table
►CTCollection	Collection abstract base class
►CTHashTable	THashTable implements a hash table to store TObject's
CTListOfTypes	A collection of TDataType designed to hold the typedef information and numerical type information
CTMap	TMap implements an associative array of (key,value) pairs using a THashTable for efficient retrieval (therefore TMap does not conserve the order of the entries)
►CTSeqCollection	Sequenceable collection abstract base class
CTBtree	B-tree class
►CTList	A doubly linked list
CRooList	A RooList is a TList with extra support for working with options that are associated with each node
►CTGridJobStatusList
CTAlienJobStatusList
►CTGridResult
CTAlienResult
CTGLiteResult
►CTHashList	THashList implements a hybrid collection class consisting of a hash table and a list to store TObject's
CTListOfDataMembers	A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of TDataMember that were described unloaded data member
►CTListOfEnums	A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum that were described unloaded enum
CTListOfEnumsWithLock	A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum that were described unloaded enum
CTListOfFunctions	A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFunction that were described unloaded function
CTListOfFunctionTemplates	A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFunction that were described unloaded function
CTSelectorList	A TList derived class that makes sure that objects added to it are not linked to the currently open file (like histograms, eventlists and trees)
CTParallelCoordSelect	A TParallelCoordSelect is a specialised TList to hold TParallelCoordRanges used by TParallelCoord
CTProofOutputList	Derivation of TList with an overload of ls() and Print() allowing to filter out some of the variables
►CTQCommand	The Command design pattern is based on the idea, that all editing in an application is done by creating instances of command objects
CTQUndoManager	Recorder of operations for undo and redo
CTSortedList	A sorted doubly linked list
CTViewPubDataMembers	View implementing the TList interface and giving access all the TDictionary describing public data members in a class and all its base classes without caching any of the TDictionary pointers
CTViewPubFunctions	View implementing the TList interface and giving access all the TFunction describing public methods in a class and all its base classes without caching any of the TFunction pointers
►CTVirtualQConnection	Mediates the link between the signal and the slot
CTQConnection	TQConnection class is an internal class, used in the object communication mechanism
►CTObjArray	An array of TObjects
CRooRefArray
CTClonesArray	An array of clone (identical) objects
CTGeoNavigatorArray
CTOrdCollection	Ordered collection
CTRefArray	An array of references to TObjects
CTCondition
►CTConditionImp
CTPosixCondition
CTWin32Condition
CTCondor
CTCondorSlave
CTConfidenceLevel	Class to compute 95% CL limits
►CTDataSetIter
CTVolumeViewIter
►CTDataSetManager
CTDataSetManagerAliEn
CTDataSetManagerFile
CTDecayChannel	Description of the decay channel
►CTDecompBase	Decomposition Base class
CTDecompBK	The Bunch-Kaufman diagonal pivoting method decomposes a real symmetric matrix A using
CTDecompChol	Cholesky Decomposition class
CTDecompLU	LU Decomposition class
CTDecompQRH	QR Decomposition class
CTDecompSparse	Sparse Symmetric Decomposition class
CTDecompSVD	Single Value Decomposition class
CTDictAttributeMap	The ROOT object has a list of properties which are stored and retrieved using TDictAttributeMap
CTDNDData
CTDocMethodWrapper
►CTDocOutput
CTClassDocOutput
CTDocParser
CTDrawFeedback	Utility class to draw objects in the feedback list during queries
CTEllipse	Draw Ellipses
CTEntryListBlock	Used by TEntryList to store the entry numbers
CTEnv	Reads config files, by default named .rootrc
CTEnvRec
CTEveCluster
CTEveElementObjectPtr	TEveElement with external TObject as a holder of visualization data
CTEveFrameBox	Description of a 2D or 3D frame that can be used to visually group a set of objects
CTEveGeoNode	Wrapper for TGeoNode that allows it to be shown in GUI and controlled as a TEveElement
CTEveGridStepper	Provide discrete position coordinates for placement of objects on regular grids
CTEveHit
CTEveMCRecCrossRef
►CTEventIter	Special iterator class used in TProofPlayer to iterate over events or objects in the packets
CTEventIterObj
CTEventIterTree
CTEventIterUnit
CTEveRecCascade
CTEveRecKink
CTEveRecTrackT< TT >
CTEveRecTrackT< Float_t >
CTEveRecV0
CTEveRGBAPalette	A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes
CTEveTrans	TEveTrans is a 4x4 transformation matrix for homogeneous coordinates stored internally in a column-major order to allow direct usage by GL
CTEveVSD	Visualization Summary Data - a collection of trees holding standard event data in experiment independent format
CTExMap	This class stores a (key,value) pair using an external hash
►CTF1AbsComposition
CTF1Convolution	Class wrapping convolution of two functions
CTF1NormSum	Class adding two functions: c1*f1+c2*f2
CTFeldmanCousins	Class to calculate the CL upper limit using the Feldman-Cousins method as described in PRD V57 #7, p3873-3889
►CTFileCacheRead	A cache when reading files over the network
►CTTreeCache	A specialized TFileCacheRead object for a TTree
CTTreeCacheUnzip	Specialization of TTreeCache for parallel Unzipping
CTFileCacheWrite	A cache when writing files over the network
CTFileMerger	This class provides file copy and merging services
CTFilePrefetch	The prefetching mechanism uses two classes (TFilePrefetch and TFPBlock) to prefetch in advance a block of tree entries
CTFoam
CTFoamCell
►CTFoamIntegrand
CRooTFoamBinding	Lightweight interface adaptor that binds a RooAbsPdf to TFOAM
CTFoamMaxwt
CTFoamVect
►CTFormLeafInfo	This class is a small helper class to implement reading a data member on an object stored in a TTree
CTFormLeafInfoCast	A small helper class to implement casting an object to a different type (equivalent to dynamic_cast)
CTFormLeafInfoClones	A small helper class to implement reading a data member on a TClonesArray object stored in a TTree
CTFormLeafInfoCollection	A small helper class to implement reading a data member on a generic collection object stored in a TTree
CTFormLeafInfoCollectionObject	A small helper class to implement reading a data member on a TClonesArray object stored in a TTree
CTFormLeafInfoCollectionSize	Used to return the size of a collection
CTFormLeafInfoDirect	A small helper class to implement reading a data member on an object stored in a TTree
CTFormLeafInfoMethod	Asmall helper class to implement executing a method of an object stored in a TTree
►CTFormLeafInfoMultiVarDim	A helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree
CTFormLeafInfoMultiVarDimClones	A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree
CTFormLeafInfoMultiVarDimCollection	A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree
CTFormLeafInfoMultiVarDimDirect	A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree
CTFormLeafInfoNumerical	A small helper class to implement reading a numerical value inside a collection
CTFormLeafInfoPointer	A small helper class to implement reading a data member by following a pointer inside a branch of TTree
CTFormLeafInfoReference	A small helper class to implement the following of reference objects stored in a TTree
CTFormLeafInfoTTree	A small helper class to implement reading from the containing TTree object itself
CTFPBlock	This class represents the encapsulation of a block request
CTFractionFitter	Fits MC fractions to data histogram
CTFree	Service class for TFile
CTFTP
CTGClient
CTGDMLParse	This class contains the implementation of the GDML parser associated to all the supported GDML elements
CTGDMLRefl	This class is a helper class for TGDMLParse
CTGDMLWrite	This class contains implementation of converting ROOT's gGeoManager geometry to GDML file
CTGDNDManager
CTGedFrame::TGedSubFrame
CTGenPhaseSpace	Utility class to generate n-body event, with constant cross-section (default) or with Fermi energy dependence (opt="Fermi")
CTGeoBatemanSol
►CTGeoBoolNode	Base class for Boolean operations between two shapes
CTGeoIntersection
CTGeoSubtraction
CTGeoUnion
CTGeoBranchArray	An array of daughter indices making a geometry path
CTGeoBuilder	Utility class for creating geometry objects.These will be associated with the current selected geometry manager object:
CTGeoCacheState	Class storing the state of the cache at a given moment
CTGeoChecker	Geometry checking package
CTGeoDecayChannel	A decay channel for a radionuclide
CTGeoElementTable	Table of elements
►CTGeoExtension	ABC for user objects attached to TGeoVolume or TGeoNode
CTGeoRCExtension	Reference counted extension which has a pointer to and owns a user defined TObject
CTGeoGlobalMagField	Global magnetic field manager
CTGeoHelix	Class representing a helix curve
CTGeoIteratorPlugin
CTGeoNavigator	Class providing navigation API for TGeo geometries
CTGeoNodeCache	Special pool of reusable nodes
►CTGeoPatternFinder	Base finder class for patterns
CTGeoPatternCylPhi
CTGeoPatternCylR
CTGeoPatternHoneycomb
CTGeoPatternParaX
CTGeoPatternParaY
CTGeoPatternParaZ
CTGeoPatternSphPhi
CTGeoPatternSphR
CTGeoPatternSphTheta
CTGeoPatternTrapZ
CTGeoPatternX
CTGeoPatternY
CTGeoPatternZ
CTGeoPolygon	An arbitrary polygon defined by vertices
CTGeoTabManager	Manager for all editor tabs
CTGeoToStep	This class is an interface to convert ROOT's geometry file to STEP file
CTGeoVoxelFinder	Finder class handling voxels
►CTGFrameElement
CTGFrameElementPack
CTGGC
►CTGHtmlElement
CTGHtmlBlock
►CTGHtmlMarkupElement
CTGHtmlAnchor
CTGHtmlCell
CTGHtmlForm
CTGHtmlHr
CTGHtmlImageMarkup
CTGHtmlInput
CTGHtmlLi
CTGHtmlListStart
CTGHtmlMapArea
CTGHtmlRef
CTGHtmlScript
CTGHtmlTable
CTGHtmlSpaceElement
CTGHtmlTextElement
CTGHtmlImage
CTGHtmlLayoutContext
CTGHtmlUri
CTGIdleHandler
CTGItemContext	Empty object used as context menu support for TGLVTreeEntries
CTGLAutoRotator	Automatically rotates GL camera
►CTGLayoutHints
CTGTableLayoutHints
CTGXYLayoutHints
►CTGLayoutManager
CTGMatrixLayout
CTGNumberEntryLayout
CTGTabLayout
CTGTableLayout
►CTGTileLayout
CTGListDetailsLayout
CTGListLayout
►CTGVerticalLayout
CTGHorizontalLayout
►CTGRowLayout
CTGColumnLayout
CTGXYLayout
►CTGLCamera	Abstract base camera class - concrete classes for orthographic and perspective cameras derive from it
CTGLOrthoCamera	Orthographic projection camera
CTGLPerspectiveCamera	Perspective projection camera - with characteristic foreshortening
CTGLLightSet	Encapsulates a set of lights for OpenGL
CTGLPShapeObj	Wrap TGLPysicalShape into TObject so that it can be edited using GED
CTGMainFrame::TGMapKey
CTGMenuEntry
CTGMime
CTGMimeTypes
►CTGObject
CTGFontPool
CTGGCPool
CTGResourcePool
►CTGWindow
►CTGFrame
CTGButton
►CTGCanvas
CTGListView
CTGMdiMainFrame
CTRootEmbeddedCanvas
CTGColorFrame
CTGColorPalette
CTGColorPick
►CTGCompositeFrame
CTEditQueryFrame
►CTEveCompositeFrame	Abstract base-class for frame-slots that encompass EVE-windows (sub-classes of TEveWindow)
CTEveCompositeFrameInMainFrame	An EVE window-slot contained within a TGMainFrame
CTEveCompositeFrameInPack	An EVE window-slot contained within one frame of a TGPack
CTEveCompositeFrameInTab	An EVE window-slot contained within one tab of a TGTab
CTEveGTriVecValuator	Composite GUI element for setting three numerical values (label, three number-entries)
CTEveGValuatorBase	Base class for composite GUI elements for setting of numeric values
CTG16ColorSelector
CTGColorPopup
CTGComboBox
CTGComboBoxPopup
►CTGContainer
CTGLBContainer
CTGListTree
►CTGLVContainer
CTGFileContainer
CTTVLVContainer	This class represent the list view container for the
CTGDockableFrame
►CTGedFrame
CTArrowEditor
CTAttFillEditor
CTAttLineEditor
CTAttMarkerEditor
CTAttTextEditor
CTAxisEditor
CTCurlyArcEditor
CTCurlyLineEditor
CTEveArrowEditor	GUI editor for TEveArrow
CTEveCalo3DEditor	GUI editor for TEveCalo3D
CTEveCaloLegoEditor	GUI editor for TEveCaloLego
CTEveCaloVizEditor	GUI editor for TEveCaloEditor
CTEveDigitSetEditor	Editor for TEveDigitSet class
CTEveElementEditor	Editor for TEveElement class
CTEveGedNameFrame	Specialization of TGedNameFrame used in EVE
CTEveGeoNodeEditor	Editor for TEveGeoNode class
CTEveGeoTopNodeEditor	Editor for TEveGeoTopNode class
CTEveGridStepperEditor	Editor for TEveGridStepper class
CTEveJetConeEditor	GUI editor for TEveJetCone
CTEveLineEditor	Editor for TEveLine class
CTEveParamListEditor	GUI editor for TEveParamList
CTEvePointSetArrayEditor	Editor for TEvePointSetArray class
CTEveProjectionAxesEditor	GUI editor for TEveProjectionAxes
CTEveProjectionManagerEditor	GUI editor for TEveProjectionManager class
CTEveRGBAPaletteEditor	Editor for TEveRGBAPalette class
CTEveShapeEditor	GUI editor for TEveShape
CTEveStraightLineSetEditor	Editor for TEveStraightLineSet class
CTEveTextEditor	GUI editor for TEveText
CTEveTrackEditor	Editor for TEveTrack class
CTEveTrackListEditor	Editor for TEveTrackList class
CTEveTrackPropagatorEditor	GUI editor for TEveTrackPropagator
CTEveTransEditor	Editor for TEveTrans class
CTEveTriangleSetEditor	Editor for TEveTriangleSet class
CTEveViewerListEditor	GUI editor for TEveViewerList
CTEveWindowEditor	GUI editor for TEveWindow
CTF1Editor
CTFrameEditor
CTGedNameFrame
►CTGeoGedFrame	Common base class for geombuilder editors
CTGeoBBoxEditor	Editor for a TGeoBBox
CTGeoCombiTransEditor	Editor for a TGeoCombiTrans
►CTGeoConeEditor	Editor for a TGeoCone
CTGeoConeSegEditor	Editor for a cone segment
CTGeoEltuEditor	Editor for a TGeoEltu
CTGeoHypeEditor	Editor for a TGeoHype
►CTGeoMaterialEditor	Editors for materials
CTGeoMixtureEditor	Editors for mixtures
CTGeoMediumEditor	Editor class for TGeo tracking media
CTGeoNodeEditor	Editor class for TGeoNode objects
CTGeoParaEditor	Editor for a TGeoPara
►CTGeoPconEditor	Editor for a TGeoPcon
CTGeoPgonEditor	Editor for a TGeoPgon
CTGeoRotationEditor	Editor for a TGeoRotation
CTGeoSphereEditor	Editor for a TGeoSphere
CTGeoTorusEditor	Editor for a TGeoTorus
CTGeoTranslationEditor	Editor for a TGeoTranslation
►CTGeoTrapEditor	Editor for a TGeoTrap
CTGeoGtraEditor	Editor for a TGeoGtra
CTGeoTrd1Editor	Editor for a TGeoTrd1
CTGeoTrd2Editor	Editor for a TGeoTrd2
►CTGeoTubeEditor	Editor for a TGeoTube
►CTGeoTubeSegEditor	Editor for a TGeoTubeSeg
CTGeoCtubEditor	Editor for a TGeoCtub
CTGeoVolumeEditor	Editor for geometry volumes and assemblies of volumes
CTGeoManagerEditor	Editor for TGeoManager class
CTGL5DDataSetEditor	GUI editor for OpenGL 5D Painter
CTGLClipSetEditor	GUI editor for TGLClipSet
CTGLLightSetEditor
CTGLPShapeObjEditor	GUI editor for TGLPShapeObj
CTGLViewerEditor	GUI editor for TGLViewer
CTGraphEditor
CTH1Editor
CTH2Editor
CTLineEditor
CTPadEditor
CTParallelCoordEditor	This is the TParallelCoord editor
CTPaveStatsEditor
CTPieEditor
CTPieSliceEditor
CTSpiderEditor	The TSpider editor class
CTStructNodeEditor
CTTextEditor
CTGedPatternSelector
►CTGedPopup
CTGedMarkerPopup
CTGedPatternPopup
CTGeoPconSection	Utility frame used by TGeoPcon editor
►CTGGroupFrame
►CTGButtonGroup
CTGHButtonGroup
CTGVButtonGroup
►CTGHorizontalFrame
CTGHeaderFrame
CTGMenuBar
CTGStatusBar
CTGListBox
►CTGMainFrame
CTASPaletteEditor	This is a GUI window to edit a color palette
CTEveGListTreeEditorFrame	Composite GUI frame for parallel display of a TGListTree and TEveGedEditor
CTFitEditor
CTGCommandPlugin
►CTGedEditor
CTEveGedEditor	Specialization of TGedEditor for proper update propagation to TEveManager
CTGeoTransientPanel
CTGFileBrowser
CTGHtmlBrowser
CTGLSAFrame	Standalone GL Viewer GUI main frame
CTGRecorder
CTGTextEditor
►CTGTransientFrame
CTAdvancedGraphicsDialog
CTFitParametersDialog
CTFunctionParametersDialog
CTGColorDialog
►CTGeoTreeDialog
CTGeoMaterialDialog
CTGeoMatrixDialog
CTGeoMediumDialog
CTGeoShapeDialog
CTGeoVolumeDialog
CTGFileDialog
CTGFontDialog
CTGGotoDialog
CTGInputDialog
CTGMsgBox
CTGPrintDialog
CTGSearchDialog
CTGSelectBox	This class represent a specialized expression editor for TTVLVEntry 'true name' and 'alias' data members
CTGUndockedFrame
CTNewChainDlg
CTNewQueryDlg
CTProofProgressLog
CTProofProgressMemoryPlot
CTRootDialog
CTRootHelpDialog
CTSessionLogView
CTStyleDialog
CTStylePreview
CTTreeInput
CTUploadDataSetDlg
CTRootBrowser
CTRootBrowserLite
CTRootCanvas
CTRootControlBar
CTRootGuiBuilder
CTSessionViewer
CTStructViewerGUI
CTStyleManager
CTTreeViewer	A graphic user interface designed to handle ROOT trees and to take advantage of TTree class features
CTGMdiButtons
CTGMdiDecorFrame
CTGMdiFrame
CTGMdiMenuBar
CTGMdiTitleBar
CTGNumberEntry
CTGPack
CTGShapedFrame
CTGShutter
CTGSplitFrame
CTGSplitTool
CTGTab
CTGTable
CTGTableHeaderFrame
CTGToolBar
CTGToolTip
CTGuiBldNameFrame
►CTGVerticalFrame
CTEveGridStepperSubEditor	Sub-editor for TEveGridStepper class
CTEveRGBAPaletteSubEditor	Sub-editor for TEveRGBAPalette class
CTEveTrackPropagatorSubEditor	Sub-editor for TEveTrackPropagator class
CTEveTransSubEditor	Sub-editor for TEveTrans class
CTGLClipSetSubEditor	GUI sub-editor for TGLClipSet
CTGLLightSetSubEditor	Sub-editor for TGLLightSet
CTGShutterItem
CTGuiBldEditor
CTGuiBldGeometryFrame
CTGuiBldHintsEditor
CTGView
CTGViewFrame
CTGViewPort
CTSessionFrame
CTSessionInputFrame
CTSessionOutputFrame
CTSessionQueryFrame
CTSessionServerFrame
CTGDoubleSlider
CTGDragWindow
CTGedPatternFrame
CTGHorizontal3DLine
►CTGIcon
CTGMdiTitleIcon
CTGLabel
►CTGLBEntry
►CTGTextLBEntry
CTGIconLBEntry
CTGLineLBEntry
CTGTreeLBEntry
►CTGLVEntry
CTGFileItem
CTTVLVEntry	This class represent entries that goes into the TreeViewer listview container
CTGLWidget	GL window with context
CTGMdiContainer
CTGMdiWinResizer
CTGMenuTitle
►CTGPopupMenu
CTRootContextMenu
►CTGProgressBar
CTGHProgressBar
CTGVProgressBar
CTGScrollBar
CTGScrollBarElement
CTGSlider
CTGSpeedo
►CTGSplitter
CTGHSplitter
►CTGVSplitter
CTGVFileSplitter
CTGTabElement
►CTGTableCell
CTGTableHeader
CTGTextEntry
CTGuiBldDragManager
CTGVertical3DLine
►CTGPicture
CTGSelectedPicture
CTGPicturePool
CTGraph2DPainter	The TGraphDelaunay painting class
CTGraphEdge	An edge object connecting two nodes which can be added in a TGraphStruct
CTGraphStruct	The Graph Structure is an interface to the graphviz package
CTGRectMap
►CTGRegion
CTGRegionWithId
►CTGrid
CTAlien
CTGLite
►CTGridCollection
CTAlienCollection
►CTGridJDL
CTAlienJDL
►CTGridJob
CTAlienJob
CTAlienMasterJob
CTGLiteJob
CTGTextLayout
CTGUnknownWindowHandler
►CTH2PolyBin	Helper class to represent a bin in the TH2Poly histogram
CTProfile2PolyBin	Helper class to represent a bin in the TProfile2Poly histogram
►CTHLimitsFinder	Class to compute nice axis limits
CTProofLimitsFinder	Class to find axis limits and synchronize them between workers
CTHnChain	A class to chain together multiple histograms
CTHnIter	Iterator over THnBase bins
CTHnSparseArrayChunk	THnSparseArrayChunk is used internally by THnSparse
CTHostAuth
CTHtml
►CTHtml::TFileSysEntry
►CTHtml::TFileSysDir
CTHtml::TFileSysDB
CTHtml::TFileSysRoot
►CTHtml::THelperBase
CTHtml::TFileDefinition
CTHtml::TModuleDefinition
CTHtml::TPathDefinition
CTHttpCallArg
CTImagePalette	A class to define a conversion from pixel values to pixel color
►CTImagePlugin
►CTASImagePlugin
CTASPluginGS	Allows to read PS/EPS/PDF files via GhostScript
CTInetAddress	This class represents an Internet Protocol (IP) address
CTKDTree< Index, Value >	Class implementing a kd-tree
CTKDTreeBinning	<- TKDTreeBinning - A class providing multidimensional binning ->
CTKSocket
CTLDAPEntry
CTLDAPResult
CTLDAPServer
CTLegendEntry	Storage class for one entry of a TLegend
CTLimitDataSource	This class serves as interface to feed data into the TLimit routines
CTLine	A simple line
CTLockFile	A scoped lock based on files
CTLockPath	Path locking class allowing shared and exclusive locks
CTLorentzRotation	Describes Lorentz transformations including Lorentz boosts and rotations (see TRotation)
CTLorentzVector	TLorentzVector is a general four-vector class, which can be used either for the description of position and time (x,y,z,t) or momentum and energy (px,py,pz,E)
CTMapFile	This class implements a shared memory region mapped to a file
CTMarker	Manages Markers
CTMarker3DBox	A special 3-D marker designed for event display
►CTMatrixTBase< Element >	Linear Algebra Package
CTMatrixT< Element >	TMatrixT
CTMatrixT< AReal >
CTMatrixT< Double_t >
CTMatrixTSparse< Element >	TMatrixTSparse
CTMatrixTSparse< Double_t >
CTMatrixTSym< Element >	TMatrixTSym
CTMatrixTSym< Double_t >
►CTMatrixTLazy< Element >	Templates of Lazy Matrix classes
CTHaarMatrixT< Element >
CTHilbertMatrixT< Element >
►CTMatrixTSymLazy< Element >
CTHilbertMatrixTSym< Element >
CTMCParticle	This class serves as a data storage for description of one particle
CTMCVerbose	Class for printing a detailed information from MC application
CTMemStat
CTMemStatShow	Utility class post-processing the file generated by TMemStat (default memstat.root)
CTMergerInfo
CTMethodCall	Method or function calling interface
CTMLPAnalyzer
CTMonitor
►CTMrbSubevent_Caen
CTUsrSevtData1
CTUsrSevtData2
CTMultiLayerPerceptron
►CTMutexImp
CTPosixMutex
CTWin32Mutex
CTMVA::DataInputHandler	Class that contains all the data information
CTMVA::DataSetFactory	Class that contains all the data information
CTMVA::DataSetInfo	Class that contains all the data information
CTMVA::DataSetManager	Class that contains all the data information
CTMVA::Event
CTMVA::Experimental::ClassificationResult
CTMVA::MsgLogger	Ostringstream derivative to redirect and format output
►CTMVA::OptionBase	Class for TMVA-option handling
►CTMVA::Option< T >
CTMVA::Option< T * >
►CTMVA::PDEFoam	Implementation of PDEFoam
►CTMVA::PDEFoamDiscriminant	This PDEFoam variant stores in every cell the discriminant
CTMVA::PDEFoamDecisionTree	This PDEFoam variant acts like a decision tree and stores in every cell the discriminant
►CTMVA::PDEFoamEvent	This PDEFoam variant stores in every cell the sum of event weights and the sum of the squared event weights
CTMVA::PDEFoamMultiTarget	This PDEFoam variant is used to estimate multiple targets by creating an event density foam (PDEFoamEvent), which has dimension:
CTMVA::PDEFoamTarget	This PDEFoam variant stores in every cell the average target fTarget (see the Constructor) as well as the statistical error on the target fTarget
CTMVA::PDEFoamCell
►CTMVA::PDEFoamDensityBase	This is an abstract class, which provides an interface for a PDEFoam density estimator
CTMVA::PDEFoamDecisionTreeDensity	This is a concrete implementation of PDEFoam
CTMVA::PDEFoamDiscriminantDensity	This is a concrete implementation of PDEFoam
CTMVA::PDEFoamEventDensity	This is a concrete implementation of PDEFoam
CTMVA::PDEFoamTargetDensity	This is a concrete implementation of PDEFoam
►CTMVA::PDEFoamKernelBase	This class is the abstract kernel interface for PDEFoam
CTMVA::PDEFoamKernelGauss	This PDEFoam kernel estimates a cell value for a given event by weighting all cell values with a gauss function
CTMVA::PDEFoamKernelLinN	This PDEFoam kernel estimates a cell value for a given event by weighting with cell values of the nearest neighbor cells
CTMVA::PDEFoamKernelTrivial	This class is a trivial PDEFoam kernel estimator
CTMVA::PDEFoamVect
►CTMVA::Results	Class that is the base-class for a vector of result
CTMVA::ResultsClassification	Class that is the base-class for a vector of result
CTMVA::ResultsMulticlass	Class which takes the results of a multiclass classification
CTMVA::ResultsRegression	Class that is the base-class for a vector of result
CTMVA::RootFinder	Root finding using Brents algorithm (translated from CERNLIB function RZERO)
CTMVA::TNeuron	Neuron class used by TMVA artificial neural network methods
CTMVA::TreeInfo
CTMVA::TSynapse	Synapse class used by TMVA artificial neural network methods
►CTMVA::VariableTransformBase	Linear interpolation class
CTMVA::VariableDecorrTransform	Linear interpolation class
CTMVA::VariableGaussTransform	Gaussian Transformation of input variables
CTMVA::VariableIdentityTransform	Linear interpolation class
CTMVA::VariableNormalizeTransform	Linear interpolation class
CTMVA::VariablePCATransform	Linear interpolation class
CTMVA::VariableRearrangeTransform	Rearrangement of input variables
►CTNamed	Base class for all named ROOT classes
CRooAbsArg	RooAbsArg is the common abstract base class for objects that represent a value (of arbitrary type) and "shape" that in general depends on (is a client of) other RooAbsArg subclasses
CRooAbsBinning	RooAbsBinning is the abstract base class for RooRealVar binning definitions This class defines the interface to retrieve bin boundaries, ranges etc
CRooAbsData	RooAbsData is the common abstract base class for binned and unbinned datasets
CRooAbsDataStore	RooAbsDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism
CRooAbsGenContext	RooAbsGenContext is the abstract base class for generator contexts of RooAbsPdf objects
►CRooAbsMCStudyModule	RooAbsMCStudyModule is a base class for add-on modules to RooMCStudy that can perform additional calculations on each generate+fit cycle managed by RooMCStudy
CRooChi2MCSModule	RooChi2MCSModule is an add-on modules to RooMCStudy that calculates the chi-squared of fitted p.d.f with respect to a binned version of the data
CRooDLLSignificanceMCSModule	RooDLLSignificanceMCSModule is an add-on modules to RooMCStudy that calculates the significance of a signal by comparing the likelihood of a fit fit with a given parameter floating with a fit with that given parameter fixed to a nominal value (usually zero)
CRooRandomizeParamMCSModule	RooRandomizeParamMCSModule is an add-on modules to RooMCStudy that allows you to randomize input generation parameters
CRooStats::UpperLimitMCSModule	This class allow to compute in the ToyMcStudy framework the ProfileLikelihood upper limit for each toy-MC sample generated
CRooAbsNumGenerator	Class RooAbsNumGenerator is the abstract base class for MC event generator implementations like RooAcceptReject and RooFoam
►CRooAbsStudy	RooAbsStudy is an abstract base class for RooStudyManager modules
CRooGenFitStudy	RooGenFitStudy is an abstract base class for RooStudyManager modules
CRooStats::ToyMCStudy	ToyMCStudy is an implementation of RooAbsStudy for toy Monte Carlo sampling
CRooArgProxy	RooArgProxy is the abstact interface for RooAbsArg proxy classes
CRooClassFactory	RooClassFactory is a clase like TTree::MakeClass() that generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names
CRooCmdArg	RooCmdArg is a named container for two doubles, two integers two object points and three string pointers that can be passed as generic named arguments to a variety of RooFit end user methods
CRooCustomizer
CRooDouble	RooDouble is a minimal implementation of a TObject holding a Double_t value
CRooFactoryWSTool	RooFactoryWSTool is a clase like TTree::MakeClass() that generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names
CRooFitResult
CRooInt	RooInt is a minimal implementation of a TObject holding a Int_t value
CRooMapCatEntry
CRooMCStudy	RooMCStudy is a help class to facilitate Monte Carlo studies such as 'goodness-of-fit' studies, that involve fitting a PDF to multiple toy Monte Carlo sets generated from the same PDF or another PDF
CRooNameReg	RooNameReg is a registry for 'const char*' name
CRooPlot	A RooPlot is a plot frame and a container for graphics objects within that frame
CRooSimWSTool
CRooSimWSTool::SplitRule
CRooStats::BayesianCalculator	BayesianCalculator is a concrete implementation of IntervalCalculator, providing the computation of a credible interval using a Bayesian method
CRooStats::ConfidenceBelt	ConfidenceBelt is a concrete implementation of the ConfInterval interface
►CRooStats::ConfInterval	ConfInterval is an interface class for a generic interval in the RooStats framework
CRooStats::LikelihoodInterval	LikelihoodInterval is a concrete implementation of the RooStats::ConfInterval interface
CRooStats::MCMCInterval	MCMCInterval is a concrete implementation of the RooStats::ConfInterval interface
CRooStats::PointSetInterval	PointSetInterval is a concrete implementation of the ConfInterval interface
►CRooStats::SimpleInterval	SimpleInterval is a concrete implementation of the ConfInterval interface
CRooStats::HypoTestInverterResult	HypoTestInverterResult class holds the array of hypothesis test results and compute a confidence interval
CRooStats::HistFactory::Measurement
CRooStats::HLFactory	HLFactory is an High Level model Factory allows you to describe your models in a configuration file (datacards) acting as an interface with the RooFactoryWSTool
CRooStats::HybridCalculatorOriginal	HybridCalculatorOriginal class
CRooStats::HybridPlot	This class provides the plots for the result of a study performed with the HybridCalculatorOriginal class
CRooStats::HypoTestInverterOriginal	This class is now deprecated and to be replaced by the HypoTestInverter
CRooStats::HypoTestInverterPlot	Class to plot an HypoTestInverterResult, result of the HypoTestInverter calculator
►CRooStats::HypoTestResult	HypoTestResult is a base class for results from hypothesis tests
CRooStats::HybridResult	Class encapsulating the result of the HybridCalculatorOriginal
CRooStats::LikelihoodIntervalPlot	This class provides simple and straightforward utilities to plot a LikelihoodInterval object
CRooStats::MarkovChain	Stores the steps in a Markov Chain of points
CRooStats::MCMCCalculator	Bayesian Calculator estimating an interval or a credible region using the Markov-Chain Monte Carlo method to integrate the likelihood function with the prior to obtain the posterior function
CRooStats::MCMCIntervalPlot	This class provides simple and straightforward utilities to plot a MCMCInterval object
CRooStats::ModelConfig	ModelConfig is a simple class that holds configuration information specifying how a model should be used in the context of various RooStats tools
CRooStats::SamplingDistPlot	This class provides simple and straightforward utilities to plot SamplingDistribution objects
CRooStats::SamplingDistribution	This class simply holds a sampling distribution of some test statistic
CRooStats::SPlot	This class calculates sWeights used to create an sPlot
CRooStats::ToyMCPayload
CRooStudyManager	RooStudyManager is a utility class to manage studies that consist of repeated applications of generate-and-fit operations on a workspace
CRooStudyPackage	RooStudyPackage is a utility class to manage studies that consist of repeated applications of generate-and-fit operations on a workspace
CROOT::Internal::TBranchDescriptor
CROOT::Internal::TBranchProxyClassDescriptor
CROOT::Internal::TBranchProxyDescriptor
CROOT::Internal::TFriendProxyDescriptor
CROOT::Internal::THnBaseBrowsable	TBrowser helper for THnBase
CROOT::TSchemaRule::TSources
►CROOT::v5::TFormula	The FORMULA class (ROOT version 5)
CRooFormula	RooFormula an implementation of ROOT::v5::TFormula that interfaces it to RooAbsArg value objects
CROOT::v5::TF1Data
CTTreeFormula	Used to pass a selection expression to the Tree drawing routine
CROOT::v5::TFormulaPrimitive	The Formula Primitive class
CRooTable	RooTable is the abstract interface for table objects
CRooTObjWrap	RooInt is a minimal implementation of a TNamed holding a TObject
CRooUnitTest	RooUnit test is an abstract base class for unit regression tests for RooFit and RooStats tests performed in stressRooFit and stressRooStats Implementations of this class must implement abstract method testCode() which defines the regression test to be performed
CRooWorkspace	The RooWorkspace is a persistable container for RooFit projects
CTAlienDirectory
CTAlienDirectoryEntry
CTApplicationRemote::TARFileStat
CTAttParticle	Particle definition, partly based on GEANT3 particle definition
CTAxis	Class to manage histogram axis
CTAxis3D	The 3D axis painter class
CTBenchmark	This class is a ROOT utility to help benchmarking applications
CTBranch	A TTree is a list of TBranches
CTBrowser	Using a TBrowser one can browse all ROOT objects
CTBrowserPlugin
CTChainElement	A TChainElement describes a component of a TChain
CTClassTree	Draw inheritance tree and their relations for a list of classes
►CTColor	The color creation and management class
►CTColorGradient	TColorGradient extends basic TColor
CTLinearGradient	Define a linear color gradient
CTRadialGradient	Define a radial color gradient
CTColorWheel	Draw the ROOT Color Wheel
►CTContextMenu	This class provides an interface to context sensitive popup menus
CTEveContextMenu	Specialization of TContext menu
►CTControlBarButton	This class defines the control bar buttons
CTControlBar	A Control Bar is a fully user configurable tool which provides fast access to frequently used operations
CTCut	A specialized string object used for TTree selections
CTDatabasePDG	Particle database manager class
►CTDataSet
►CTChair
CTColumnView
CTFileSet
►CTObjectSet
CTVolume
CTVolumeView
►CTTable
►CTGenericTable
CTResponseTable
CTIndexTable
CTTableDescriptor
►CTDictionary	This class defines an abstract interface that must be implemented by all classes that contain dictionary information
CTBaseClass	Each class (see TClass) has a linked list of its base class(es)
►CTClass	The ROOT global object gROOT contains a list of all defined classes
CTQClass
CTDataMember	All ROOT classes may have RTTI (run time type identification) support added
CTDataType	Basic data type descriptor (datatype information is obtained from CINT)
CTEnum	Implements the enum type
►CTFunction	Global functions class (global functions are obtained from CINT)
CTMethod	Each ROOT class (see TClass) has a linked list of methods
CTFunctionTemplate	Dictionary for function template This class describes one single function template
►CTGlobal	Global variables class (global variables are obtained from CINT)
CTEnumConstant	Implements the constants of the enum type
CTGlobalMappedFunction
CTMethodArg	Each ROOT method (see TMethod) has a linked list of its arguments
►CTDirectory	Describe directory structure in memory
►CTDirectoryFile	A ROOT file is structured in Directories (like a file system)
CRooWorkspace::WSDir
►CTFile	A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format
CTChirpFile	Read and write data via a Chirp server
CTDavixFile
CTDCacheFile	A TDCacheFile is like a normal TFile except that it may read and write its data via a dCache server (for more on the dCache daemon see http://www-dcache.desy.de/
CTGFALFile	Read and write data via the underlying Grid access mechanism
CTHDFSFile	Reads and writes its data via the HDFS protocols
►CTMemFile	A TMemFile is like a normal TFile except that it reads and writes only from memory
CROOT::Experimental::TBufferMergerFile
CTParallelMergingFile
►CTNetFile
CTCastorFile	A TNetFile interfaced to the Castor storage backend
►CTXNetFile
CTAlienFile
CTNetXNGFile
CTRFIOFile	A ROOT file that reads/writes via a rfiod server
CTSQLFile	Access an SQL db via the TFile interface
►CTWebFile
CTS3WebFile
CTXMLFile
CTROOT	ROOT top level object description
►CTDocDirective
CTDocHtmlDirective
CTDocLatexDirective
CTDocMacroDirective
►CTDSet	This class implements a data set to be used for PROOF processing
CTDSetProxy
CTDSetElement	Manages an element of a TDSet
CTEfficiency	Class to handle efficiency histograms
►CTEntryList	A List of entry numbers in a TTree or TChain
CTEntryListArray	A list of entries and subentries in a TTree or TChain
CTEntryListArray	A list of entries and subentries in a TTree or TChain
CTEntryListFromFile	Manages entry lists from different files, when they are not loaded in memory at the same time
CTEveArrow	Class used for display of a thick arrow
CTEveCaloData	A central manager for calorimeter event data
CTEveCaloViz	Base class for calorimeter data visualization
CTEveDigitSet	Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox)
CTEveElementList	A list of TEveElements
CTEveGeoShapeExtract	Globally positioned TGeoShape with rendering attributes and an optional list of daughter shape-extracts
CTEventIterTree::TFileTree
CTEventList	A TEventList object is a list of selected events (entries) in a TTree
CTEveParamList	Collection of named parameters
CTEvePointSetArray	An array of point-sets with each point-set playing a role of a bin in a histogram
CTEveProjectionAxes	Axes for non-linear projections
CTEveSceneInfo	TEveUtil representation of TGLSceneInfo
CTEveStraightLineSet	Set of straight lines with optional markers along the lines
CTEveText	TEveElement class used for displaying FreeType GL fonts
CTExec	TExec is a utility class that can be used to execute a C++ command when some event happens in a pad
CTF1	1-Dim function class
CTFileCollection	Class that contains a list of TFileInfo's and accumulated meta data information about its entries
CTFileDrawMap	This class is automatically called by TFile::DrawMap
CTFileInfo	Class describing a generic file including meta information
CTFileInfoMeta
CTFileOpenHandle	Class holding info about the file being opened
►CTFileStager
CTNetFileStager
CTNetXNGFileStager
CTXNetFileStager
CTFitResult	Extends the ROOT::Fit::Result class with a TNamed inheritance providing easy possibility for I/O
CTFITSHDU	FITS file interface class
CTFolder	A TFolder object is a collection of objects and folders
CTFormula	The Formula class
CTFriendElement	A TFriendElement TF describes a TTree object TF in a file
►CTGenerator	The interface to various event generators
CTPythia6	TPythia is an interface class to F77 version of Pythia 6.2
CTPythia8	TPythia8 is an interface class to C++ version of Pythia 8.1 event generators, written by T.Sjostrand
►CTGeoElement	Base class for chemical elements
CTGeoElementRN	Class representing a radionuclide
CTGeoIsotope
CTGeoManager	The manager class for any TGeo geometry
CTGeoMaterial	Base class describing materials
►CTGeoMatrix	Geometrical transformation package
►CTGeoCombiTrans	Class describing rotation + translation
CTGeoGenTrans	Most general transformation, holding a translation, a rotation and a scale
CTGeoHMatrix	Matrix class used for computing global transformations Should NOT be used for node definition
CTGeoIdentity	An identity transformation
CTGeoRotation	Class describing rotations
CTGeoScale	Class describing scale transformations
CTGeoTranslation	Class describing translations
CTGeoMedium	Media are used to store properties related to tracking and which are useful only when using geometry with a particle transport MC package (via VMC)
CTGeometry	TGeometry description
CTGeoNode	A node represent a volume positioned inside another.They store links to both volumes and to the TGeoMatrix representing the relative positioning
CTGeoOverlap	Base class describing geometry overlaps
CTGeoParallelWorld	Base class for a flat parallel geometry
CTGeoPhysicalNode	Physical nodes are the actual 'touchable' objects in the geometry, representing a path of positioned volumes starting with the top node: path=/TOP/A_1/B_4/C_3 , where A, B, C represent names of volumes
CTGeoPNEntry	The knowledge of the path to the objects that need to be misaligned is essential since there is no other way of identifying them
CTGeoRegion	Regions are groups of volumes having a common set of user tracking cuts
CTGeoRegionCut
►CTGeoShape	Base abstract class for all shapes
►CTGeoBBox	Box class
CTEveGeoPolyShape	Description of TEveGeoPolyShape
►CTGeoArb8	An arbitrary trapezoid with less than 8 vertices standing on two parallel planes perpendicular to Z axis
►CTGeoTrap	TRAP is a general trapezoid, i.e
CTGeoGtra	Gtra is a twisted trapezoid
CTGeoCompositeShape	Class handling Boolean composition of shapes
►CTGeoCone	Conical tube class
CTGeoConeSeg	A phi segment of a conical tube
CTGeoHalfSpace	A half-space defined by:
CTGeoPara	Parallelepiped class
CTGeoParaboloid	Paraboloid class
►CTGeoPcon	A polycone
CTGeoPgon	A polygone
CTGeoScaledShape	A shape scaled by a TGeoScale transformation
CTGeoShapeAssembly	The shape encapsulating an assembly (union) of volumes
CTGeoSphere	Spherical shell class
CTGeoTorus	Torus segment class
CTGeoTrd1	A trapezoid with only x length varying with z
CTGeoTrd2	A trapezoid with both x and y lengths varying with z
►CTGeoTube	Cylindrical tube class
CTGeoEltu	Elliptical tube class
CTGeoHype	Hyperboloid class defined by 5 parameters
►CTGeoTubeSeg	A phi segment of a tube
CTGeoCtub	A tube segment cut with 2 planes
CTGeoVGShape	Bridge class for using a VecGeom solid as TGeoShape
CTGeoXtru	An extrusion with fixed outline shape in x-y and a sequence of z extents (segments)
CTGeoVolume	TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes
►CTGEventHandler
►CTGLEventHandler	Base-class and default implementation of event-handler for TGLViewer
CTEveLegoEventHandler	A base class of TGLEventHandler
CTGFont
CTGL5DDataSet
►CTGLManager
CTGOSXGLManager
CTGWin32GLManager
CTGWin32GLManagerProxy
CTX11GLManager	The TX11GLManager is X11 implementation of TGLManager
CTGLParametricEquation	A parametric surface is a surface defined by a parametric equation, involving two parameters (u, v):
CTGLTH3Slice	A slice of a TH3
CTGraph	A Graph is a graphics object made of two arrays X and Y with npoints each
CTGraph2D	Graphics object made of three arrays X, Y and Z with the same number of points each
CTGraphDelaunay	TGraphDelaunay generates a Delaunay triangulation of a TGraph2D
CTGraphDelaunay2D	TGraphDelaunay2D generates a Delaunay triangulation of a TGraph2D
CTGraphNode	A graph node object which can be added in a TGraphStruct
CTGraphPolargram	To draw polar axis
CTGraphSmooth	A helper class to smooth TGraph
CTGraphTime	TGraphTime is used to draw a set of objects evolving with nsteps in time between tmin and tmax
►CTGridJobStatus
CTAlienJobStatus
CTAlienMasterJobStatus
CTGLiteJobStatus
CTGuiBldAction
►CTGuiFactory	This ABC is a factory for GUI components
CTQtRootGuiFactory
►CTRootGuiFactory
CTQRootGuiFactory
CTH1	The TH1 histogram class
CTHbookFile	This class is an interface to the Hbook objects in Hbook files
CTHbookKey	HBOOK Key
►CTHnBase	Multidimensional histogram base
►CTHn	Multidimensional histogram
CTHnT< T >	Templated implementation of the abstract base THn
►CTHnSparse	Efficient multidimensional histogram
CTHnSparseT< CONT >	Templated implementation of the abstract base THnSparse
CTHStack	The Histogram stack class
►CTHttpEngine
CTCivetweb
CTFastCgi
CTHttpServer
CTHttpWSHandler
CTImage	An abstract interface to image processing library
CTInterpreter	This class defines an abstract interface to a generic command line interpreter
CTKDE	Kernel Density Estimation class
►CTKey	Book space in a file, create I/O buffers, to fill them, (un)compress them
►CTBasket	Manages buffers for branches of a Tree
CTBasketSQL	Implement TBasket for a SQL backend
CTKeySQL	TKeySQL represents meta-inforamtion about object, which was written to SQL database
CTKeyXML
CTKeyMapFile	Utility class for browsing TMapFile objects
CTLDAPAttribute
►CTLeaf	A TLeaf describes individual elements of a TBranch See TBranch structure in TTree
CTLeafB	A TLeaf for an 8 bit Integer data type
CTLeafC	A TLeaf for a variable length string
CTLeafD	A TLeaf for a 64 bit floating point data type
CTLeafElement	A TLeaf for the general case when using the branches created via a TStreamerInfo (i.e
CTLeafF	A TLeaf for a 32 bit floating point data type
CTLeafI	A TLeaf for an Integer data type
CTLeafL	A TLeaf for a 64 bit Integer data type
CTLeafO	A TLeaf for a bool data type
CTLeafObject	A TLeaf for a general object derived from TObject
CTLeafS	A TLeaf for a 16 bit Integer data type
CTLibraryDocInfo
►CTMacro	Class supporting a collection of lines with C++ code
CTEveMacro	Sub-class of TMacro, overriding Exec to unload the previous version and cleanup after the execution
CTMaterial	Manages a detector material
CTMessageHandler	Handle messages that might be generated by the system
►CTMinuit	Implementation in C++ of the Minuit package written by Fred James
CTMVA::MinuitWrapper	Wrapper around MINUIT
CTMinuit2TraceObject
CTModuleDocInfo
CTMonaLisaText
CTMonaLisaValue
CTMultiDimFit	Multidimensional Fits in ROOT
CTMultiGraph	A TMultiGraph is a collection of TGraph (or derived) objects
CTMVA::ClassInfo	Class that contains all the information of a class
►CTMVA::Configurable
►CTMVA::CvSplit
CTMVA::CvSplitKFolds
CTMVA::DataLoader
►CTMVA::Envelope	Abstract base class for all high level ml algorithms, you can book ml methods like BDT, MLP
CTMVA::CrossValidation	Class to perform cross validation, splitting the dataloader into folds
CTMVA::Experimental::Classification
CTMVA::HyperParameterOptimisation
CTMVA::VariableImportance
CTMVA::Factory	This is the main MVA steering class
►CTMVA::FitterBase	Base class for TMVA fitters
CTMVA::GeneticFitter	Fitter using a Genetic Algorithm
CTMVA::MCFitter	Fitter using Monte Carlo sampling of parameters
CTMVA::MinuitFitter	/Fitter using MINUIT
CTMVA::SimulatedAnnealingFitter	Fitter using a Simulated Annealing Algorithm
CTMVA::MethodBase	Virtual base Class for all MVA method
CTMVA::PDF	PDF wrapper for histograms; uses user-defined spline interpolation
CTMVA::Reader	Serves to use the MVAs in a specific analysis context
CTMVA::DataSet	Class that contains all the data information
CTMVA::MethodInfo
CTMVA::VariableInfo	Class for type info of MVA input variable
CTNeuron
CTNode	TNode description
CTPackMgr	The PROOF package manager contains tools to manage packages
CTParallelCoord	Parallel Coordinates class
CTParallelCoordRange	A TParallelCoordRange is a range used for parallel coordinates plots
CTParallelCoordVar	TParallelCoord axes
CTParticleClassPDG	Utility class used internally by TDatabasePDG
CTParticlePDG	Description of the static properties of a particle
CTPie	Draw a Pie Chart,
CTPieSlice	A slice of a piechart, see the TPie class
CTPrincipal	Principal Components Analysis (PCA)
►CTProcessID	A TProcessID identifies a ROOT job in a unique way in time and space
CTProcessUUID	This class is a specialized TProcessID managing the list of UUIDs
►CTProof	This class controls a Parallel ROOT Facility, PROOF, cluster
CTProofCondor
CTProofLite	This class starts a PROOF session on the local machine: no daemons, client and master merged, communications via UNIX-like sockets
CTProofSuperMaster	Implementation of TProof controlling PROOF federated clusters
CTProofDesc
CTProofLockPath
CTProofLog	Implementation of the PROOF session log handler
CTProofLogElem
►CTProofMgr	The PROOF manager interacts with the PROOF server coordinator to create or destroy a PROOF session, attach to or detach from existing one, and to monitor any client activity on the cluster
CTProofMgrLite	Basic TProofMgr functionality implementation in the case of Lite session
CTXProofMgr	Implementation of the functionality provided by TProofMgr in the case of a xproofd-based session
►CTProofMonSender	Provides the interface for PROOF monitoring to different writers
CTProofMonSenderML	TProofMonSender implementation for the ML writer
CTProofMonSenderSQL	TProofMonSender implementation for the SQL writers
CTProofMonSender::TDSetPlet
CTProofOutputFile	Class to steer the merging of files produced on the workers
CTProofPerfAnalysis	Set of tools to analyse the performance tree
CTProofVectorContainer< T >
CTProofVectorContainer< TProofDrawListOfGraphs::Point3D_t >
CTProofVectorContainer< TProofDrawListOfPolyMarkers3D::Point4D_t >
CTProtoClass	Persistent version of a TClass
►CTQueryResult	A container class for query results
CTProofQueryResult	TQueryResult version adapted to PROOF neeeds
►CTRandom	This is the base class for the ROOT Random number generators
CTRandom1	The Ranlux Random number generator class
CTRandom2	Random number generator class based on the maximally quidistributed combined Tausworthe generator by L'Ecuyer
CTRandom3	Random number generator class based on M
CTRandomGen< Engine >
CTRemoteObject	Protocol for browsing ROOT objects from a remote ROOT session
CTRootSniffer
CTRotMatrix	Manages a detector rotation matrix
CTShape	This is the base class for all geometry shapes
►CTSocket
CTPSocket
►CTServerSocket
CTPServerSocket
CTSSLSocket
►CTXSocket	High level handler of connections to XProofD
CTXUnixSocket	Implementation of TXSocket using PF_UNIX sockets
CTSpectrum	Advanced Spectra Processing
CTSpectrum2	Advanced 2-dimensional spectra processing
CTSpectrum2Fit	Advanced 2-dimensional spectra fitting functions
CTSpectrum2Painter	Two-dimensional graphics function
CTSpectrum3	Advanced 3-dimensional spectra processing functions
CTSpectrumFit	Advanced 1-dimensional spectra fitting functions
CTSpectrumTransform	Advanced 1-dimensional orthogonal transform functions
CTSpline	Base class for spline implementation containing the Draw/Paint methods
CTSQLColumnInfo
CTSQLTableInfo
CTStatus	This class holds the status of an ongoing operation and collects error messages
►CTStreamerElement
CTStreamerArtificial
CTStreamerBase
CTStreamerBasicPointer
CTStreamerBasicType
CTStreamerLoop
CTStreamerObject
CTStreamerObjectAny
CTStreamerObjectAnyPointer
CTStreamerObjectPointer
►CTStreamerSTL
CTStreamerSTLstring
CTStreamerString
CTStructNodeProperty
CTStyle	TStyle objects may be created to define special styles
►CTSystem	Abstract base class defining a generic interface to the underlying Operating System
CTAlienSystem
CTChirpSystem
CTDavixSystem
CTDCacheSystem
CTGFALSystem	Directory handler for GFAL
CTHDFSSystem	Directory handler for HDFS (THDFSFile)
►CTNetSystem
CTXNetSystem
CTNetXNGSystem
CTRFIOSystem	Directory handler for RFIO
►CTUnixSystem
CTMacOSXSystem
CTWebSystem
CTWinNTSystem
►CTSystemFile	A TSystemFile describes an operating system file
CTSystemDirectory	Describes an Operating System directory for the browser
CTTableSorter
CTTask	TTask is a base class that can be used to build a complex tree of Tasks
CTText	Base class for several text objects
CTThread
►CTThreadFactory
CTPosixThreadFactory
CTWin32ThreadFactory
CTToggle	This class defines toggling facility for both - object's method or variables
CTToggleGroup	This class defines check-box facility for TToggle objects It is used in context menu "selectors" for picking up a value
CTTree	A TTree object has a header with a name and a title
CTUDPSocket
►CTUnfoldBinning	Binning schemes for use with the unfolding algorithm TUnfoldDensity
CTUnfoldBinningXML	XML interfate to binning schemes, for use with the unfolding algorithm TUnfoldDensity
►CTVirtualBranchBrowsable	TVirtualBranchBrowsable is a base class (not really abstract, but useless by itself) for helper objects that extend TBranch's browsing support
CTCollectionPropertyBrowsable	A tiny browser helper object (and its generator) for adding a virtual (as in "not actually part of the class", not in C++ virtual) "@size()" method to a collection
►CTMethodBrowsable	This helper object allows the browsing of methods of objects stored in branches
CTCollectionMethodBrowsable	TCollectionMethodBrowsable extends TCollectionPropertyBrowsable by showing all methods of the collection itself
CTNonSplitBrowsable	Allows a TBrowser to browse non-split branches as if they were split
►CTVirtualFitter	Abstract Base Class for Fitting
CTBackCompFitter	Backward compatible implementation of TVirtualFitter
CTFitter
CTFumili
CTLinearFitter	The Linear Fitter - For fitting functions that are LINEAR IN PARAMETERS
►CTVirtualIndex	Abstract interface for Tree Index
CTChainIndex	A Chain Index
CTTreeIndex	A Tree Index with majorname and minorname
►CTVirtualMagField	Abstract class for magnetic field
CTGeoUniformMagField	Implementation for uniform magnetic field
CTVirtualMC	Abstract Monte Carlo interface
CTVirtualMCApplication	Interface to a user Monte Carlo application
►CTVirtualMCGeometry	Interface to Monte Carlo geometry construction
CTGeoMCGeometry	Implementation of the TVirtualMCGeometry interface for building TGeo geometry
CTVirtualMCSensitiveDetector	Interface to a user defined sensitive detector
CTVirtualMonitoringReader
►CTVirtualMonitoringWriter
CTMonaLisaWriter
CTSQLMonitoringWriter
CTVirtualPS	TVirtualPS is an abstract interface to Postscript, PDF, SVG
►CTVirtualStreamerInfo	Abstract Interface class describing Streamer information for one class
CTStreamerInfo	Describe Streamer information for one class version
CTVirtualX	Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...)
CTXrdClientAdminWrapper
►CTNDArray
CTNDArrayT< T >
CTNDArrayT< Double_t >
CTObjectRefSpy
CTObjectSpy	Monitors objects for deletion and reflects the deletion by reverting the internal pointer to zero
CTObjectTable	This class registers all instances of TObject and its derived classes in a hash table
►CTObjString	Collectable string class
CTClass::TNameMapNode
CTOptionListItem
CTOutputListSelectorDataMap	Set the selector's data members to the corresponding elements of the output list
CTPackageDescription
CTPainter3dAlgorithms	The Legos and Surfaces painter class
CTPair	Class used by TMap to store (key,value) pairs
CTParameter< AParamType >	Named parameter, streamable and storable
►CTParameter< Long64_t >
CTSelectorScalar	Named scalar type, based on Long64_t, streamable, storable and mergable
CTParticle	Description of the dynamic properties of a particle
CTPBHandleDSType
CTPBHistType
CTPBReadType
CTPerfEvent
CTPluginHandler
CTPluginManager	This class implements a plugin library manager
►CTPoints3DABC	Abstract class to define Arrays of 3D points
CTPoints3D
CTPointsArray3D
►CTTablePoints
CTTable3Points
CTPolyLine	Defined by an array on N points in a 2-D space
CTPolyLine3D	A 3-dimensional polyline
CTPolyMarker	A PolyMarker is defined by an array on N points in a 2-D space
CTPolyMarker3D	A 3D polymarker
CTPrimary	Old version of a dynamic particle class created by event generators
CTProofBench	Steering class for PROOF benchmarks
CTProofBenchDataSet	Handle operations on datasets used by ProofBench
►CTProofBenchRun	Abstract base class for PROOF benchmark runs
CTProofBenchRunCPU	CPU-intensive PROOF benchmark test generates events and fill 1, 2, or 3-D histograms
CTProofBenchRunDataRead	I/O-intensive PROOF benchmark test reads in event files distributed on the cluster
CTProofNodeInfo	The purpose of this class is to provide a complete node description for masters, submasters and workers
CTProofNodes	PROOF worker node information
CTProofProgressInfo
CTProofProgressStatus	Container class for processing statistics
►CTProofResources
CTProofResourcesStatic	The purpose of this class is to provide a standard interface to static config files
CTPyDispatcher
►CTQpDataBase
CTQpDataDens
CTQpDataSparse
►CTQpLinSolverBase
CTQpLinSolverDens
CTQpLinSolverSparse
►CTQpProbBase
CTQpProbDens
CTQpProbSparse
CTQpResidual
►CTQpSolverBase
CTGondzioSolver
CTMehrotraSolver
CTQpVar
CTQuaternion	Quaternion is a 4-component mathematic object quite convenient when dealing with space rotation (or reference frame transformation)
CTQueryDescription
CTQueryResultManager	Class managing the query-result area
CTrack
CTRatioPlot	Class for displaying ratios, differences and fit residuals
CTRealData	Manages the effective list of all data members for a given class
►CTRecEvent
CTRecCmdEvent
CTRecExtraEvent
CTRecGuiEvent
CTRecorder
CTRecWinPair
CTRef	Persistent Reference link to a TObject A TRef is a lightweight object pointing to any TObject
CTRefTable	A TRefTable maintains the association between a referenced object and the parent object supporting this referenced object
CTRobustEstimator	Minimum Covariance Determinant Estimator - a Fast Algorithm invented by Peter J.Rousseeuw and Katrien Van Dreissen "A Fast Algorithm for the Minimum covariance Determinant Estimator" Technometrics, August 1999, Vol.41, NO.3
CTRolke	This class computes confidence intervals for the rate of a Poisson process in the presence of uncertain background and/or efficiency
►CTRootSnifferStore	Abstract interface for storage of hierarchy scan in TRootSniffer
CTRootSnifferStoreJson	Storage of hierarchy scan in TRootSniffer in JSON format
CTRootSnifferStoreXml	Storage of hierarchy scan in TRootSniffer in XML format
CTRotation	Describes a rotation of objects of the TVector3 class
CTRWLock
CTS3HTTPRequest
►CTSecContext
CTRootSecContext
CTSecContextCleanup
►CTSelector	A TSelector object is used by the TTree::Draw, TTree::Scan, TTree::Process to navigate in a TTree and make selections
Ch1analysis
Ch1analysisTreeReader
CRooProofDriverSelector
►CTProofDraw	Implement Tree drawing using PROOF
CTProofDrawEntryList
CTProofDrawEventList
CTProofDrawGraph
CTProofDrawHist
CTProofDrawListOfGraphs
CTProofDrawListOfPolyMarkers3D
CTProofDrawPolyMarker3D
CTProofDrawProfile
CTProofDrawProfile2D
CTPySelector
►CTSelectorDraw	A specialized TSelector for TTree::Draw
CTEvePointSelector	TEvePointSelector is a sub-class of TSelectorDraw for direct extraction of point-like data from a Tree
CTEveSelectorToEventList	TSelector that stores entry numbers of matching TTree entries into an event-list
CTSelectorEntries	The class is derived from the ROOT class TSelector
CTSelEvent	Selector for PROOF I/O benchmark test
CTSelEventGen	Selector for event file generation
CTSelHandleDataSet	PROOF selector for file cache release
CTSelHist	PROOF selector for CPU-intensive benchmark test
CTSelVerifyDataSet	Selector to verify dataset in parallel on workers
CTSemaphore
CTSessionDescription
►CTSlave	Class describing a PROOF worker server
CTSlaveLite	Version of TSlave for local worker servers
CTXSlave	This is the version of TSlave for workers servers based on XProofD
CTSlaveInfo
CTSpectrum2Transform	Advanced 2-dimensional orthogonal transform functions
CTSpider	Spider class
►CTSplinePoly	Base class for TSpline knot
CTSplinePoly3	Class for TSpline3 knot
CTSplinePoly5	Class for TSpline5 knot
CTSPlot
CTSQLClassColumnInfo
CTSQLClassInfo	Contains information about tables specific to one class and version
CTSQLColumnData
CTSQLObjectData	TSQLObjectData is used in TBufferSQL2 class in reading procedure
CTSQLObjectDataPool	XML object keeper class
CTSQLObjectInfo	Info (classname, version) about object in database
►CTSQLResult
CTMySQLResult
CTODBCResult
CTOracleResult
CTPgSQLResult
CTSapDBResult
CTSQLiteResult
CTTreeResult	Class defining interface to a TTree query result with the same interface as for SQL databases
►CTSQLRow
CTMySQLRow
CTODBCRow
CTOracleRow
CTPgSQLRow
CTSapDBRow
CTSQLiteRow
CTTreeRow	Class defining interface to a row of a TTree query result
►CTSQLServer
CTMySQLServer
CTODBCServer
CTOracleServer
CTPgSQLServer
CTSapDBServer
CTSQLiteServer
►CTSQLStatement
CTMySQLStatement
CTODBCStatement
CTOracleStatement
CTPgSQLStatement
CTSQLiteStatement
CTSQLStructure	This is hierarchical structure, which is created when data is written by TBufferSQL2
CTSQLTableData
CTStatistic	Statistical variable, defined by its mean and variance (RMS)
CTStatsFeedback	Utility class to display PROOF stats feedback histos during queries
►CTStopwatch	Stopwatch class
CTMVA::Timer	Timing information for training and evaluation of MVA methods
CTStreamerInfoActions::TActionSequence
CTStreamerInfoActions::TConfiguredAction
CTStructNode
CTStructViewer
CTSVDUnfold	SVD Approach to Data Unfolding
CTSynapse
►CTSysEvtHandler	Abstract base class for handling system events
►CTFileHandler
CTASLogHandler
CTProofInputHandler
CTProofServLogHandler
CTXSocketHandler	Input handler for XProofD sockets
►CTSignalHandler
CTARInterruptHandler
CTProofInterruptHandler
►CTStdExceptionHandler
CTEveManager::TExceptionHandler	Exception handler for Eve exceptions
►CTTimer	Handles synchronous and a-synchronous timer events
CTGLRedrawTimer
CTIdleTOTimer
CTProcessEventTimer
CTReaperTimer
CTShutdownTimer
CTThreadTimer
CTViewTimer
CTTableIter
CTTableMap
►CTThreadImp
CTPosixThread
CTWin32Thread
CTTreeDrawArgsParser	A class that parses all parameters for TTree::Draw()
CTTreeFormulaManager	Used to coordinate one or more TTreeFormula objects
CTTreeReader	TTreeReader is a simple, robust and fast interface to read values from a TTree, TChain or TNtuple
CTTVRecord	I/O classes for TreeViewer session handling
CTTVSession	I/O classes for TreeViewer session handling
►CTUnfold	An algorithm to unfold distributions from detector to truth level
►CTUnfoldSys	An algorithm to unfold distributions from detector to truth level, with background subtraction and propagation of systematic uncertainties
CTUnfoldDensity	An algorithm to unfold distributions from detector to truth level
CTUri	This class represents a RFC 3986 compatible URI
CTUrl	This class represents a WWW compatible URL
CTUsrHit
CTUsrHitBuffer
CTVector2	TVector2 is a general two vector class, which can be used for the description of different vectors in 2D
CTVector3	TVector3 is a general three vector class, which can be used for the description of different vectors in 3D
CTVectorT< Element >	TVectorT
CTVectorT< Double_t >
CTView	See TView3D
►CTVirtualFFT	TVirtualFFT is an interface class for Fast Fourier Transforms
CTFFTComplex
CTFFTComplexReal
CTFFTReal
CTFFTRealComplex
►CTVirtualGeoConverter	Abstract class for geometry converters
CTGeoVGConverter	Geometry converter to VecGeom
►CTVirtualGeoPainter	Abstract class for geometry painters
CTGeoPainter	Class implementing all draw interfaces for a generic 3D viewer using TBuffer3D mechanism
CTVirtualGeoTrack	Base class for user-defined tracks attached to a geometry
►CTVirtualGraphPainter	Abstract interface to a histogram painter
CTGraphPainter	The graph painter class
►CTVirtualHistPainter	Abstract interface to a histogram painter
CTGLHistPainter	The histogram painter class using OpenGL
CTHistPainter	The histogram painter class
►CTVirtualMCDecayer	Abstract base class for particle decays
CTPythia6Decayer	This class implements the TVirtualMCDecayer interface
CTPythia8Decayer	This class implements the TVirtualMCDecayer interface using TPythia8
CTVirtualMCStack	Interface to a user defined particles stack
►CTVirtualPacketizer	The packetizer is a load balancing object created for each query
CTPacketizer	This class generates packets to be processed on PROOF worker servers
CTPacketizerAdaptive	This packetizer is based on TPacketizer but uses different load-balancing algorithms and data structures
CTPacketizerFile	This packetizer generates packets which contain a single file path to be used in process
CTPacketizerMulti	This class allows to do multiple runs in the same query; each run can be a, for example, different dataset or the same dataset with entry list
CTPacketizerUnit	This packetizer generates packets of generic units, representing the number of times an operation cycle has to be repeated by the worker node, e.g
CTVirtualPacketizer::TVirtualSlaveStat
CTVirtualPad	TVirtualPad is an abstract base class for the Pad and Canvas classes
►CTVirtualPerfStats	Provides the interface for the PROOF internal performance measurement and event tracing
CTPerfStats	Provides the interface for the PROOF internal performance measurement and event tracing
CTTreePerfStats	TTree I/O performance measurement
►CTVirtualProofPlayer	Abstract interface for the PROOF player
►CTProofPlayer	Internal class steering processing in PROOF
CTProofPlayerLocal
►CTProofPlayerRemote
CTProofPlayerLite	Version of TProofPlayerRemote merges the functionality needed by clients and masters
CTProofPlayerSuperMaster
CTProofPlayerSlave
►CTVirtualTreePlayer	Abstract base class defining the interface for the plugins that implement Draw, Scan, Process, MakeProxy, etc
CTTreePlayer	Implement some of the functionality of the class TTree requiring access to extra libraries (Histogram, display, etc)
►CTVirtualViewer3D	Abstract 3D shapes viewer
CTGLScenePad	Implements VirtualViewer3D interface and fills the base-class visualization structures from pad contents
CTGLViewer	Base GL viewer object - used by both standalone and embedded (in pad) GL
CTViewer3DPad	Provides 3D viewer interface (TVirtualViewer3D) support on a pad
CTVolumePosition
CTXMLAttr	TXMLAttribute is the attribute of an Element
CTXMLDocument	TXMLDocument contains a pointer to an xmlDoc structure, after the parser returns a tree built during the document analysis
CTXMLEngine
CTXMLNode	TXMLNode contains a pointer to xmlNode, which is a node under the DOM tree
►CTXMLParser	TXMLParser is an abstract class which interfaces with Libxml2
CTDOMParser
CTSAXParser	TSAXParser is a subclass of TXMLParser, it is a wraper class to libxml library
CTXMLPlayer
CROOT::Experimental::Internal::TObjectDrawable	Provides v7 drawing facilities for TObject types (TGraph etc)
CROOT::Experimental::Internal::TObjectDrawingOpts	For TObject
►CROOT::Internal::TObjProxy< T >
CROOT::Internal::TStlSimpleProxy< T >
CTOCCToStep	This class contains implementation of writing OpenCascade's geometry shapes to the STEP file reproducing the original ROOT geometry tree
CROOT::Experimental::TDirectory::ToContentType< T >
CMemstat::ToLower_t
CROOT::Detail::RDF::RLoopManager::TOneTimeCallback
CToolBarData_t
CTMVA::Tools	Global auxiliary applications and data treatment routines
CROOT::Internal::TOperatorNewHelper
CROOT::v5::TOperOffset
►CROOT::Experimental::TPadBase	Base class for graphic containers for TDrawable-s
CROOT::Experimental::TCanvas	A window's topmost TPad
CROOT::Experimental::TPad	Graphic container for TDrawable-s
►CROOT::Experimental::Internal::TPadHorizVert	A 2D (horizontal and vertical) combination of TPadLengths
CROOT::Experimental::TPadExtent	An extent / size (horizontal and vertical) in a TPad
CROOT::Experimental::TPadPos	A position (horizontal and vertical) in a TPad
CROOT::Experimental::TPadLength	A coordinate in a TPad
►CROOT::Experimental::Internal::TPadPainter	Abstract interface for object painting on the pad/canvas
CROOT::Experimental::Internal::TVirtualCanvasPainter	Abstract interface for painting a canvas
CROOT::Experimental::Internal::TPadUserAxisBase	Base class for user coordinates (e.g
►CROOT::Experimental::TPadUserAxisBase
CROOT::Experimental::TPadCartesianUserAxis
►CTPaletteEditor	Edit the palette via a GUI
CTASPaletteEditor	This is a GUI window to edit a color palette
CTMySQLStatement::TParamData
CPyROOT::TParameter
CROOT::Internal::TParBranchProcessingRAII
CROOT::Internal::TParTreeProcessingRAII
CTPickerStackGuard
CTPoint
CTStreamerInfo::TPointerCollectionAdapter
►CROOT::Internal::TDS::TPointerHolder	Mother class of TTypedPointerHolder
CROOT::Internal::TDS::TTypedPointerHolder< T >	Class to wrap a pointer and delete the memory associated to it correctly
CTPoints	2-D graphics point (world coordinates)
CROOT::TPoolManager	A manager for the scheduler behind ROOT multithreading operations
CROOT::Internal::TPoolManager
CTPosixThreadCleanUp
►CTPRegexp
CTPMERegexp	Wrapper for PCRE library (Perl Compatible Regular Expressions)
CROOT::RDF::TProfile1DModel	A struct which stores the parameters of a TProfile
CROOT::RDF::TProfile2DModel	A struct which stores the parameters of a TProfile2D
CTProfileHelper
CTProofDebug
CTProofLockPathGuard
CTProofMergePrg
CTProofProgressDialog
CTProofServLogHandlerGuard
CTProtoClass::TProtoRealData
CTVirtualCollectionProxy::TPushPop
CTPwdCtx
CTPyArg
CPyROOT::TPyBufferFactory	Factory for python buffers of non-string type
CTPyReturn
CTPythia6::TPythia6Cleaner	Utility class to manage the TPythia6 instance
CTPython
►CTQObject	This is the ROOT implementation of the Qt object communication mechanism (see also http://www.troll.no/qt/metaobjects.html)
CTApplication	This class creates the ROOT Application Environment that interfaces to the windowing system eventloop and eventhandlers
CTBonjourBrowser
CTBonjourRegistrar
CTBonjourResolver
CTDrawFeedback	Utility class to draw objects in the feedback list during queries
CTEveDigitSet	Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox)
CTEveParamList	Collection of named parameters
CTEvePointSet	TEvePointSet 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)
CTEveRGBAPalette	A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes
CTEveSelection	Make sure there is a SINGLE running TEveSelection for each selection type (select/highlight)
CTEveStraightLineSet	Set of straight lines with optional markers along the lines
CTEveWindowManager	Manager for EVE windows
CTGClient
CTGEventHandler
CTGFrame
CTGLOverlayButton	GL-overlay button
CTGLViewer	Base GL viewer object - used by both standalone and embedded (in pad) GL
CTGTableFrame
CTMessageHandler	Handle messages that might be generated by the system
CTMonitor
CTProof	This class controls a Parallel ROOT Facility, PROOF, cluster
CTProofLog	Implementation of the PROOF session log handler
CTQClass
CTQCommand	The Command design pattern is based on the idea, that all editing in an application is done by creating instances of command objects
CTQConnection	TQConnection class is an internal class, used in the object communication mechanism
CTQObjSender
CTStatsFeedback	Utility class to display PROOF stats feedback histos during queries
CTSysEvtHandler	Abstract base class for handling system events
CTVirtualPad	TVirtualPad is an abstract base class for the Pad and Canvas classes
CTVirtualProofPlayer	Abstract interface for the PROOF player
CTXMLParser	TXMLParser is an abstract class which interfaces with Libxml2
►CROOT::Math::TRandomEngine
CROOT::Math::LCGEngine
CROOT::Math::MersenneTwisterEngine	Random number generator class based on M
CROOT::Math::MixMaxEngine< N, SkipNumber >	MixMaxEngine is a wrapper class for the MIXMAX Random number generator
CTRandom	This is the base class for the ROOT Random number generators
CTRandomEngine
CTRangeDynCast< T >	TRangeDynCast is an adaptater class that allows the typed iteration through a TCollection
CROOT::Detail::TRangeStaticCast< T >	TRangeStaticCast is an adaptater class that allows the typed iteration through a TCollection
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::TransformationHandler	Class 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::Internal::RDF::TRDFValueTuple< T >
CROOT::Internal::RDF::TRDFValueTuple< TypeList< BranchTypes... > >
CROOT::Internal::RDF::TReaderValueOrArray< T >	Choose between TTreeReader{Array,Value} depending on whether the branch type T is a RVec<T> or any other type (respectively)
CROOT::Internal::RDF::TReaderValueOrArray< RVec< T > >
CROOT::TReadLockGuard
►CTRecorderState
CTRecorderInactive
CTRecorderPaused
CTRecorderRecording
CTRecorderReplaying
CTRedirectOutputGuard
CTEveManager::TRedrawDisabler
CROOT::TReentrantRWLock< MutexT, RecurseCountsT >
►CTRefCnt	Definitions for TRefCnt, base class for reference counted objects
CTGFont
CTGGC
CTGLayoutHints
CTGPicture
CTMVA::DNN::TReference< AReal >	The reference architecture class
CTBits::TReference
CTRegexp	Regular expression class
CROOT::Math::Delaunay2D::Triangle
Ctriangulateio
CTRootIOCtor
CTRootSnifferScanRec
CTRotation::TRotationRow
CTRSA_fun
►Ctrue_type
Cnlohmann::detail::conjunction<... >
CROOT::TypeTraits::IsSmartOrDumbPtr< std::shared_ptr< P > >
CROOT::TypeTraits::IsSmartOrDumbPtr< std::unique_ptr< P > >
CROOT::TRWSpinLock
CROOT::TRWSpinLockReadGuard
CROOT::TRWSpinLockWriteGuard
CROOT::Internal::TSchemaHelper
CROOT::Internal::TSchemaRuleProcessor
CROOT::Internal::TSchemaType
CROOT::TSeq< T >	A pseudo container class which is a generator of indices
CTMVA::DNN::TSharedLayer< Architecture_t >	Layer class width shared weight and bias layers
CTSimpleAnalysis	A TSimpleAnalysis object creates histograms from a TChain
CRgl::Mc::TSlice< V >
CRgl::Mc::TSlice< ElementType_t >
CROOT::Internal::RDF::TSlotStack
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::TSpinLockGuard	A spin mutex-as-code-guard class
CROOT::TSpinMutex	A 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::TStaging	Small helper to stage the content of an associative container when reading and before inserting it in the actual collection
CROOT::Detail::TStatusBitsChecker
CROOT::Internal::TStdBitsetHelper< T >
CROOT::Internal::TStlObjProxy< T >
CTStorage	Storage manager
►CTString	Basic string class
CTEveException	Exception class thrown by TEve classes and macros
►CTGString
CTGHotString
CTStringLong	ATTENTION: this class is obsolete
CTStringToken	Provides iteration through tokens of a given string
CROOT::Internal::TStringView
CTSubString	A zero length substring is legal
CTTabCom
CTTablePadView3D
CTTableRange
CROOT::Experimental::TTaskGroup	A 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 > >
CTTF	Interface to the freetype 2 library
CTTF::TTGlyph	TTF 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 >
CTTime	Basic time type with millisecond precision
CTTimeStamp	The TTimeStamp encapsulates seconds and ns since EPOCH
CTMVA::MethodDNN::TTrainingSettings
CTMVA::TTrainingSettings	All of the options that can be specified in the training string
CTTreeCloner	Class implementing or helping the various TTree cloning method
►CROOT::Internal::TTreeGeneratorBase
CROOT::Internal::TTreeProxyGenerator
CROOT::Internal::TTreeReaderGenerator
CROOT::TTreeProcessorMT	A class to process the entries of a TTree in parallel
►CROOT::Internal::TTreeReaderValueBase
►CROOT::Internal::TTreeReaderArrayBase
CTTreeReaderArray< T >	Extracts array data from a TTree
CTTreeReaderArray< Float_t >
CTTreeReaderArray< Int_t >
CTTreeReaderValue< T >	Extracts data from a TTree
CTTreeReaderValue< Float_t >
CTTreeReaderValue< Int_t >
CTTreeView	A helper class that encapsulates a file and a tree
CROOT::Internal::TTreeView
CROOT::Experimental::Internal::TUniWeakPtr< T >
CROOT::Experimental::Internal::TUniWeakPtr< ROOT::Experimental::Detail::THistImplPrecisionAgnosticBase >
CTGLLockable::TUnlocker
CTUnuran	TUnuran class
►CTUnuranBaseDist	TUnuranBaseDist, base class for Unuran distribution classees such as TUnuranContDist (for one-dimension) or TUnuranMultiContDist (multi-dimension)
CTUnuranContDist	TUnuranContDist class describing one dimensional continuous distribution
CTUnuranDiscrDist	TUnuranDiscrDist class for one dimensional discrete distribution
CTUnuranEmpDist	TUnuranEmpDist class for describing empiral distributions
CTUnuranMultiContDist	TUnuranMultiContDist class describing multi dimensional continuous distributions
CTUUID	This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDentifier)
CTVersionCheck
CTVirtualArray	Wrapper 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
CTRootAuth
CTVirtualCollectionIterators	Small helper class to generically acquire and release iterators
►CTVirtualCollectionProxy
►CTGenCollectionProxy	Proxy around an arbitrary container, which implements basic functionality and iteration
CAnyCollectionProxy< T >
►CTEmulatedCollectionProxy	Streamer around an arbitrary STL like container, which implements basic container functionality
CTEmulatedMapProxy	Streamer around a map container
►CTGenCollectionStreamer
CAnyCollectionStreamer< T >
CTVirtualCollectionPtrIterators
CROOT::Internal::TVirtualCollectionReader
►CTVirtualDragManager
CTGuiBldDragManager
►CTVirtualGLManip
►CTGLManip	Abstract base class for viewer manipulators, which allow direct in viewer manipulation of a (TGlPhysicalShape) object - currently translation, scaling and rotation along/round objects local axes
CTGLRotateManip	Rotate manipulator - attaches to physical shape and draws local axes widgets - rings drawn from attached physical center, in plane defined by axis
CTGLScaleManip	Scale manipulator - attaches to physical shape and draws local axes widgets with box heads
CTGLTransManip	Translation manipulator - attaches to physical shape and draws local axes widgets with arrow heads
►CTVirtualGLPainter
►CTGLPlotPainter	Base class for plot-painters that provide GL rendering of various 2D and 3D histograms, functions and parametric surfaces
CTGL5DPainter	TGL5DPainter implements "gl5d" option for TTree::Draw
CTGLBoxPainter	Paints TH3 histograms by rendering variable-sized boxes matching the bin contents
CTGLH2PolyPainter	Paint TH2Poly
CTGLIsoPainter	"gliso" option for TH3
CTGLLegoPainter	Plot-painter implementing LEGO rendering of TH2 histograms in cartesian, polar, cylindrical and spherical coordinates
CTGLParametricPlot
CTGLSurfacePainter	Implements painting of TH2 with "SURF" option
CTGLTF3Painter	Plot-painter for TF3 functions
CTGLTH3CompositionPainter
CTGLVoxelPainter	Paint TH3 histograms as "voxels" - colored boxes, transparent if transfer function was specified
►CTVirtualIsAProxy
CTInstrumentedIsAProxy< T >
CTIsAProxy	TIsAProxy implementation class
►CTVirtualMutex	This class implements a mutex interface
►CROOT::TVirtualRWMutex
CROOT::TRWMutexImp< MutexT, RecurseCountsT >
CTMutex
CTVirtualObject	Wrapper around an object and giving indirect access to its content even if the object is not of a class in the Cint/Reflex dictionary
►CTVirtualPadEditor	Abstract base class used by ROOT graphics editor
CTGedEditor
►CTVirtualPadPainter	To make it possible to use GL for 2D graphic in a TPad/TCanvas
CTGLPadPainter	"Delegating" part of TGLPadPainter
CTPadPainter	Implement TVirtualPadPainter which abstracts painting operations
►CTVirtualRefProxy
►CTRefProxy
CTRefArrayProxy	A container proxy, which allows to access references stored in a TRefArray from TTree::Draw
►CTVirtualTableInterface
CTGSimpleTableInterface
CTTreeTableInterface	TTreeTableInterface is used to interface to data that is stored in a TTree
CTVirtualVectorIterators
CTWin32SplashThread
CTWin32ThreadCleanUp
CROOT::TWriteLockGuard
►CTXHandler	Handler of asynchronous events for XProofD sockets
CTXProofMgr	Implementation of the functionality provided by TProofMgr in the case of a xproofd-based session
CTXProofServ	This class implements the XProofD version of TProofServ, with respect to which it differs only for the underlying connection technology
CTXSlave	This is the version of TSlave for workers servers based on XProofD
►CTXMLSetup
CTBufferXML	Class for serializing/deserializing object to/from xml
CTXMLFile
CTXNetSystemConnectGuard
CTXSemaphoreGuard
CTXSockBuf
CTXSockPipe
►Ctype
Cnlohmann::detail::conjunction< B1, Bn... >
►CType_t
CRgl::Mc::TMeshBuilder< DataSource, ValueType >
CRgl::Mc::TMeshBuilder< TKDEFGT, Float_t >
►CType_t
CRgl::Mc::TMeshBuilder< DataSource, ValueType >
CRgl::Mc::TMeshBuilder< TKDEFGT, Float_t >
CROOT::TypeTraits::TypeList< Types >	Lightweight storage for a collection of types
CTMVA::Types	Singleton class for Global types used by TMVA
CROOT::TypeTraits
►Cunary_function
Chash< std::experimental::basic_string_view< _CharT, _Traits > >
CTMVA::compose_unary_t< F, G >
CROOT::Math::UnaryOp< Operator, RHS, T >	UnaryOperation class A class representing unary operators in the parse tree
CRooRandomizeParamMCSModule::UniParam
CRooRandomizeParamMCSModule::UniParamSet
CROOT::Internal::UniqueLockRecurseCount
CUnuranDistr< Function >	UnuranDistr Provides free function based on TF1 to be called by unuran
CUnuranDistrMulti< Function >	Free functions for multidimensional functions needed bby UNURAN
CUnuranRng< Random >	UnuranRng class for interface ROOT random generators to Unuran
CTTreeCacheUnzip::UnzipState
CUserGroup_t
CTString::UStr_t
CTUUID::uuid_time_t
CPyROOT::TParameter::Value
CROOT::Internal::TCheckHashRecursiveRemoveConsistency::Value
CTGenCollectionProxy::Value	Small helper to describe the Value_type or the key_type of an STL container
CTMVA::VariableImportanceResult
CROOT::Minuit2::VariableMetricEDMEstimator
CTMVA::Config::VariablePlotting
CTMVA::TransformationHandler::VariableStat
CTMVA::MethodCFMlpANN_Utils::VARn2
CTMVA::VarTransformHandler
►CROOT::Math::Vavilov	Base class describing a Vavilov distribution
CROOT::Math::VavilovAccurate	Class describing a Vavilov distribution
CROOT::Math::VavilovFast	Class describing a Vavilov distribution
CROOT::Minuit2::vec
CROOT::Math::VecExpr< ExprType, T, D >	Expression wrapper class for Vector objects
►Cstd::vector< T >	STL class
CROOT::Detail::TSchemaRuleSet::TMatches
CTGL2DArray< T >
CTGL2DArray< Double_t >
CTGL2DArray< std::pair< TGLVector3, TGLVector3 > >
CTGL2DArray< TGLParametricPlot::Vertex_t >
CTGL2DArray< TGLVector3 >
CTGL2DArray< TGLVertex3 >
CTTableMap
CVecTVecDouble
CVecVecDouble
CROOT::Math::VectorMatrixColOp< Vector, Matrix, D1 >	Class for Vector-Matrix multiplication
CROOT::Math::VectorMatrixRowOp< Matrix, Vector, D2 >
CROOT::Minuit2::VectorOuterProduct< M, T >
CROOT::Math::VegasParameters	Structures collecting parameters for VEGAS multidimensional integration FOr implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h
CTGLParametricPlot::Vertex_t
►CTMVA::DNN::VGeneralLayer< Architecture_t >	Generic General Layer class
CTMVA::DNN::CNN::TConvLayer< Architecture_t >
CTMVA::DNN::CNN::TMaxPoolLayer< Architecture_t >	Generic Max Pooling Layer class
CTMVA::DNN::RNN::TBasicRNNLayer< Architecture_t >
CTMVA::DNN::TDenseLayer< Architecture_t >	Generic layer class
CTMVA::DNN::TReshapeLayer< Architecture_t >
►CROOT::Math::VirtualIntegrator	Abstract 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
►CROOT::Math::VirtualIntegratorMultiDim	Interface (abstract) class for multi numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLMCIntegrator
CROOT::Math::AdaptiveIntegratorMultiDim	Class for adaptive quadrature integration in multi-dimensions using rectangular regions
CROOT::Math::GSLMCIntegrator
►CROOT::Math::VirtualIntegratorOneDim	Interface (abstract) class for 1D numerical integration It must be implemented by the concrate Integrator classes like ROOT::Math::GSLIntegrator
►CROOT::Math::GaussIntegrator	User class for performing function integration
CROOT::Math::GaussLegendreIntegrator	User class for performing function integration
CROOT::Math::GSLIntegrator	Class for performing numerical integration of a function in one dimension
CTMVA::Volume	Volume for BinarySearchTree
CROOT::MacOSX::X11::CommandBuffer::WidgetRect
CWindowAttributes_t
►C<X11Drawable>
CQuartzImage
CQuartzPixmap
C<X11Window >
►C<X11Window>
CQuartzView
CQuartzWindow
CXColor_t	Description of a X11 color
CXHandleErr_t
CXHandleIn_t
CROOT::MacOSX::X11::XLFDName
CXPClientArchiveRequest
CXPClientInterruptRequest
CXPClientLoginRequest
CXPClientProofRequest
CXPClientReadbufRequest
CXPClientRequest
CXPClientSendRcvRequest
CXpdAdminCpCmd
CXpdClientSessions
CXpdEnv
CXpdGroupEff_t
CXpdGroupGlobal_t
CXpdManagerCron_t
CXpdMsg
CXpdObject
CXpdSrvMgrCreateCnt
CXpdSrvMgrCreateGuard
►CXrdClientAbsUnsolMsgHandler
CTXSocket	High level handler of connections to XProofD
CXrdClientConnectionMgr
CXrdClientLogConnection
►CXrdProofConn
CXrdProofPhyConn
CXrdClientCacheInterval
CXrdClientConn
CXrdClientEnv
CXrdClientID
CXrdClientInputBuffer
CXrdClientMessage
CXrdClientPhyConnLocker
CXrdClientReadCache
CXrdClientReadCacheItem
CXrdClientSock
CXrdClientSockConnectParms
►CXrdClientUnsolMsgSender
CXrdClientConnectionMgr
CXrdClientLogConnection
CXrdClientPhyConnection
CXrdClientUrlInfo
CXrdClientVector< T >
CXrdClientVector< ClientRequest >
CXrdClientVector< XrdClientLogConnection *>
CXrdClientVector< XrdClientMessage *>
CXrdClientVector< XrdClientPhyConnection *>
CXrdClientVector< XrdClientReadCacheItem * >
►CXrdJob
CXpdObjectQ
CXrdPoll
CXrdProofdAux
CXrdProofdClient
►CXrdProofdConfig
CXrdProofdAdmin
CXrdProofdClientMgr
CXrdProofdManager
CXrdProofdNetMgr
CXrdProofdPriorityMgr
CXrdProofdProofServMgr
CXrdProofSched
CXrdROOTMgr
CXrdProofdDirective
CXrdProofdDSInfo
CXrdProofdFile
CXrdProofdMultiStr
CXrdProofdMultiStrToken
CXrdProofdPInfo
CXrdProofdPipe
CXrdProofdPriority
CXrdProofdProofServ
CXrdProofdResponse
CXrdProofdSandbox
CXrdProofdSessionEntry
CXrdProofGI
CXrdProofGroup
CXrdProofGroupMember
CXrdProofGroupMgr
CXrdProofQuery
CXrdProofSessionInfo
CXrdProofUI
CXrdProofWorker
►CXrdProtocol
CXrdProofdProtocol
CXrdROOT
CXrdSrvBuffer
CXrdSysPriv
CXrdSysPrivGuard
CXShapeEvent
CTGDMLWrite::Xyz
►CBASES
CROOT::Experimental::Detail::THistBinStat< DATA, BASES >	Const view on a bin's statistical data
►CFunctionType
CROOT::Math::BasicFitMethodFunction< FunctionType >	FitMethodFunction class Interface for objective functions (like chi2 and likelihood used in the fit) In addition to normal function interface provide interface for calculating each data contrinution to the function which is required by some algorithm (like Fumili)
►CIPFType
CROOT::Math::ParamFunction< IPFType >	Base template class for all Parametric Functions