  ROOT::Math::CholeskyDecompHelpers::_decomposer< F, N, M > | Struct to do a Cholesky decomposition |
| ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 0, M > | Struct to do a Cholesky decomposition (specialized, N = 0) |
| ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 1, M > | Struct to do a Cholesky decomposition (specialized, N = 1) |
| ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 2, M > | Struct to do a Cholesky decomposition (specialized, N = 2) |
| ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 3, M > | Struct to do a Cholesky decomposition (specialized, N = 3) |
| ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 4, M > | Struct to do a Cholesky decomposition (specialized, N = 4) |
| ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 5, M > | Struct to do a Cholesky decomposition (specialized, N = 5) |
| ROOT::Math::CholeskyDecompHelpers::_decomposer< F, 6, M > | Struct to do a Cholesky decomposition (specialized, N = 6) |
| ROOT::Math::CholeskyDecompHelpers::_decomposerGenDim< F, M > | Struct to do a Cholesky decomposition (general dimensionality) |
| ROOT::Math::CholeskyDecompHelpers::_inverter< F, N, M > | Struct to obtain the inverse from a Cholesky decomposition |
| ROOT::Math::CholeskyDecompHelpers::_inverter< F, 0, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 0) |
| ROOT::Math::CholeskyDecompHelpers::_inverter< F, 1, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 1) |
| ROOT::Math::CholeskyDecompHelpers::_inverter< F, 2, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 2) |
| ROOT::Math::CholeskyDecompHelpers::_inverter< F, 3, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 3) |
| ROOT::Math::CholeskyDecompHelpers::_inverter< F, 4, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 4) |
| ROOT::Math::CholeskyDecompHelpers::_inverter< F, 5, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 5) |
| ROOT::Math::CholeskyDecompHelpers::_inverter< F, 6, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 6) |
| ROOT::Math::CholeskyDecompHelpers::_inverterGenDim< F, M > | Struct to obtain the inverse from a Cholesky decomposition (general dimensionality) |
| ROOT::Vc::_MemorySizeCalculation< V, Size > | |
| _root_std_complex< T > | |
| ROOT::Math::CholeskyDecompHelpers::_solver< F, N, V > | Struct to solve a linear system using its Cholesky decomposition |
| ROOT::Math::CholeskyDecompHelpers::_solver< F, 0, V > | Struct to solve a linear system using its Cholesky decomposition (N=0) |
| ROOT::Math::CholeskyDecompHelpers::_solver< F, 1, V > | Struct to solve a linear system using its Cholesky decomposition (N=1) |
| ROOT::Math::CholeskyDecompHelpers::_solver< F, 2, V > | Struct to solve a linear system using its Cholesky decomposition (N=2) |
| ROOT::Math::CholeskyDecompHelpers::_solver< F, 3, V > | Struct to solve a linear system using its Cholesky decomposition (N=3) |
| ROOT::Math::CholeskyDecompHelpers::_solver< F, 4, V > | Struct to solve a linear system using its Cholesky decomposition (N=4) |
| ROOT::Math::CholeskyDecompHelpers::_solver< F, 5, V > | Struct to solve a linear system using its Cholesky decomposition (N=5) |
| ROOT::Math::CholeskyDecompHelpers::_solver< F, 6, V > | Struct to solve a linear system using its Cholesky decomposition (N=6) |
| ROOT::Math::CholeskyDecompHelpers::_solverGenDim< F, V > | Struct to solve a linear system using its Cholesky decomposition (generalised dimensionality) |
| _Ulp_ExponentVector< T > | |
| _Ulp_ExponentVector< Vc::sfloat_v > | |
| _UnitTest_Compare | |
| _UnitTest_Failure | |
| _UnitTest_Global_Object | |
| _x3d_data_ | |
| _x3d_sizeof_ | |
| ROOT::Minuit2::ABObj< mtype, M, T > | |
| ROOT::Minuit2::ABObj< sym, LASymMatrix, double > | |
| ROOT::Minuit2::ABObj< vec, LAVector, double > | |
| ROOT::Minuit2::ABProd< M1, M2 > | |
| ROOT::Minuit2::ABSum< M1, M2 > | |
| TMVA::AbsValue | |
| ADD_PASS | |
| ROOT::Math::AddOp< T > | Addition Operation Class |
| ROOT::Math::AddPolicy< T, D1, D2, R1, R2 > | Matrix addition policy |
| ROOT::Math::AddPolicy< T, D1, D2, MatRepSym< T, D1 >, MatRepSym< T, D1 > > | |
| ROOT::Detail::TCollectionProxyInfo::Address< T > | |
 ROOT::Detail::TCollectionProxyInfo::Address< const Bool_t & > | |
  ROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > > | |
  ROOT::Detail::TCollectionProxyInfo::Pushback< Internal::TStdBitsetHelper< Bitset_t > > | |
| ROOT::Detail::TCollectionProxyInfo::Address< std::vector< Bool_t >::const_reference > | |
| ROOT::Detail::TCollectionProxyInfo::Type< std::vector< Bool_t > > | |
| ROOT::Detail::TCollectionProxyInfo::Pushback< std::vector< bool > > | |
| ROOT::Detail::TCollectionProxyInfo::Address< TYPENAME T::const_reference > | |
| ROOT::Detail::TCollectionProxyInfo::Type< T > | |
| ROOT::Detail::TCollectionProxyInfo::Insert< T > | |
| ROOT::Detail::TCollectionProxyInfo::MapInsert< T > | |
| ROOT::Detail::TCollectionProxyInfo::Pushback< T > | |
| ROOT::Detail::TCollectionProxyInfo::Pushfront< T > | |
| ROOT::Minuit2::AlgebraicProdType< A, B > | |
| ROOT::Minuit2::AlgebraicProdType< gen, gen > | |
| ROOT::Minuit2::AlgebraicProdType< gen, sym > | |
| ROOT::Minuit2::AlgebraicProdType< gen, vec > | |
| ROOT::Minuit2::AlgebraicProdType< sym, gen > | |
| ROOT::Minuit2::AlgebraicProdType< sym, sym > | |
| ROOT::Minuit2::AlgebraicProdType< sym, vec > | |
| ROOT::Minuit2::AlgebraicProdType< T, T > | |
| ROOT::Minuit2::AlgebraicProdType< vec, gen > | |
| ROOT::Minuit2::AlgebraicProdType< vec, sym > | |
| ROOT::Minuit2::AlgebraicSumType< A, B > | |
| ROOT::Minuit2::AlgebraicSumType< gen, vec > | |
| ROOT::Minuit2::AlgebraicSumType< sym, vec > | |
| ROOT::Minuit2::AlgebraicSumType< T, T > | |
| ROOT::Minuit2::AlgebraicSumType< vec, gen > | |
| ROOT::Minuit2::AlgebraicSumType< vec, sym > | |
| ROOT::Vc::Common::AliasingEntryHelper< StorageType > | |
| RooAbsCachedPdf::AnaIntConfig | Registry for analytical integration codes |
| RooMultiVarGaussian::AnaIntData | |
| RScanner::AnnotatedNamespaceDecl | |
| ROOT::TMetaUtils::AnnotatedRecordDecl | |
| RooStats::HistFactory::Asimov | |
| ROOT::Math::Assign< T, D1, D2, A, R1, R2 > | Structure to assign from an expression based to general matrix to general matrix |
| ROOT::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 |
| ROOT::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 |
| ROOT::Math::AssignItr< T, D1, D2, R > | Structure for assignment to a general matrix from iterator |
| ROOT::Math::AssignItr< T, D1, D2, MatRepSym< T, D1 > > | Specialized structure for assignment to a symmetrix matrix from iterator |
| ROOT::Math::AssignSym | Force Expression evaluation from general to symmetric |
| TExMap::Assoc_t | |
| XMLReader::Attributes | |
| ROOT::MacOSX::Util::AutoreleasePool | |
| ROOT::Math::AxisAngle | AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis |
| Baker | |
| BalancerInfo | |
| RooStats::HistFactory::RooBarlowBeestonLL::BarlowCache | |
| ROOT::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 |
| ROOT::Math::IntegratorMultiDimOptions | Numerical multi dimensional integration options |
| ROOT::Math::IntegratorOneDimOptions | Numerical one dimensional integration options |
| ROOT::Math::KDTree< _DataPoint >::BaseNode | |
| ROOT::Math::KDTree< _DataPoint >::BinNode | |
| ROOT::Math::KDTree< _DataPoint >::TerminalNode | |
| ROOT::Math::KDTree< _DataPoint >::HeadNode | |
| ROOT::Math::KDTree< _DataPoint >::SplitNode | |
| BaseSelectionRule | |
| ClassSelectionRule | |
| VariableSelectionRule | |
| basic_string_view< _CharT, _Traits > | |
| ROOT::Minuit2::BasicFunctionGradient | |
| ROOT::Minuit2::BasicFunctionMinimum | Result of the minimization; both internal and external (MnUserParameterState) representation available For the parameters at the Minimum |
| ROOT::Minuit2::BasicMinimumError | Internal Class containing the error information on the estimated minimum : Error matrix + dcovar + additional flags for quality and validity checks |
| ROOT::Minuit2::BasicMinimumParameters | |
| ROOT::Minuit2::BasicMinimumSeed | |
| ROOT::Minuit2::BasicMinimumState | |
| TMVA::BDTEventWrapper | |
| RooStats::BernsteinCorrection | BernsteinCorrection is a utility in RooStats to augment a nominal PDF with a polynomial correction term |
| BidirMMapPipe | BidirMMapPipe creates a bidirectional channel between the current process and a child it forks |
| binary_function | |
| Memstat::SFind_t | |
| TMVA::compose_binary_t< F, G, H > | |
| ROOT::Math::BinaryOp< Operator, LHS, RHS, T > | BinaryOperation class A class representing binary operators in the parse tree |
| ROOT::Math::BinaryOpCopyL< Operator, LHS, RHS, T > | Binary Operation class with value storage for the left argument |
| ROOT::Math::BinaryOpCopyR< Operator, LHS, RHS, T > | Binary Operation class with value storage for the right argument |
| BinaryOpPolicy | |
| TMVA::BinaryTree | |
| TMVA::BinarySearchTree | |
| TMVA::DecisionTree | |
| ROOT::R::TRDataFrame::Binding | |
| ROOT::R::TRInterface::Binding | |
| BinomialNeymanInterval< Sorter > | |
| BinomialNeymanInterval< FeldmanCousinsSorter > | |
| FeldmanCousinsBinomialInterval | |
| BinomialProbHelper | |
| ROOT::Fit::BinPoint | Obsolete class, no more in use |
| RooMultiVarGaussian::BitBlock | |
| ROOT::Math::GenVector_detail::BitReproducible | |
| TEveParamList::BoolConfig_t | |
| ROOT::Math::Boost | Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix |
| ROOT::Math::BoostX | Class representing a Lorentz Boost along the X axis, by beta |
| ROOT::Math::BoostY | Class representing a Lorentz Boost along the Y axis, by beta |
| ROOT::Math::BoostZ | Class representing a Lorentz Boost along the Z axis, by beta |
| Rgl::Pad::BoundingRect< ValueType > | |
| RooNDKeysPdf::BoxInfo | |
| TGeoBatemanSol::BtCoef_t | |
| RooSimWSTool::BuildConfig | |
| RooSimWSTool::MultiBuildConfig | |
| ROOT::Vc::SSE::c_general | |
| ROOT::Vc::AVX::c_log< T > | |
| ROOT::Vc::SSE::c_log< T > | |
| ROOT::Vc::AVX::c_log< double > | |
| ROOT::Vc::SSE::c_log< double > | |
| ROOT::Vc::AVX::c_trig< T > | |
| ROOT::Vc::SSE::c_trig< T > | |
| TInterpreter::CallFuncIFacePtr_t | |
| CanvasDrawerCore | |
| JupyROOT.kernel.draw.CanvasDrawer | |
| ROOT::Math::Cartesian2D< T > | Class describing a 2D cartesian coordinate system (x, y coordinates) |
| ROOT::Math::Cartesian3D< T > | Class describing a 3D cartesian coordinate system (x, y, z coordinates) |
| ROOT::Math::Cartesian3D< double > | |
| ROOT::Math::Cartesian3D< Double32_t > | |
| ROOT::Math::Cartesian3D< Scalar > | |
| RooVectorDataStore::CatVector | |
| TMVA::CCPruner | |
| TMVA::CCTreeWrapper | |
| TFITSHDU::Cell | |
| TEveCaloLegoGL::Cell2D_t | |
| TEveCaloData::CellGeom_t | Cell geometry inner structure |
| TEveCaloData::CellData_t | Cell data inner structure |
| TEveCaloData::CellId_t | |
| ROOT::MacOSX::Util::CFScopeGuard< RefType > | |
| ROOT::MacOSX::Util::CFScopeGuard< CGContextRef > | |
| ROOT::MacOSX::Util::CFScopeGuard< CGImageRef > | |
| ROOT::MacOSX::Util::CFStrongReference< RefType > | |
| ROOT::Quartz::CGAAStateGuard | |
| ROOT::Quartz::CGStateGuard | |
| RooStats::HistFactory::Channel | |
| TCling::CharPtrCmp_t | |
| ROOT::Math::ChebyshevApprox | Class describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials |
| ROOT::Math::ChebyshevPol | |
| ROOT::Math::CholeskyDecomp< F, N > | Class to compute the Cholesky decomposition of a matrix |
| ROOT::Math::CholeskyDecompGenDim< F > | Class to compute the Cholesky decomposition of a matrix |
| ROOT::Math::CholInverter< idim > | |
| class_ | |
| ROOT::R::class_< T > | |
| ROOT::Meta::Selection::ClassAttributes< classAttributes > | Used to specify attributes of classes in the "DictSelection" syntax |
| RooWorkspace::CodeRepo::ClassFiles | |
| TMVA::ClassifierFactory | |
| TMVA::ClassInfo | |
| RooWorkspace::CodeRepo::ClassRelInfo | |
| ClusterD | |
| XrdClientConnectionMgr::CndVarInfo | |
| ROOT::MacOSX::Details::CocoaPrivate | |
| ROOT::MacOSX::X11::ColorParser | |
| ColorStruct_t | |
| TFITSHDU::Column | |
| ROOT::MacOSX::X11::Command | |
| CompareAsc< T > | |
| compareBAasc | |
| compareBAdesc | |
| ROOT::TMetaUtils::AnnotatedRecordDecl::CompareByName | |
| CompareDesc< T > | |
| TTreeCloner::CompareEntry | |
| ROOT::Math::KDTree< _DataPoint >::ComparePoints | |
| TTreeCloner::CompareSeek | |
| ROOT::Math::CompileTimeChecker< bool > | |
| ROOT::Math::CompileTimeChecker< false > | |
| Completer | |
| ROOT.RootNameCompleter | |
| TMVA::Config | |
| RooStats::HistFactory::ConfigParser | |
| ROOT::Vc::AVX::Const< _T > | |
| ROOT::Vc::SSE::Const< _T > | |
| ROOT::Math::Constant< T > | Constant expression class A class representing constant expressions (literals) in the parse tree |
| ContDist | Free functions adapter needed by UNURAN for onedimensional continuous distributions |
| Context | Small helper to keep current directory context |
| ROOT::Minuit2::ContoursError | |
| TMVA::ConvergenceTest | |
| TMVA::MethodMLP | |
| ROOT::Math::CoordinateTraits< C > | |
| ROOT::Math::CoordinateTraits< Cartesian3D< Scalar > > | |
| ROOT::Math::CoordinateTraits< Cylindrical3D< Scalar > > | |
| ROOT::Math::CoordinateTraits< CylindricalEta3D< Scalar > > | |
| ROOT::Math::CoordinateTraits< Polar3D< Scalar > > | |
| ROOT::Math::CoordinateTraits< PtEtaPhiE4D< Scalar > > | |
| ROOT::Math::CoordinateTraits< PtEtaPhiM4D< Scalar > > | |
| ROOT::Math::CoordinateTraits< PxPyPzE4D< Scalar > > | |
| ROOT::Math::CoordinateTraits< PxPyPzM4D< Scalar > > | |
| ROOT::Vc::Common::Internal::CopyConst< A, B > | |
| ROOT::Vc::Common::Internal::CopyConst< const A, B > | |
| ROOT::Vc::CpuId | This class is available for x86 / AMD64 systems to read and interpret information about the CPU's capabilities |
| CpuInfo_t | |
| ROOT::Minuit2::MnCross::CrossFcnLimit | |
| ROOT::Minuit2::MnCross::CrossNewMin | |
| ROOT::Minuit2::MnCross::CrossParLimit | |
| ROOT::Vc::SSE::CtorTypeHelper< T > | |
| ROOT::Vc::SSE::CtorTypeHelper< float > | |
| ROOT::Vc::SSE::CtorTypeHelper< short > | |
| ROOT::Vc::SSE::CtorTypeHelper< unsigned short > | |
| ROOT::Math::KDTree< _DataPoint >::Cut | |
| ROOT::Math::Cylindrical3D< T > | Class describing a cylindrical coordinate system based on rho, z and phi |
| ROOT::Math::CylindricalEta3D< T > | Class describing a cylindrical coordinate system based on eta (pseudorapidity) instead of z |
| TimeStampCounter::Data | |
| RooStats::HistFactory::Data | |
| TMVA::DataInputHandler | |
| ROOT::Fit::DataOptions | DataOptions : simple structure holding the options on how the data are filled |
| ROOT::Fit::DataRange | Class describing the range in the coordinates it supports multiple range in a coordinate |
| TMVA::DataSet | |
| TMVA::DataSetFactory | |
| TMVA::DataSetManager | |
| ROOT::Fit::DataVector | Class holding the fit data points |
| ROOT::Fit::DataWrapper | Class maintaining a pointer to external data Using this class avoids copying the data when performing a fit NOTE: this class is not thread-safe and should not be used in parallel fits |
| ROOT::Math::GenVector_detail::BitReproducible::DB8 | |
| ROOT::Vc::AVX::DebugStream | |
| ROOT::Vc::SSE::DebugStream | |
| ROOT::Math::DefaultCoordinateSystemTag | DefaultCoordinateSystemTag Default tag for identifying any coordinate system |
| ROOT::Math::Delaunay2D | Class to generate a Delaunay triangulation of a 2D set of points |
| TMVA::DeleteFunctor_t< T > | |
| ROOT::Math::Derivator | Class for computing numerical derivative of a function |
| TKSocket::Desc_t | |
| RooStats::DetailedOutputAggregator | |
| ROOT::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 |
| ROOT::Vc::DetermineEntryType< T > | |
| ROOT::Vc::DetermineEntryType< sfloat > | |
| ROOT::Vc::SSE::DetermineGatherMask< T > | |
| ROOT::Vc::SSE::DetermineGatherMask< Float8Mask > | |
| ROOT::Vc::SSE::DetermineMask< T, Size > | |
| ROOT::Vc::SSE::DetermineMask< sfloat, 8 > | |
| TEveDigitSet::DigitBase_t | |
| TEveBoxSet::BCone_t | |
| TEveBoxSet::BEllipticCone_t | |
| TEveBoxSet::BOrigin_t | |
| TEveBoxSet::BAABox_t | |
| TEveBoxSet::BAABoxFixedDim_t | |
| DigitBase_t | |
| TEveBoxSet::BFreeBox_t | |
| TEveQuadSet::QFreeQuad_t | |
| TEveQuadSet::QOrigin_t | |
| TEveQuadSet::QHex_t | |
| TEveQuadSet::QLineFixC_t | |
| TEveQuadSet::QRectFixDimC_t | |
| TEveQuadSet::QRectFixC_t | |
| TEveQuadSet::QRectFixDim_t | |
| TEveQuadSet::QRect_t | |
| DiscrDist | Free functions adapter needed by UNURAN for one-dimensional discrete distribution |
| ROOT::Math::DisplacementVector2D< CoordSystem, Tag > | Class describing a generic displacement vector in 2 dimensions |
| ROOT::Math::DisplacementVector3D< CoordSystem, Tag > | Class describing a generic displacement vector in 3 dimensions |
| ROOT::Math::DisplacementVector3D< Cartesian3D< double >, DefaultCoordinateSystemTag > | |
| ROOT::Math::DisplacementVector3D< Cartesian3D< Scalar > > | |
| ROOT::Math::DistSampler | Interface class for generic sampling of a distribution, i.e |
| TFoamSampler | TFoamSampler class class implementing the ROOT::Math::DistSampler interface using FOAM for sampling arbitrary distributions |
| TUnuranSampler | TUnuranSampler class class implementing the ROOT::Math::DistSampler interface using the UNU.RAN package for sampling distributions |
| ROOT::Math::DistSamplerOptions | DistSampler options class |
| ROOT::Math::DivOp< T > | Division (element-wise) Operation Class |
| THtml::DocEntityInfo_t | |
| THtml::DocSyntax_t | |
| TGLScene::DrawElement_t | |
| RooPlot::DrawOpt | |
| drr_func_cache | |
| drr_func_entry | |
| TMVA::DTNodeTrainingInfo | |
| DUMMY | |
| ROOT::Fit::DummyDeleter< T > | |
| TEveGeoPolyShape::Edge_t | |
| TEvePolygonSetProjectedGL::Edge_t | |
| TBranchSTL::ElementBranchHelper_t | |
| ROOT::Vc::Common::Internal::EnableInterleaves< S, X, R > | |
| RooMappedCategory::Entry | |
| TCollectionProxyInfo::Environ | Small helper to save proxy environment in the event of recursive calls |
| ROOT::Detail::TCollectionProxyInfo::EnvironBase | |
| ROOT::Detail::TCollectionProxyInfo::Environ< T > | |
| ROOT::Math::gv_detail::ERROR_This_Rotation_Conversion_is_NOT_Supported | |
| ROOT::Math::EulerAngles | EulerAngles class describing rotation as three angles (Euler Angles) |
| RooAbsReal::EvalError | |
| ROOT::Math::EvaluatorOneDim< MultiFuncType > | |
| ROOT::Math::EvaluatorOneDim< const ROOT::Math::IParamMultiFunction & > | |
| TMVA::Event | |
| TMVA::kNN::Event | |
| Event_t | |
| TMVA::QuickMVAProbEstimator::EventInfo | |
| TMVA::DataSetFactory::EventStats | |
| ROOT::MacOSX::X11::EventTranslator | |
| std::exception | STL class |
| PyROOT::TPyException | |
| RooStats::HistFactory::hf_exc | |
| ROOT::Math::GenVector_detail::BitReproducibleException | |
| std::runtime_error | STL class |
| ROOT::Math::GenVector_exception | |
| TEveException | Exception class thrown by TEve classes and macros |
| ExceptionContext_t | |
| ROOT::Vc::SSE::ExpandTypeHelper< T > | |
| ROOT::Vc::SSE::ExpandTypeHelper< float > | |
| ROOT::Vc::SSE::ExpandTypeHelper< short > | |
| ROOT::Vc::SSE::ExpandTypeHelper< unsigned short > | |
| RooExpensiveObjectCache::ExpensiveObject | |
| exponentToDivisor< e, center > | |
| exponentToDivisor< 1, center > | |
| exponentToDivisor< 1024, center > | |
| exponentToDivisor< 128, center > | |
| exponentToDivisor< 256, center > | |
| exponentToDivisor< 384, center > | |
| exponentToDivisor< 512, center > | |
| exponentToDivisor< 640, center > | |
| exponentToDivisor< 768, center > | |
| exponentToDivisor< 896, center > | |
| exponentToDivisor< center, center > | |
| exponentToMultiplier< e, center > | |
| exponentToMultiplier< -1, center > | |
| exponentToMultiplier< -128, center > | |
| exponentToMultiplier< -256, center > | |
| exponentToMultiplier< -384, center > | |
| exponentToMultiplier< -512, center > | |
| exponentToMultiplier< -640, center > | |
| exponentToMultiplier< -768, center > | |
| exponentToMultiplier< -896, center > | |
| exponentToMultiplier< center, center > | |
| exponentToMultiplier<-1024, center > | |
| Rcpp::traits::Exporter< std::array< T, i > > | |
| ROOT::Math::Expr< ExprType, T, D, D2, R1 > | |
| RooWorkspace::CodeRepo::ExtraHeader | |
| ROOT::Math::Fabs< T > | Unary abs Operation Class |
| ROOT::Math::Factory | Factory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager |
| ROOT::Math::FastInverter< idim, n > | Fast Matrix Inverter class Class to specialize calls to Dinv |
| ROOT::Math::FastInverter< 3 > | 3x3 direct matrix inversion using Cramer Rule use only for FastInverter |
| ROOT::Math::FastInverter< 4 > | 4x4 matrix inversion using Cramers rule |
| ROOT::Math::FastInverter< 5 > | 5x5 Matrix inversion using Cramers rule |
| FeldmanCousinsSorter | |
| FileStat_t | |
| Rgl::Pad::FillAttribSet | |
| ROOT::Fit::FitConfig | Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::ParameterSettings class |
| ROOT::Fit::FitData | Base class for all the fit data types |
| ROOT::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: |
| ROOT::Fit::SparseData | |
| ROOT::Fit::UnBinData | Class describing the unbinned data sets (just x coordinates values) of any dimensions |
| ROOT::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 |
| TFitResult | Extends the ROOT::Fit::Result class with a TNamed inheritance providing easy possibility for I/O |
| ROOT::Fit::Fitter | Fitter class, entry point for performing all type of fits |
| ROOT::Vc::Internal::FlagObject< A > | |
| ROOT::Vc::Internal::FlagObject< AlignedFlag > | |
| ROOT::Vc::Internal::FlagObject< StreamingAndAlignedFlag > | |
| ROOT::Vc::Internal::FlagObject< StreamingAndUnalignedFlag > | |
| ROOT::Vc::Internal::FlagObject< UnalignedFlag > | |
| ROOT::Minuit2::FlatRandomGen | |
| float | |
| cppyy._Double | |
| cppyy.double | |
| ROOT::Vc::SSE::Float8GatherMask | |
| ROOT::Vc::SSE::Float8Mask | |
| TEveParamList::FloatConfig_t | |
| FontAttributes_t | |
| ROOT::MacOSX::Details::FontCache | |
| ROOT::MacOSX::Details::FontCache::FontList | |
| FontMetrics_t | |
| TGFontDialog::FontProp_t | |
| Foption_t | |
| ROOT::Vc::AVX::ForeachHelper | |
| ROOT::Vc::Scalar::ForeachHelper | |
| ROOT::Vc::SSE::ForeachHelper | |
| TLatex::FormSize_t | TLatex helper struct holding the dimensions of a piece of text |
| FUMILI2 | |
| FuncCacheElem | |
| RooNumRunningInt::RICacheElem | |
| ROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F > | |
| ROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F * > | |
| ROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *const > | |
| TFitEditor::FuncParamData_t | TF1Convolution object |
| funcptr_and_voidptr_t | |
| ROOT::Minuit2::FunctionGradient | |
| ROOT::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 |
| ROOT::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 |
| ROOT::Minuit2::CombinedMinimizer | Combined minimizer: combination of Migrad and Simplex |
| ROOT::Minuit2::FumiliMinimizer | Instantiates the seed generator and Minimum builder for the Fumili minimization method |
| ROOT::Minuit2::ScanMinimizer | Class implementing the required methods for a minimization using SCAN API is provided in the upper ROOT::Minuit2::ModularFunctionMinimizer class |
| ROOT::Minuit2::SimplexMinimizer | Class implementing the required methods for a minimization using Simplex |
| ROOT::Minuit2::VariableMetricMinimizer | Instantiates the SeedGenerator and MinimumBuilder for Variable Metric Minimization method |
| ROOT::Minuit2::FunctionMinimum | Class holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum |
| FunType | |
| ROOT::Math::BasicFitMethodFunction< FunType > | |
| ROOT::Fit::BasicFCN< FunType, BinData > | |
| ROOT::Fit::Chi2FCN< FunType > | Chi2FCN class for binnned fits using the least square methods |
| ROOT::Fit::PoissonLikelihoodFCN< FunType > | Class evaluating the log likelihood for binned Poisson likelihood fits it is template to distinguish gradient and non-gradient case |
| ROOT::Fit::BasicFCN< FunType, UnBinData > | |
| ROOT::Fit::LogLikelihoodFCN< FunType > | LogLikelihoodFCN class for likelihood fits |
| ROOT::Fit::BasicFCN< FunType, 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 |
| ROOT::Vc::AVX::GatherHelper< T > | |
| RooRandomizeParamMCSModule::GausParam | |
| RooRandomizeParamMCSModule::GausParamSet | |
| ROOT::Minuit2::GaussDataGen | |
| ROOT::Minuit2::GaussFunction | |
| ROOT::Minuit2::GaussRandomGen | |
| GcCache_t | |
| GCValues_t | |
| ROOT::Minuit2::gen | |
| RooMultiVarGaussian::GenData | |
| ROOT::Minuit2::GenericFunction | Class from which all the other classes, representing functions, inherit |
| ROOT::Minuit2::FCNBase | Interface (abstract class) defining the function to be minimized, which has to be implemented by the user |
| ROOT::Minuit2::FCNAdapter< Function > | Template wrapped class for adapting to FCNBase signature |
| ROOT::Minuit2::FCNGradientBase | Extension of the FCNBase for providing the analytical Gradient of the function |
| ROOT::Minuit2::FCNGradAdapter< Function > | Template wrapped class for adapting to FCNBase signature a IGradFunction |
| ROOT::Minuit2::Quad1F | |
| ROOT::Minuit2::Quad4FGrad | |
| ROOT::Minuit2::FumiliFCNBase | Extension of the FCNBase for the Fumili method |
| ROOT::Minuit2::FumiliChi2FCN | Extension of the FCNBase for the Fumili method |
| ROOT::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 |
| ROOT::Minuit2::FumiliFCNAdapter< Function > | Template wrapped class for adapting to FumiliFCNBase signature |
| ROOT::Minuit2::FumiliMaximumLikelihoodFCN | Extension of the FCNBase for the Fumili method |
| ROOT::Minuit2::FumiliStandardMaximumLikelihoodFCN | Class implementing the Elements member function for the standard maximum likelihood method |
| ROOT::Minuit2::GaussFcn | |
| ROOT::Minuit2::GaussFcn2 | |
| ROOT::Minuit2::ParametricFunction | Function which has parameters |
| ROOT::Minuit2::GaussianModelFunction | Sample implementation of a parametric function |
| ROOT::Minuit2::Quad12F | |
| ROOT::Minuit2::Quad4F | |
| ROOT::Minuit2::Quad8F | |
| TMVA::GeneticAlgorithm | |
| TMVA::GeneticGenes | |
| ROOT::Math::GeneticMinimizerParameters | |
| TMVA::GeneticPopulation | |
| TMVA::GeneticRange | |
| RooAbsPdf::GenSpec | |
| TLeaf::GetValueHelper< T > | |
| TFormLeafInfo::GetValueHelper< T > | |
| TLeaf::GetValueHelper< Long64_t > | |
| TFormLeafInfo::GetValueHelper< Long64_t > | |
| TLeaf::GetValueHelper< LongDouble_t > | |
| TFormLeafInfo::GetValueHelper< LongDouble_t > | |
| TLeaf::GetValueHelper< ULong64_t > | |
| TFormLeafInfo::GetValueHelper< ULong64_t > | |
| Rgl::Pad::GLLimits | |
| ROOT::Math::GlobalCoordinateSystemTag | Tag for identifying vectors based on a global coordinate system |
| ROOT::Math::GoFTest | |
| ROOT::Minuit2::GradientCalculator | Interface class for gradient calculators |
| ROOT::Minuit2::AnalyticalGradientCalculator | |
| ROOT::Minuit2::FumiliGradientCalculator | |
| ROOT::Minuit2::HessianGradientCalculator | HessianGradientCalculator: class to calculate Gradient for Hessian |
| ROOT::Minuit2::InitialGradientCalculator | Class to calculate an initial estimate of the gradient |
| ROOT::Minuit2::Numerical2PGradientCalculator | Class performing the numerical gradient calculation |
| group | |
| ROOT::Math::GSL1DMinimizerWrapper | Wrapper class for gsl_min_fminimizer structure |
| GSL_BFGS | |
| GSL_BFGS2 | |
| GSL_FR | |
| GSL_NLS | |
| GSL_PR | |
| ROOT::Math::GSLChebSeries | Wrapper class for C struct gsl_cheb_series |
| ROOT::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 ) |
| ROOT::Math::GSLFunctionAdapter< UserFunc > | Class for adapting any C++ functor class to C function pointers used by GSL |
| ROOT::Math::GSLFunctionDerivWrapper | Class to wrap a gsl_function_fdf (with derivatives) |
| ROOT::Math::GSLFunctionWrapper | Wrapper class to the gsl_function C structure |
| ROOT::Math::GSLIntegrationWorkspace | |
| ROOT::Math::GSLInterpolator | Interpolation class based on GSL interpolation functions |
| ROOT::Math::GSLMCIntegrationWorkspace | |
| ROOT::Math::GSLMiserIntegrationWorkspace | Workspace for MISER |
| ROOT::Math::GSLPlainIntegrationWorkspace | |
| ROOT::Math::GSLVegasIntegrationWorkspace | Workspace for VEGAS |
| ROOT::Math::GSLMonteFunctionAdapter< UserFunc > | |
| ROOT::Math::GSLMonteFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm |
| ROOT::Math::GSLMultiFit | GSLMultiFit, internal class for implementing GSL non linear least square GSL fitting |
| ROOT::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: |
| ROOT::Math::GSLMultiFitFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm |
| ROOT::Math::GSLMultiMinDerivFunctionWrapper | Wrapper for a multi-dimensional function with derivatives used in GSL multidim minimization algorithm |
| ROOT::Math::GSLMultiMinFunctionAdapter< UserFunc > | Class for adapting any multi-dimension C++ functor class to C function pointers used by GSL MultiMin algorithms |
| ROOT::Math::GSLMultiMinFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm |
| ROOT::Math::GSLMultiMinimizer | GSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives |
| ROOT::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) |
| ROOT::Math::GSLMultiRootDerivSolver | GSLMultiRootDerivSolver, internal class for implementing GSL multi-root finders using derivatives |
| ROOT::Math::GSLMultiRootSolver | GSLMultiRootSolver, internal class for implementing GSL multi-root finders not using derivatives |
| ROOT::Math::GSLMultiRootDerivFunctionWrapper | Wrapper to a multi-dim function with derivatives for multi roots algorithm |
| ROOT::Math::GSLMultiRootFinder | Class for Multidimensional root finding algorithms bassed on GSL |
| ROOT::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: |
| ROOT::Math::GSLMultiRootFunctionWrapper | Wrapper to a multi-dim function without derivatives for multi roots algorithm |
| ROOT::Math::GSLQRngWrapper | GSLQRngWrapper class to wrap gsl_qrng structure |
| ROOT::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 |
| ROOT::Math::GSLQRngNiederreiter2 | Niederreiter generator gsl_qrng_niederreiter_2 from here |
| ROOT::Math::GSLQRngSobol | Sobol generator gsl_qrng_sobol from here |
| ROOT::Math::GSLRandomEngine | GSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator |
| ROOT::Math::GSLRngCMRG | Combined multiple recursive generator (L'Ecuyer) see here |
| ROOT::Math::GSLRngGFSR4 | Lagged Fibonacci generator by Ziff see here |
| ROOT::Math::GSLRngMinStd | MINSTD generator (Park and Miller) see here |
| ROOT::Math::GSLRngMRG | 5-th order multiple recursive generator (L'Ecuyer, Blouin and Coutre) see here |
| ROOT::Math::GSLRngMT | Mersenne-Twister generator gsl_rng_mt19937 from here |
| ROOT::Math::GSLRngRand | BSD rand() generator gsl_rmg_rand from here |
| ROOT::Math::GSLRngRanLux | Old Ranlux generator (James, Luscher) (default luxury level, p = 223) (This is eequivalent to TRandom1 with default luxury level) see here |
| ROOT::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 |
| ROOT::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 |
| ROOT::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 |
| ROOT::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 |
| ROOT::Math::GSLRngRanMar | RANMAR generator see here |
| ROOT::Math::GSLRngTaus | Tausworthe generator by L'Ecuyer see here |
| ROOT::Math::GSLRngWrapper | GSLRngWrapper class to wrap gsl_rng structure |
| ROOT::Math::GSLRootFdFSolver | Root-Finder with derivatives implementation class using GSL |
| ROOT::Math::GSLRootFSolver | Root-Finder implementation class using GSL |
| ROOT::Math::GSLSimAnFunc | GSLSimAnFunc class description |
| ROOT::Math::GSLSimAnnealing | GSLSimAnnealing class for performing a simulated annealing search of a multidimensional function |
| ROOT::Math::GSLSimAnParams | Structure holding the simulated annealing parameters |
| RooRandom::Guard | |
| TClingValue::HasTheSameSizeAsClingValue | |
| ROOT::Vc::AVX::HasVectorDivisionHelper< T > | |
| TFITSHDU::HDURecord | |
| TEveTrackPropagator::Helix_t | |
| ROOT::Vc::Internal::HelperImpl< Impl > | |
| ROOT::Vc::Internal::HelperImpl< SSE2Impl > | |
| ROOT::Vc::Internal::HelperImpl< SSE3Impl > | |
| ROOT::Vc::Internal::HelperImpl< SSSE3Impl > | |
| ROOT::Vc::Internal::HelperImpl< SSE41Impl > | |
| ROOT::Vc::Internal::HelperImpl< SSE42Impl > | |
| ROOT::Vc::Internal::HelperImpl< Vc::AVXImpl > | |
| ROOT::Vc::Internal::HelperImpl< Vc::ScalarImpl > | |
| ROOT::Vc::Internal::HelperImpl< Vc::SSE2Impl > | |
| HelperOps | |
| HEPEVT_DEF | HEPEVT common block |
| RooStats::HistFactory::HistFactoryNavigation | |
| RooStats::HistFactory::HistoFactor | |
| RooStats::HistFactory::HistoSys | |
| RooStats::HistFactory::HistRef | |
| Hoption_t | Histogram option structure |
| Hparam_t | Histogram parameters structure |
| RooStats::HypoTestCalculator | HypoTestCalculator is an interface class for a tools which produce RooStats HypoTestResults |
| RooStats::CombinedCalculator | CombinedCalculator is an interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals |
| RooStats::ProfileLikelihoodCalculator | ProfileLikelihoodCalculator is a concrete implementation of CombinedCalculator (the interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals) |
| RooStats::HybridCalculatorOriginal | HybridCalculatorOriginal class |
| RooStats::HypoTestCalculatorGeneric | Common base class for the Hypothesis Test Calculators |
| RooStats::AsymptoticCalculator | Hypothesis Test Calculator based on the asymptotic formulae for the profile likelihood ratio |
| RooStats::FrequentistCalculator | Hypothesis Test Calculator using a full frequentist procedure for sampling the test statistic distribution |
| RooStats::HybridCalculator | This class implements the Hypothesis test calculation using an hybrid (frequentist/bayesian) procedure |
| IBaseFunc | |
| ROOT::Math::FunctorImpl< IBaseFunc > | FunctorImpl is a base class for the functor handler implementation class |
| ROOT::Math::IBaseFunctionMultiDim | Documentation for the abstract class IBaseFunctionMultiDim |
| RooMinimizerFcn | |
| RooMultiGenFunction | Lightweight interface adaptor that exports a RooAbsReal as a ROOT::Math::IMultiGenFunction |
| ROOT::Fit::FcnAdapter | |
| ROOT::Math::Functor | Documentation for class Functor class |
| ROOT::Math::IGradientFunctionMultiDim | Interface (abstract class) for multi-dimensional functions providing a gradient calculation |
| ROOT::Math::GradFunctor | GradFunctor class for Multidimensional gradient functions |
| ROOT::Math::LSResidualFunc | LSResidualFunc class description |
| ROOT::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 |
| ROOT::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) |
| TPyMultiGradFunction | |
| ROOT::Math::IParametricFunctionMultiDim | IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam |
| ROOT::Math::IParametricGradFunctionMultiDim | 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 |
| GaussFunction | |
| GaussFunction | |
| ROOT::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 |
| ROOT::Math::WrappedMultiTF1 | 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 This wrapper class does not own the TF1 pointer, so it assumes it exists during the wrapper lifetime |
| ROOT::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 |
| ROOT::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 |
| ROOT::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 |
| WrapperRooPdf | |
| ROOT::Math::WrappedMemMultiFunction< FuncObj, MemFuncPtr > | |
| ROOT::Math::WrappedMultiFunction< Func > | Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-dimensional function interface |
| TPyMultiGenFunction | |
| ROOT::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 ) |
| RooGenFunction | Lightweight interface adaptor that exports a RooAbsReal as a ROOT::Math::IGenFunction |
| ROOT::Math::Functor1D | Functor1D class for one-dimensional functions |
| ROOT::Math::IGradientFunctionOneDim | Interface (abstract class) for one-dimensional functions providing a gradient calculation |
| ROOT::Math::GradFunctor1D | GradFunctor1D class for one-dimensional gradient functions |
| ROOT::Math::IntegrandTransform | Auxillary inner class for mapping infinite and semi-infinite integrals |
| ROOT::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 |
| ROOT::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 |
| ROOT::Math::ParamFunction< IParamGradFunction > | |
| ROOT::Math::Polynomial | Parametric Function class describing polynomials of order n |
| ROOT::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 |
| ROOT::Math::VavilovAccurateCdf | Class describing the Vavilov cdf |
| ROOT::Math::VavilovAccuratePdf | Class describing the Vavilov pdf |
| ROOT::Math::VavilovAccurateQuantile | Class describing the Vavilov quantile function |
| ROOT::Math::OneDimMultiFunctionAdapter< MultiFuncType > | OneDimMultiFunctionAdapter class to wrap a multidimensional function in one dimensional one |
| ROOT::Math::OneDimParamFunctionAdapter< ParamFuncType > | OneDimParamFunctionAdapter class to wrap a multi-dim parameteric function in one dimensional one |
| ROOT::Math::WrappedFunction< Func > | Template class to wrap any C++ callable object which takes one argument i.e |
| ROOT::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; |
| ROOT::Math::IBaseParam | Documentation for the abstract class IBaseParam |
| ROOT::Math::IParametricFunctionMultiDim | IParamFunction interface (abstract class) describing multi-dimensional parameteric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam |
| ROOT::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 |
| vdt::details::ieee754 | Used to switch between different type of interpretations of the data (64 bits) |
| RooFactoryWSTool::IFace | |
| RooClassFactory::ClassFacIFace | |
| RooCustomizer::CustIFace | |
| RooFactoryWSTool::SpecialsIFace | |
| RooSimWSTool::SimWSIFace | |
| TMVA::IFitterTarget | |
| TMVA::MethodCuts | |
| TMVA::MethodFDA | |
| TMVA::MethodMLP | |
| TMVA::MinuitFitter | |
| TMVA::OptimizeConfigParameters | |
| TMVA::ResultsMulticlass | |
| ROOT::Math::IGradientMultiDim | Gradient interface (abstract class) defining the signature for calculating the gradient of a multi-dimensional function |
| ROOT::Math::IGradientFunctionMultiDim | Interface (abstract class) for multi-dimensional functions providing a gradient calculation |
| ROOT::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 |
| ROOT::Math::IGradientFunctionOneDim | Interface (abstract class) for one-dimensional functions providing a gradient calculation |
| ROOT::Math::Polynomial | Parametric Function class describing polynomials of order n |
| ROOT::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 |
| TMVA::IMethod | |
| TMVA::MethodBase | |
| TMVA::MethodANNBase | |
| TMVA::MethodMLP | |
| TMVA::MethodBayesClassifier | |
| TMVA::MethodBDT | |
| TMVA::MethodCFMlpANN | |
| TMVA::MethodCompositeBase | |
| TMVA::MethodBoost | |
| TMVA::MethodCategory | |
| TMVA::MethodCuts | |
| TMVA::MethodDT | |
| TMVA::MethodFDA | |
| TMVA::MethodFisher | |
| TMVA::MethodHMatrix | |
| TMVA::MethodKNN | |
| TMVA::MethodLD | |
| TMVA::MethodLikelihood | |
| TMVA::MethodPDEFoam | |
| TMVA::MethodPDERS | |
| TMVA::MethodRuleFit | |
| TMVA::MethodSVM | |
| TMVA::MethodTMlpANN | |
| TMVA::PyMethodBase | |
| TMVA::MethodPyAdaBoost | |
| TMVA::MethodPyGTB | |
| TMVA::MethodPyRandomForest | |
| TMVA::RMethodBase | |
| TMVA::MethodC50 | |
| TMVA::MethodRSNNS | |
| TMVA::MethodRSVM | |
| TMVA::MethodRXGB | |
| ROOT::Math::IMinimizer1D | Interface class for numerical methods for one-dimensional minimization |
| ROOT::Math::BrentMinimizer1D | User class for performing function minimization |
| ROOT::Math::GSLMinimizer1D | Minimizer for arbitrary one dimensional functions |
| BidirMMapPipe_impl::Pages::impl | Implementation |
| Impl | |
| ROOT::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) |
| ROOT::Math::FunctorHandler< ParentFunctor, Func > | Functor Handler class is responsible for wrapping any other functor and pointer to free C functions |
| ROOT::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 |
| ROOT::Math::MemGradFunHandler< ParentFunctor, PointerToObj, PointerToMemFn, PointerToGradMemFn > | Functor Handler to Wrap pointers to member functions for the evaluation of the function and the gradient |
| ROOT::Math::ParamFunctorHandler< ParentFunctor, Func > | ParamFunctor Handler class is responsible for wrapping any other functor and pointer to free C functions |
| ROOT::Math::ParamMemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | ParamFunctor Handler to Wrap pointers to member functions |
| ROOT::Vc::ImplementationT< Features > | |
| TMVA::Increment< T > | |
| ROOT::Vc::AVX::IndexesFromZeroData< T > | |
| ROOT::Vc::AVX::IndexesFromZeroData< char > | |
| ROOT::Vc::AVX::IndexesFromZeroData< int > | |
| ROOT::Vc::AVX::IndexesFromZeroData< short > | |
| ROOT::Vc::AVX::IndexesFromZeroData< signed char > | |
| ROOT::Vc::AVX::IndexesFromZeroData< unsigned char > | |
| ROOT::Vc::AVX::IndexesFromZeroData< unsigned int > | |
| ROOT::Vc::AVX::IndexesFromZeroData< unsigned short > | |
| ROOT::Vc::AVX::IndexTypeHelper< T > | |
| ROOT::Vc::SSE::IndexTypeHelper< Size > | |
| ROOT::Vc::SSE::IndexTypeHelper< 16u > | |
| ROOT::Vc::SSE::IndexTypeHelper< 2u > | |
| ROOT::Vc::SSE::IndexTypeHelper< 4u > | |
| ROOT::Vc::SSE::IndexTypeHelper< 8u > | |
| ROOT::Vc::AVX::IndexTypeHelper< char > | |
| ROOT::Vc::AVX::IndexTypeHelper< double > | |
| ROOT::Vc::AVX::IndexTypeHelper< float > | |
| ROOT::Vc::AVX::IndexTypeHelper< int > | |
| ROOT::Vc::AVX::IndexTypeHelper< sfloat > | |
| ROOT::Vc::AVX::IndexTypeHelper< short > | |
| ROOT::Vc::AVX::IndexTypeHelper< unsigned char > | |
| ROOT::Vc::AVX::IndexTypeHelper< unsigned int > | |
| ROOT::Vc::AVX::IndexTypeHelper< unsigned short > | |
| ROOT::Math::rowOffsetsUtils::indices<> | |
| TClass::InsertTClassInRegistryRAII | |
| int | |
| cppyy.long_int | |
| cppyy.short | |
| cppyy.unsigned_int | |
| cppyy.unsigned_long | |
| cppyy.unsigned_short | |
| TEveParamList::IntConfig_t | |
| ROOT::Math::IntegratorMultiDim | User class for performing multidimensional integration |
| ROOT::Math::IntegratorOneDim | User Class for performing numerical integration of a function in one dimension |
| ROOT::Vc::Common::InterleavedMemoryAccessBase< V > | |
| ROOT::Vc::Common::InterleavedMemoryReadAccess< StructSize, V > | |
| ROOT::Vc::Common::InterleavedMemoryAccess< StructSize, V > | |
| ROOT::Vc::Common::InterleavedMemoryWrapper< S, V > | Wraps a pointer to memory with convenience functions to access it via vectors |
| ROOT::Math::Interpolator | Class for performing function interpolation of points |
| InterpreterCallbacks | |
| TClingCallbacks | |
| TMVA::Interval | |
| TMVA::LogInterval | |
| RooStats::IntervalCalculator | IntervalCalculator is an interface class for a tools which produce RooStats ConfIntervals |
| RooStats::BayesianCalculator | BayesianCalculator is a concrete implementation of IntervalCalculator, providing the computation of a credible interval using a Bayesian method |
| RooStats::CombinedCalculator | CombinedCalculator is an interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals |
| RooStats::FeldmanCousins | (like the Feldman-Cousins technique) is essentially a specific configuration of the more general NeymanConstruction |
| RooStats::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 |
| RooStats::HypoTestInverterOriginal | This class is now depratcated and to be replaced by the HypoTestInverter |
| RooStats::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 |
| RooStats::NeymanConstruction | NeymanConstruction is a concrete implementation of the NeymanConstruction interface that, as the name suggests, performs a NeymanConstruction |
| TMVA::RuleFitAPI::IntParms | |
| ROOT::Vc::Error::invalid_operands_of_types< L, R > | |
| ROOT::Math::Inverter< idim, n > | Matrix Inverter class Class to specialize calls to Dinv |
| ROOT::Math::Inverter< 0 > | Inverter<0> |
| ROOT::Math::Inverter< 1 > | 1x1 matrix inversion \(a_{11} \to 1/a_{11}\) |
| ROOT::Math::Inverter< 2 > | 2x2 matrix inversion using Cramers rule |
| TMVA::Config::IONames | |
| ROOT::Math::IOptions | Generic interface for defining configuration options of a numerical algorithm |
| ROOT::Math::GenAlgoOptions | Class implementing generic options for a numerical algorithm Just store the options in a map of string-value pairs |
| std::ios_base | STL class |
| std::basic_ios< Char > | STL class |
| std::basic_ostream< Char > | STL class |
| std::basic_ostringstream< Char > | STL class |
| std::ostringstream | STL class |
| TMVA::MsgLogger | |
| std::ostream | STL class |
| TGTextViewostream | |
| TMVA::IPruneTool | |
| TMVA::CostComplexityPruneTool | |
| TMVA::ExpectedErrorPruneTool | |
| ROOT::Math::IRootFinderMethod | Interface for finding function roots of one-dimensional functions |
| ROOT::Math::BrentRootFinder | Class for finding the root of a one dimensional function using the Brent algorithm |
| ROOT::Math::GSLRootFinder | Base class for GSL Root-Finding algorithms for one dimensional functions which do not use function derivatives |
| ROOT::Math::Roots::Bisection | Roots::Bisection Bisection algorithm, simplest algorithm for bracketing the roots of a function, but slowest one |
| ROOT::Math::Roots::Brent | Brent-Dekker algorithm which combines an interpolation strategy with the bisection algorithm See the GSL manual for more information |
| ROOT::Math::Roots::FalsePos | False Position algorithm based on linear interpolation |
| ROOT::Math::GSLRootFinderDeriv | Base class for GSL Root-Finding algorithms for one dimensional functions which use function derivatives |
| ROOT::Math::Roots::Newton | Newton algorithm, which computes the derivative at each iteration See the GSL manual for more information |
| ROOT::Math::Roots::Secant | Secant algorithm, simplified version of Newton method, which does not require the derivative at every step |
| ROOT::Math::Roots::Steffenson | Steffenson method, providing the fastes convergence |
| isEqualType< A, B > | |
| isEqualType< T, T > | |
| TEveChunkManager::iterator | |
| ROOT::Math::KDTree< _DataPoint >::iterator | |
| iterator | |
| ROOT::TSeq< T >::iterator | |
| TBtreeIter | Iterator of btree |
| TListIter | Iterator of linked list |
| TFileIter | |
| TListOfEnumsWithLockIter | Iterator for TListOfEnumsWithLock |
| TListOfFunctionsIter | Iterator for TListOfFunctions |
| TMapIter | Iterator of map |
| TObjArrayIter | Iterator of object array |
| TOrdCollectionIter | Iterator of ordered collection |
| TRefArrayIter | Iterator of object array |
| TTreeReader::Iterator_t | |
| TTreeReaderArray< T >::Iterator_t | |
| TViewPubDataMembersIter | Iterator of over the view's content |
| TViewPubFunctionsIter | Iterator of over the view's content |
| TGenericTable::iterator | |
| TIndexTable::iterator | |
| TTable::iterator | |
| iterator_traits | |
| TIterCategory< T > | |
| ROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, large > | |
| ROOT::Detail::TCollectionProxyInfo::Type< std::vector< Bool_t > >::Iterators | |
| ROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators | |
| ROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, true > | |
| ROOT::Detail::TCollectionProxyInfo::Iterators< std::vector< T >, false > | |
| ROOT::Detail::TCollectionProxyInfo::IteratorValue< Cont_t, value > | |
| ROOT::Detail::TCollectionProxyInfo::IteratorValue< Cont_t, value_ptr * > | |
| TMVA::KDEKernel | |
| ROOT::Math::KDTree< _DataPoint > | |
| ROOT::Meta::Selection::KeepFirstTemplateArguments< I > | Used to specify the number of arguments to be kept |
| ROOT::Math::KelvinFunctions | |
| ROOT::Minuit2::LASymMatrix | Class describing a symmetric matrix of size n |
| ROOT::Minuit2::LAVector | |
| TMVA::LDA | |
| TMath::Limits< T > | |
| TEveStraightLineSet::Line_t | |
| LINEAR | |
| Rgl::Pad::LineAttribSet | |
| THtml::LinkInfo_t | |
| ROOT::Math::LocalCoordinateSystemTag | Tag for identifying vectors based on a local coordinate system |
| TAtomicCount::LockGuard | |
| ROOT::Vc::Common::LogImpl< Base > | |
| TString::LongStr_t | |
| ROOT::Math::LorentzRotation | Lorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix |
| ROOT::Math::LorentzVector< CoordSystem > | Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part |
| ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double > > | |
| ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< Double32_t > > | |
| ROOT::Vc::SSE::M256 | |
| Magics | |
| JupyROOT.magics.cppmagic.CppMagics | |
| ROOT::Math::rowOffsetsUtils::make_indices_impl< I, IndexTuple, N > | |
| ROOT::Math::rowOffsetsUtils::make_indices_impl< 0, indices<>, N > | |
| ROOT::Math::rowOffsetsUtils::make_indices< N > | |
| ROOT::Math::rowOffsetsUtils::make_indices_impl< I, indices< Indices...>, N > | |
| ROOT::Math::rowOffsetsUtils::make_indices_impl< N, indices< Indices...>, N > | |
| ROOT::Math::detail::manipulator< char_t > | |
| std::map< K, T > | STL class |
| TGDMLBaseTGDMMapHelper | |
| TGDMMapHelper< T > | |
| TGDMMapHelper< const char > | |
| TGDMMapHelper< TGDMLRefl > | |
| TGDMMapHelper< TGeoElement > | |
| TGDMMapHelper< TGeoIsotope > | |
| TGDMMapHelper< TGeoMaterial > | |
| TGDMMapHelper< TGeoMedium > | |
| TGDMMapHelper< TGeoMixture > | |
| TGDMMapHelper< TGeoRotation > | |
| TGDMMapHelper< TGeoScale > | |
| TGDMMapHelper< TGeoShape > | |
| TGDMMapHelper< TGeoTranslation > | |
| TGDMMapHelper< TGeoVolume > | |
| TCollectionProxyInfo::Map | Small helper to encapsulate all necessary data accesses for containers like vector, list, deque |
| TCollectionProxyInfo::Map | Small helper to encapsulate all necessary data accesses for containers like set, multiset etc |
| TCollectionProxyInfo::Map | Small helper to encapsulate all necessary data accesses for containers like set, multiset etc |
| ROOT::Vc::Internal::MapImpl< Impl > | |
| ROOT::Vc::Internal::MapImpl< Vc::SSE42Impl > | |
| TEveStraightLineSet::Marker_t | |
| Rgl::Pad::MarkerPainter | |
| ROOT::Vc::AVX::Mask< VectorSize, RegisterWidth > | |
| ROOT::Vc::Scalar::Mask< VectorSize > | |
| ROOT::Vc::SSE::Mask< VectorSize > | |
| ROOT::Vc::AVX::Mask< Size, sizeof(VectorType)> | |
| ROOT::Vc::AVX::Mask< VectorSize, 16u > | |
| ROOT::Vc::AVX::Mask< VectorSize, 32u > | |
| ROOT::Vc::SSE::MaskHelper< Size1 > | |
| ROOT::Vc::SSE::MaskHelper< 2 > | |
| ROOT::Vc::SSE::MaskHelper< 4 > | |
| ROOT::Vc::SSE::MaskHelper< 8 > | |
| ROOT::Vc::Math< T > | |
| ROOT::Vc::Math< double > | |
| ROOT::Vc::Math< float > | |
| ROOT::Math::MathMoreLibrary | |
| ROOT::Math::MatRepStd< T, D, D2 > | Expression wrapper class for Matrix objects |
| ROOT::Math::MatRepStd< double, 5, 5 > | |
| ROOT::Math::MatRepStd< Double32_t, 5, 5 > | |
| ROOT::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 |
| ROOT::Math::MatRepSym< double, N_CITIES > | |
| ROOT::Minuit2::MatrixInverse< mtype, M, T > | |
| ROOT::Minuit2::MatrixInverse< vec, M, T > | |
| ROOT::Math::MatrixMulOp< MatrixA, MatrixB, T, D > | Class for Matrix-Matrix multiplication |
| TProof::MD5Mod_t | |
| ROOT::Meta::Selection::MemberAttributes< memberAttributes > | Used to specify attributes of data members in the "DictSelection" syntax |
| MemInfo_t | |
| ROOT::Vc::MemoryDimensionBase< V, Parent, Dimension, RowMemory > | |
| ROOT::Vc::MemoryBase< V, Parent, Dimension, RowMemory > | Common interface to all Memory classes, independent of allocation on the stack or heap |
| ROOT::Vc::Memory< V, Size *Size > | |
| ROOT::Vc::MemoryDimensionBase< V, Memory< V, 0u, 0u >, Dimension, void > | |
| ROOT::Vc::MemoryBase< V, Memory< V, 0u, 0u >, 1, void > | |
| ROOT::Vc::Memory< V, 0u, 0u > | A helper class that is very similar to Memory<V, Size> but with dynamically allocated memory and thus dynamic size |
| ROOT::Vc::MemoryDimensionBase< V, Memory< V, Size, 0u >, Dimension, void > | |
| ROOT::Vc::MemoryBase< V, Memory< V, Size, 0u >, 1, void > | |
| ROOT::Vc::Memory< V, Size, 0u > | A helper class to simplify usage of correctly aligned and padded memory, allowing both vector and scalar access |
| ROOT::Vc::MemoryDimensionBase< V, Memory< V, Size1, Size2 >, Dimension, Memory< V, Size2 > > | |
| ROOT::Vc::MemoryBase< V, Memory< V, Size1, Size2 >, 2, Memory< V, Size2 > > | |
| ROOT::Vc::Memory< V, Size1, Size2 > | A helper class for fixed-size two-dimensional arrays |
| ROOT::Vc::MemoryDimensionBase< V, Parent, 1, RowMemory > | |
| ROOT::Vc::MemoryDimensionBase< V, Parent, 2, RowMemory > | |
| Rgl::Pad::MeshPatch_t | |
| ROOT::Math::meta_col_dot< I > | |
| ROOT::Math::meta_col_dot< 0 > | |
| ROOT::Math::meta_dot< I > | |
| ROOT::Math::meta_dot< 0 > | |
| ROOT::Math::meta_mag< I > | |
| ROOT::Math::meta_mag< 0 > | |
| ROOT::Math::meta_matrix_dot< I > | |
| ROOT::Math::meta_matrix_dot< 0 > | |
| ROOT::Math::meta_row_dot< I > | |
| ROOT::Math::meta_row_dot< 0 > | |
| TGenCollectionProxy::Method | Small helper to execute (compiler) generated function for the access to STL or other containers |
| TGenCollectionProxy::Method0 | |
| TMVA::MethodCFMlpANN_Utils | |
| TMVA::MethodCFMlpANN | |
| PyROOT::MethodProxy::MethodInfo_t | |
| PyROOT::MethodProxy | |
| mg_callbacks | |
| mg_request_info::mg_header | |
| mg_request_info | |
| ROOT::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 |
| ROOT::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 |
| ROOT::Math::GSLMinimizer | GSLMinimizer class |
| ROOT::Math::GSLNLSMinimizer | GSLNLSMinimizer class for Non Linear Least Square fitting It Uses the Levemberg-Marquardt algorithm from GSL Non Linear Least Square fitting |
| ROOT::Math::GSLSimAnMinimizer | GSLSimAnMinimizer class for minimization using simulated annealing using the algorithm from GSL |
| ROOT::Math::RMinimizer | RMinimizer class |
| ROOT::Math::GeneticMinimizer | GeneticMinimizer |
| ROOT::Minuit2::Minuit2Minimizer | Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for Minuit2 minimization algorithm |
| TFumiliMinimizer | TFumiliMinimizer class: minimizer implementation based on TFumili |
| TLinearMinimizer | TLinearMinimizer class: minimizer implementation based on TMinuit |
| TMinuitMinimizer | TMinuitMinimizer class: ROOT::Math::Minimizer implementation based on TMinuit |
| ROOT::Math::MinimizerOptions | Minimizer options |
| ROOT::Math::MinimizerVariableTransformation | Base class for MinimizerVariable transformations defining the functions to deal with bounded parameters |
| ROOT::Math::SinVariableTransformation | Sin Transformation class for dealing with double bounded variables |
| ROOT::Math::SqrtLowVariableTransformation | Sqrt Transformation class for dealing with lower bounded variables |
| ROOT::Math::SqrtUpVariableTransformation | Sqrt Transformation class for dealing with upper bounded variables |
| ROOT::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 |
| ROOT::Minuit2::MinimumBuilder | |
| ROOT::Minuit2::CombinedMinimumBuilder | |
| ROOT::Minuit2::FumiliBuilder | Builds the FunctionMinimum using the Fumili method |
| ROOT::Minuit2::ScanBuilder | Performs a minimization using the simplex method of Nelder and Mead (ref |
| ROOT::Minuit2::SimplexBuilder | Performs a minimization using the simplex method of Nelder and Mead (ref |
| ROOT::Minuit2::VariableMetricBuilder | Build (find) function minimum using the Variable Metric method (MIGRAD) |
| ROOT::Minuit2::MinimumError | MinimumError keeps the inv |
| ROOT::Minuit2::MinimumErrorUpdator | |
| ROOT::Minuit2::DavidonErrorUpdator | Update of the covariance matrix for the Variable Metric minimizer (MIGRAD) |
| ROOT::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 |
| ROOT::Minuit2::MinimumParameters | |
| ROOT::Minuit2::MinimumSeed | MinimumSeed contains the starting values for the minimization produced by the SeedGenerator |
| ROOT::Minuit2::MinimumSeedGenerator | Base class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization; |
| ROOT::Minuit2::MnSeedGenerator | Concrete implementation of the MinimumSeedGenerator interface; used within ModularFunctionMinimizer; |
| ROOT::Minuit2::SimplexSeedGenerator | Generate Simplex starting point (state) |
| ROOT::Minuit2::MinimumState | MinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder) |
| ROOT::Math::MinOp< T > | Subtraction Operation Class |
| ROOT::Minuit2::MinosError | Class holding the result of Minos (lower and upper values) for a specific parameter |
| MINUIT2 | |
| ROOT::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; |
| ROOT::Math::Minus< T > | Unary Minus Operation Class |
| ROOT::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 ) |
| ROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > > | Specialization for symmetrix -= general : NOT Allowed operation |
| ROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > > | Specialization for symmetric matrices |
| ROOT::Math::MiserParameters | Structures collecting parameters for MISER multidimensional integration |
| ROOT::Minuit2::BasicFunctionMinimum::MnAboveMaxEdm | |
| ROOT::Minuit2::FunctionMinimum::MnAboveMaxEdm | |
| ROOT::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 |
| ROOT::Minuit2::MnFumiliMinimize | API class for minimization using Fumili technology; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc |
| ROOT::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 |
| ROOT::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 |
| ROOT::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 |
| ROOT::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 |
| ROOT::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; |
| ROOT::Minuit2::MnCovarianceSqueeze | Class to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index |
| ROOT::Minuit2::MnCross | |
| ROOT::Minuit2::MnEigen | API class for calculating the eigenvalues of symmetric matrix |
| ROOT::Minuit2::MnFcn | Wrapper class to FCNBase interface used internally by Minuit |
| ROOT::Minuit2::MnUserFcn | Wrapper used by Minuit of FCN interface containing a reference to the transformation object |
| ROOT::Minuit2::MnFunctionCross | MnFunctionCross |
| ROOT::Minuit2::MnGlobalCorrelationCoeff | Class for global correlation coefficient |
| ROOT::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 |
| ROOT::Minuit2::BasicMinimumError::MnHesseFailed | |
| ROOT::Minuit2::MinimumError::MnHesseFailed | |
| ROOT::Minuit2::BasicMinimumError::MnInvertFailed | |
| ROOT::Minuit2::MinimumError::MnInvertFailed | |
| ROOT::Minuit2::MnLineSearch | Implements a 1-dimensional minimization along a given direction (i.e |
| ROOT::Minuit2::MnMachinePrecision | Determines the relative floating point arithmetic precision |
| ROOT::Minuit2::BasicMinimumError::MnMadePosDef | |
| ROOT::Minuit2::MinimumError::MnMadePosDef | |
| ROOT::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; |
| ROOT::Minuit2::BasicMinimumError::MnNotPosDef | |
| ROOT::Minuit2::MinimumError::MnNotPosDef | |
| ROOT::Minuit2::MnParabola | This class defines a parabola of the form a*x*x + b*x + c |
| ROOT::Minuit2::MnParabolaFactory | |
| ROOT::Minuit2::MnParabolaPoint | A point of a parabola |
| ROOT::Minuit2::MnParameterScan | Scans the values of FCN as a function of one Parameter and retains the best function and Parameter values found |
| ROOT::Minuit2::MnPlot | MnPlot produces a text-screen graphical output of (x,y) points, e.g |
| ROOT::Minuit2::MnPosDef | Force the covariance matrix to be positive defined by adding extra terms in the diagonal |
| ROOT::Minuit2::MnPrint | |
| ROOT::Minuit2::BasicFunctionMinimum::MnReachedCallLimit | |
| ROOT::Minuit2::FunctionMinimum::MnReachedCallLimit | |
| ROOT::Minuit2::MnRefCountedPointer< T > | |
| ROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicFunctionGradient > | |
| ROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicFunctionMinimum > | |
| ROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumError > | |
| ROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumParameters > | |
| ROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumSeed > | |
| ROOT::Minuit2::MnRefCountedPointer< ROOT::Minuit2::BasicMinimumState > | |
| ROOT::Minuit2::MnReferenceCounter | |
| ROOT::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) |
| ROOT::Minuit2::MnTiny | |
| ROOT::Minuit2::MnTraceObject | |
| TMinuit2TraceObject | |
| ROOT::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 |
| ROOT::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 |
| ROOT::Minuit2::MnUserParameterState | Class which holds the external user and/or internal Minuit representation of the parameters and errors; transformation internal <-> external on demand; |
| ROOT::Minuit2::MnUserTransformation | Class dealing with the transformation between user specified parameters (external) and internal parameters used for minimization |
| ROOT::Minuit2::MnVectorTransform | |
| TMVA::kNN::ModulekNN | |
| ModuleType | |
| ROOT.ModuleFacade | Allow loading ROOT classes as attributes ---------------------------------— |
| ROOT::Minuit2::MPIProcess | |
| ROOT::Minuit2::MPITerminate | |
| ROOT::Math::MulOp< T > | Multiplication (element-wise) Operation Class |
| MultiDist | Free functions adapter needed by UNURAN for multidimensional cont distribution |
| ROOT::Math::MultPolicy< T, R1, R2 > | Matrix-matrix multiplication policy |
| MYSQL_BIND | |
| MYSQL_STMT | |
| TGDMLWrite::NameLst | |
| ROOT::Vc::NegateTypeHelper< T > | |
| ROOT::Vc::NegateTypeHelper< unsigned char > | |
| ROOT::Vc::NegateTypeHelper< unsigned int > | |
| ROOT::Vc::NegateTypeHelper< unsigned short > | |
| ROOT::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 |
| TMVA::Node | |
| TMVA::BinarySearchTreeNode | |
| TMVA::CCTreeWrapper::CCTreeNode | |
| TMVA::DecisionTreeNode | |
| TMVA::kNN::Node< T > | |
| TMVA::kNN::Node< TMVA::kNN::Event > | |
| RooStats::HistFactory::EstimateSummary::NormFactor | |
| RooStats::HistFactory::NormFactor | |
| <NSApplicationDelegate> | |
| ROOTApplicationDelegate | |
| NSObject | |
| PassiveKeyGrab | |
| QuartzImage | |
| QuartzPixmap | |
| ROOTApplicationDelegate | |
| ROOT::MacOSX::Util::NSScopeGuard< DerivedType > | |
| ROOT::MacOSX::Util::NSScopeGuard< ROOTApplicationDelegate > | |
| ROOT::MacOSX::Util::NSStrongReference< DerivedType > | |
| ROOT::MacOSX::Util::NSStrongReference< NSObject< X11Drawable-p > > | |
| ROOT::MacOSX::Util::NSStrongReference< NSOpenGLContext > | |
| ROOT::MacOSX::Util::NSStrongReference< QuartzWindow > | |
| NSView | |
| QuartzView | |
| ROOTOpenGLView | |
| NSWindow | |
| QuartzWindow | |
| <NSWindowDelegate> | |
| QuartzWindow | |
| RooStats::NuisanceParametersSampler | Helper class for ToyMCSampler |
| TMVA::null_t< F > | |
| ROOT::Math::NullTypeFunc1D | |
| RooStats::NumberCountingPdfFactory | |
| numeric_limits | |
| std::numeric_limits< ::ROOT::Vc::SSE::int_v > | |
| std::numeric_limits< ::ROOT::Vc::SSE::short_v > | |
| std::numeric_limits< ::ROOT::Vc::SSE::uint_v > | |
| std::numeric_limits< ::ROOT::Vc::SSE::ushort_v > | |
| RooSimWSTool::ObjBuildConfig | |
| object | |
| cppyy._global_cpp.std | |
| JupyROOT.cppcompleter.CppCompleter | |
| JupyROOT.kernel.cppcompleter.CppCompleter | |
| JupyROOT.kernel.utils.MagicLoader | |
| JupyROOT.utils.CanvasDrawer | |
| JupyROOT.utils.CaptureDrawnCanvases | |
| JupyROOT.utils.StreamCapture | |
| ROOT._Configuration | Configuration ------------------------------------------------------------— |
| ROOT._ExpandMacroFunction | Put std namespace directly onto ROOT ----------------------------------—— |
| ROOTwriter.ROOTwriter | |
| writer.writer | |
| PyROOT::ObjectProxy | |
| RooSimWSTool::ObjSplitRule | |
| TODBCStatement::ODBCBufferRec_t | |
| Rgl::Pad::OffScreenDevice | |
| ROOT::Vc::Operand< Parent > | |
| ROOT::Vc::Operand< BinaryOperation< Result, Left, Right > > | |
| ROOT::Vc::BinaryOperation< Result, Left, Right > | |
| Baker::Options | |
| THtml::OutputStyle_t | |
| RooStats::HistFactory::OverallSys | |
| ROOT::Math::CholeskyDecompHelpers::PackedArrayAdapter< G > | Adapter for packed arrays (to SMatrix indexing conventions) |
| BidirMMapPipe_impl::PageChunk | Class representing a chunk of pages |
| BidirMMapPipe_impl::Pages | Handle class for a number of Pages |
| RooNormSetCache::PairCmp | |
| ROOT::Detail::TCollectionProxyInfo::PairHolder< T, Q > | |
| ROOT::Vc::SSE::ParameterHelper< T > | |
| ROOT::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 |
| ROOT::Math::ParamFunctionBase | Class defining the signature for multi-dim parametric functions |
| ROOT::Math::ParamFunctor | Param Functor class for Multidimensional functions |
| passwd | |
| THtml::PathInfo_t | |
| PdfCacheElem | |
| RooFFTConvPdf::FFTCacheElem | |
| PgSQL_Stmt_t | |
| PictureAttributes_t | |
| XrdPoll::PipeData | |
| TTable::piterator | |
| ROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, R1, R2 > | |
| ROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > > | |
| ROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepSym< T, D3 > > | |
| ROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, R1, R2 > | Structure to deal when a submatrix is placed in a matrix |
| ROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > > | |
| ROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > > | |
| ROOT::Math::PlainParameters | |
| ROOT::Math::Plane3D | Class describing a geometrical plane in 3 dimensions |
| RooAbsData::PlotOpt | |
| RooAbsReal::PlotOpt | |
| Rgl::PlotTranslation | |
| ROOT::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 ) |
| ROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > > | Specialization for symmetrix += general : NOT Allowed operation |
| ROOT::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 ) |
| TColorGradient::Point | |
| ROOT::MacOSX::X11::Point | |
| TProofDrawListOfGraphs::Point3D_t | |
| TProofDrawListOfPolyMarkers3D::Point4D_t | |
| Point_t | |
| ROOT::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) |
| ROOT::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) |
| BidirMMapPipe::PollEntry | For poll() interface |
| TEvePolygonSetProjected::Polygon_t | |
| Rgl::Pad::PolygonStippleSet | |
| ROOT::Math::PositionVector2D< CoordSystem, Tag > | Class describing a generic position vector (point) in 2 dimensions |
| ROOT::Math::PositionVector3D< CoordSystem, Tag > | Class describing a generic position vector (point) in 3 dimensions |
| ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double > > | |
| ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< Double32_t > > | |
| RooStats::HistFactory::PreprocessFunction | |
| TEveProjection::PreScaleEntry_t | |
| ProcInfo_t | |
| RooStats::ProfileInspector | |
| ProgressWriter | |
| TGLSurfacePainter::Projection_t | |
| RooStats::ProofConfig | Holds configuration options for proof and proof-lite |
| ProofServEnv_t | |
| PyROOT::PropertyProxy | |
| TMVA::PruningInfo | |
| ROOT::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 (-,-,-,+) |
| ROOT::Math::PtEtaPhiM4D< ScalarType > | Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+) |
| pthread_cond_t | |
| ROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators::PtrSize_t | |
| TCollectionProxyInfo::Pushfront | Small helper to encapsulate all necessary data accesses for containers like forward_list |
| ROOT::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) |
| ROOT::Math::PxPyPzE4D< double > | |
| ROOT::Math::PxPyPzE4D< Double32_t > | |
| ROOT::Math::PxPyPzM4D< ScalarType > | Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M) |
| Pybins_t | Pythia6 common block Pybins |
| PyROOT::PyCallable | |
| PyROOT::TMethodHolder | |
| PyROOT::TClassMethodHolder | |
| PyROOT::TConstructorHolder | |
| PyROOT::TFunctionHolder | |
| PyROOT::TSetItemHolder | |
| Pydat1_t | Pythia6 common block Pydat1 |
| Pydat2_t | Pythia6 common block Pydat2 |
| Pydat3_t | Pythia6 common block Pydat3 |
| Pydat4_t | Pythia6 common block Pydat4 |
| Pydatr_t | Pythia6 common block Pydatr |
| Pyint1_t | Pythia6 common block Pyint1 |
| Pyint2_t | Pythia6 common block Pyint2 |
| Pyint3_t | Pythia6 common block Pyint3 |
| Pyint4_t | Pythia6 common block Pyint4 |
| Pyint5_t | Pythia6 common block Pyint5 |
| Pyint6_t | Pythia6 common block Pyint6 |
| Pyint7_t | Pythia6 common block Pyint7 |
| Pyint8_t | Pythia6 common block Pyint8 |
| Pyint9_t | Pythia6 common block Pyint9 |
| Pyints_t | Pythia6 common block Pyints |
| Pyjets_t | Pythia6 common block Pyjets |
| Pymssm_t | Pythia6 common block Pymssm |
| Pypars_t | Pythia6 common block Pypars |
| PyROOT::PyRootClass | Type object to hold TClassRef instance (this is only semantically a presentation of PyRootType instances, not in a C++ sense) |
| Pyssmt_t | Pythia6 common block Pyssmt |
| Pysubs_t | Pythia6 common block Pysubs |
| Q3MainWindow | |
| ApplicationWindow | Main Qt&Root Application Window: |
| QApplication | |
| TQRootApplication | |
| QMainWindow | |
| qtexample.window | |
| QObject | |
| TQCanvasMenu | |
| QThread | |
| MandelBase | |
| Mandel< Impl > | |
| Mandel< ScalarImpl > | |
| Mandel< VcImpl > | |
| Quad | |
| ROOT::Math::QuasiRandom< Engine > | User class for MathMore random numbers template on the Engine type |
| ROOT::Math::Quaternion | Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k) |
| TMVA::QuickMVAProbEstimator | |
| QVBox | |
| TQRootDialog | |
| QWidget | |
| MainWindow | |
| TQRootCanvas | |
| ROOT::Math::Random< Engine > | Documentation for the Random class |
| ROOT::Math::RandomBaseEngine | |
| ROOT::Math::TRandomEngine | |
| ROOT::Math::LCGEngine | |
| ROOT::Math::MersenneTwisterEngine | Random number generator class based on M |
| ROOT::Math::MixMaxEngine | MIXMAX Random number generator |
| ROOT::Math::RandomFunctions< Engine, EngineBaseType > | |
| ROOT::Math::RandomFunctions< EngineType, DefaultEngineType > | |
| ROOT::Math::RandomFunctions< EngineType, ROOT::Math::GSLRandomEngine > | Specialized implementation of the Random functions based on the GSL library |
| ROOT::Math::RandomFunctionsImpl< EngineBaseType > | Definition of the generic impelmentation class for the RandomFunctions |
| ROOT::Math::RandomFunctionsImpl< DefaultEngineType > | |
| ROOT::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 |
| TMVA::RandomGenerator | |
| TMVA::Rank | |
| TMVA::Ranking | |
| TString::RawStr_t | |
| ROOT::TMetaUtils::RConstructorType | |
| TFormLeafInfo::ReadValueHelper< T > | |
| TFormLeafInfo::ReadValueHelper< Long64_t > | |
| TFormLeafInfo::ReadValueHelper< LongDouble_t > | |
| TFormLeafInfo::ReadValueHelper< ULong64_t > | |
| TMVA::RuleFitAPI::RealParms | |
| RooVectorDataStore::RealVector | |
| RooVectorDataStore::RealFullVector | |
| TEveCaloData::RebinData_t | |
| ROOT::MacOSX::X11::Rectangle | |
| Rectangle_t | |
| RecursiveASTVisitor | |
| RScanner | |
| RedirectHandle_t | |
| redirguard | |
| TMVA::RegressionVariance | |
| TString::Rep_t | |
| TMVA::Results | |
| TMVA::ResultsClassification | |
| TMVA::ResultsMulticlass | |
| TMVA::ResultsRegression | |
| ROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, R1, R2 > | Structure for getting sub matrices We have different cases according to the matrix representations |
| ROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > > | |
| ROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > > | |
| ROOT::MacOSX::X11::ColorParser::RGB_t | |
| ROOT::Math::RichardsonDerivator | User class for calculating the derivatives of a function |
| rng_state_st | |
| TMVA::ROCCalc | |
| RooAbsCache | RooAbsCache is the abstract base class for data members of RooAbsArgs that cache other (composite) RooAbsArg expressions |
| RooCacheManager< 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 |
| RooCacheManager< RooAbsCacheElement > | |
| RooObjCacheManager | Class RooObjCacheManager is an implementation of class RooCacheManager<RooAbsCacheElement> and specializes in the storage of cache elements that contain RooAbsArg objects |
| RooCacheManager< std::vector< Double_t > > | |
| RooAbsCacheElement | RooAbsCacheElement is the abstract base class for objects to be stored in RooAbsCache cache manager objects |
| ParamHistFunc::CacheElem | |
| PiecewiseInterpolation::CacheElem | |
| RooAbsAnaConvPdf::CacheElem | Iterator over _convNormSet |
| RooAbsCachedPdf::PdfCacheElem | |
| RooIntegralMorph::MorphCacheElem | |
| RooAbsCachedReal::FuncCacheElem | |
| RooAbsPdf::CacheElem | Normalization set with for above integral |
| RooAddition::CacheElem | Iterator over set |
| RooAddModel::CacheElem | Transiet cache with transformed values of coefficients |
| RooAddModel::IntCacheElem | |
| RooAddPdf::CacheElem | Transiet cache with transformed values of coefficients |
| RooEffProd::CacheElem | |
| RooMomentMorph::CacheElem | |
| RooProdPdf::CacheElem | |
| RooProduct::CacheElem | |
| RooProjectedPdf::CacheElem | |
| RooRealSumPdf::CacheElem | |
| RooSimultaneous::CacheElem | |
| RooAbsFunc | Abstract interface for evaluating a real-valued function of one real variable and performing numerical algorithms on it |
| RooConvIntegrandBinding | 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 |
| RooHistError::BinomialSumAsym | |
| RooHistError::BinomialSumEff | |
| RooHistError::PoissonSum | |
| RooIntegratorBinding | Function binding representing the output of a RooAbsIntegrator |
| RooInvTransform | 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 |
| RooRealBinding | Lightweight interface adaptor that binds a RooAbsReal object to a subset of its servers and present it as a simple array oriented interface |
| RooDataProjBinding | Adaptor that projects a real function via summation of states provided in a dataset |
| RooRealAnalytic | Lightweight RooAbsFunc interface adaptor that binds an analytic integral of a RooAbsReal object (specified by a code) to a set of dependent variables |
| RooScaledFunc | Lightweight RooAbsFunction implementation that applies a constant scale factor to another RooAbsFunc |
| RooAbsLValue | Abstract base class for objects that are lvalues, i.e |
| RooAbsCategoryLValue | 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') |
| RooCategory | RooCategory represents a fundamental (non-derived) discrete value object |
| RooSuperCategory | RooSuperCategory consolidates several RooAbsCategoryLValue objects into a single category |
| RooAbsRealLValue | 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 |
| RooErrorVar | RooErrorVar is an auxilary class that represents the error of a RooRealVar as a seperate object |
| RooLinearVar | |
| RooRealVar | RooRealVar represents a fundamental (non-derived) real valued object |
| RooAbsProxy | RooAbsProxy is the abstact interface for proxy classes |
| RooArgProxy | RooArgProxy is the abstact interface for RooAbsArg proxy classes |
| RooCategoryProxy | RooCategoryProxy is the proxy implementation for RooAbsCategory objects A RooCategoryProxy is the general mechanism to store references to RooAbsCategoriess inside a RooAbsArg |
| RooRealProxy | RooRealProxy is the concrete proxy for RooAbsReal objects A RooRealProxy is the general mechanism to store references to RooAbsReals inside a RooAbsArg |
| RooListProxy | RooListProxy is the concrete proxy for RooArgList objects |
| RooSetProxy | RooSetProxy is the concrete proxy for RooArgSet objects |
| RooAbsRootFinder | RooAbsRootFinder is the abstract interface for finding roots of real-valued 1-dimensional function that implements the RooAbsFunc interface |
| RooBrentRootFinder | Implement the abstract 1-dimensional root finding interface using the Brent-Decker method |
| RooAICRegistry | RooAICRegistry is a utility class for operator p.d.f classes that keeps track of analytical integration codes and associated normalization and integration sets |
| RooBlindTools | |
| RooCFunction1Map< VO, VI > | |
| RooCFunction2Map< VO, VI1, VI2 > | |
| RooCFunction3Map< VO, VI1, VI2, VI3 > | |
| RooCFunction4Map< VO, VI1, VI2, VI3, VI4 > | |
| RooComplex | Class RooComplex is a simple container class for complex values |
| RooDirItem | RooDirItem is a utility base class for RooFit objects that are to be attached to ROOT directories |
| RooDataHist | RooDataSet is a container class to hold N-dimensional binned data |
| RooDataSet | RooDataSet is a container class to hold unbinned data |
| RooFitResult | |
| RooErrorHandler | |
| RooFIter | |
| RooFunctor | Lightweight interface adaptor that exports a RooAbsPdf as a functor |
| RooGlobalFunc | |
| RooHistError | RooHistError is a singleton class used to calculate the error bars for each bin of a RooHist object |
| RooLinkedListElem | RooLinkedListElem is an link element for the RooLinkedList class |
| RooMath | |
| RooMathCoreReg | |
| RooMathMoreReg | |
| RooMPSentinel | RooMPSentinel is a singleton class that keeps track of all parellel execution processes for goodness-of-fit calculations |
| RooNormSetCache | Class RooNormSet cache manage the bookkeeping of multiple instances of sets of integration and normalization observables that effectively have the same definition |
| RooNumber | Class RooNumber implements numeric constants used by RooFit |
| RooPrintable | RooPlotable is a 'mix-in' base class that define the standard RooFit plotting and printing methods |
| RooAbsArg | 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 |
| RooAbsCategory | RooAbsCategory is the common abstract base class for objects that represent a discrete value with a finite number of states |
| RooAbsCategoryLValue | 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') |
| RooBinningCategory | Class RooBinningCategory provides a real-to-category mapping defined by a series of thresholds |
| RooMappedCategory | |
| RooMultiCategory | RooMultiCategory consolidates several RooAbsCategory objects into a single category |
| RooThresholdCategory | Class RooThresholdCategory provides a real-to-category mapping defined by a series of thresholds |
| RooAbsReal | 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 |
| ParamHistFunc | |
| PiecewiseInterpolation | |
| Roo1DMomentMorphFunction | 1-dimensional morph function between a list of input functions (varlist) as a function of one input parameter (m) |
| Roo2DMomentMorphFunction | 2-dimensional morph function between a list of function-numbers as a function of two input parameters (m1 and m2) |
| RooAbsCachedReal | 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 |
| RooAbsSelfCachedReal | RooAbsSelfCachedReal is an abstract base class for functions whose output is cached in terms of a histogram in all observables between getVal() and evaluate() |
| RooCachedReal | RooCachedReal is an implementation of RooAbsCachedReal that can cache any external RooAbsReal input function provided in the constructor |
| RooNumRunningInt | 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 |
| RooNumCdf | Class RooNumCdf is an implementation of RooNumRunningInt specialized to calculate cumulative distribution functions from p.d.f.s |
| RooAbsHiddenReal | RooAbsHiddenReal is a base class for objects that want to hide their return value from interactive use, e.g |
| RooUnblindCPAsymVar | 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 |
| RooUnblindOffset | 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 |
| RooUnblindPrecision | 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 |
| RooUnblindUniform | 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 |
| RooAbsMoment | RooAbsMoment represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class |
| RooFirstMoment | RooFirstMoment represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class |
| RooMoment | RooMoment represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class |
| RooSecondMoment | RooSecondMoment represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class |
| RooAbsPdf | 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 |
| NuMuToNuE_Oscillation | |
| Roo2DKeysPdf | Two-dimensional kernel estimation PDF |
| RooAbsAnaConvPdf | |
| RooBCPEffDecay | PDF describing decay time distribution of B meson including effects of standard model CP violation |
| RooBCPGenDecay | Implement standard CP physics model with S and C (no mention of lambda) Suitably stolen and modified from RooBCPEffDecay |
| RooBDecay | Most general description of B decay time distribution with effects of CP violation, mixing and life time differences |
| RooBMixDecay | Class RooBMixDecay is a RooAbsAnaConvPdf implementation that describes the decay of B mesons with the effects of B0/B0bar mixing |
| RooDecay | Single or double sided decay function that can be analytically convolved with any RooResolutionModel implementation |
| RooNonCPEigenDecay | Time-dependent RooAbsAnaConvPdf for CP violating decays to Non-CP eigenstates (eg, \( B_0 \rightarrow \rho^\pm \pi^\mp\)) |
| RooAbsCachedPdf | 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 |
| RooAbsSelfCachedPdf | 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() |
| RooCachedPdf | RooCachedPdf is an implementation of RooAbsCachedPdf that can cache any external RooAbsPdf input function provided in the constructor |
| RooFFTConvPdf | |
| RooIntegralMorph | |
| RooAddPdf | |
| RooArgusBG | RooArgusBG is a RooAbsPdf implementation describing the ARGUS background shape |
| RooBernstein | Bernstein basis polynomials are positive-definite in the range [0,1] |
| RooBifurGauss | Bifurcated Gaussian p.d.f with different widths on left and right side of maximum value |
| RooBreitWigner | Class RooBreitWigner is a RooAbsPdf implementation that models a non-relativistic Breit-Wigner shape |
| RooBukinPdf | RooBukinPdf implements the NovosibirskA function |
| RooCBShape | P.d.f implementing the Crystall Ball line shape |
| RooCFunction1PdfBinding< VO, VI > | |
| RooCFunction2PdfBinding< VO, VI1, VI2 > | |
| RooCFunction3PdfBinding< VO, VI1, VI2, VI3 > | |
| RooCFunction4PdfBinding< VO, VI1, VI2, VI3, VI4 > | |
| RooChebychev | Chebychev polynomial p.d.f |
| RooChiSquarePdf | The PDF of the Chi Square distribution for n degrees of freedom |
| RooDstD0BG | Special p.d.f shape that can be used to model the background of D*-D0 mass difference distributions |
| RooEfficiency | RooEfficiency is a PDF helper class to fit efficiencies parameterized by a supplied function F |
| RooEffProd | |
| RooExponential | Exponential p.d.f |
| RooExtendedTerm | 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 |
| RooExtendPdf | |
| RooFunctor1DPdfBinding | |
| RooFunctorPdfBinding | |
| RooGamma | |
| RooGaussian | Plain Gaussian p.d.f |
| RooGenericPdf | 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 |
| RooHistConstraint | |
| RooHistPdf | RooHistPdf implements a probablity density function sampled from a multidimensional histogram |
| RooJeffreysPrior | RooJeffreysPrior |
| RooKeysPdf | 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 |
| RooLandau | Landau Distribution p.d.f |
| RooLognormal | RooFit Lognormal PDF |
| RooMomentMorph | |
| RooMultiVarGaussian | Multivariate Gaussian p.d.f |
| RooNDKeysPdf | Generic N-dimensional implementation of a kernel estimation p.d.f |
| RooNonCentralChiSquare | The PDF of the Non-Central Chi Square distribution for n degrees of freedom |
| RooNovosibirsk | RooNovosibirsk implements the Novosibirsk function |
| RooNumConvPdf | Numeric 1-dimensional convolution operator PDF |
| RooParametricStepFunction | |
| RooPoisson | Poisson pdf |
| RooPolynomial | 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 freedome less than polynomial functions due to the normalization condition |
| RooProdPdf | RooProdPdf is an efficient implementation of a product of PDFs of the form |
| RooProjectedPdf | Class RooProjectedPdf is a RooAbsPdf implementation that represent a projection of a given input p.d.f and the object returned by RooAbsPdf::createProjection |
| RooRealSumPdf | |
| RooResolutionModel | |
| RooAddModel | |
| RooGaussModel | Class RooGaussModel implements a RooResolutionModel that models a Gaussian distribution |
| RooGExpModel | Class RooGExpModel is a RooResolutionModel implementation that models a resolution function that is the convolution of a Gaussian with a one-sided exponential |
| RooTruthModel | 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 |
| RooSimultaneous | RooSimultaneous facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset |
| RooStats::HistFactory::HistFactorySimultaneous | |
| RooTFnPdfBinding | |
| RooUniform | Flat p.d.f |
| RooVoigtian | RooVoigtian is an efficient implementation of the convolution of a Breit-Wigner with a Gaussian, making use of the complex error function |
| RooAbsRealLValue | 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 |
| RooAbsTestStatistic | RooAbsTestStatistic is the abstract base class for all test statistics |
| RooAbsOptTestStatistic | RooAbsOptTestStatistic is the abstract base class for test statistics objects that evaluate a function or PDF at each point of a given dataset |
| RooChi2Var | |
| RooDataWeightedAverage | Class RooDataWeightedAverage calculate a weighted average of a function or p.d.f given a dataset with observable values, i.e |
| RooNLLVar | Class RooNLLVar implements a a -log(likelihood) calculation from a dataset and a PDF |
| RooXYChi2Var | |
| RooAddition | 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 |
| RooCFunction1Binding< 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 |
| RooCFunction2Binding< 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 |
| RooCFunction3Binding< 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 |
| RooCFunction4Binding< 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 |
| RooChangeTracker | RooChangeTracker is a meta object that tracks value changes in a given set of RooAbsArgs by registering itself as value client of these objects |
| RooConstraintSum | RooConstraintSum calculates the sum of the -(log) likelihoods of a set of RooAbsPfs that represent constraint functions |
| RooConstVar | RooConstVar represent a constant real-valued object |
| RooConvCoefVar | 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 |
| RooDerivative | RooDerivative represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class |
| RooExtendedBinding | |
| RooFormulaVar | |
| RooFracRemainder | RooFracRemainder calculates the remainder fraction of a sum of RooAbsReal fraction, i.e (1 - sum_i a_i) |
| RooFunctor1DBinding | 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 |
| RooFunctorBinding | 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 |
| RooGenProdProj | RooGenProdProj is an auxiliary class for RooProdPdf that calculates a general normalized projection of a product of non-factorizing PDFs, e.g |
| RooHistFunc | RooHistFunc implements a real-valued function sampled from a multidimensional histogram |
| RooLegendre | |
| RooSpHarmonic | 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) \]
|
| RooMultiBinomial | RooMultiBinomial is an efficiency function which makes all combinations of efficiencies given as input different effiency functions for different categories |
| RooNumConvolution | Numeric 1-dimensional convolution operator PDF |
| RooParamHistFunc | |
| RooPolyVar | 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 |
| RooProduct | RooProduct a RooAbsReal implementation that represent the product of a given set of other RooAbsReal objects |
| RooProfileLL | Class RooProfileLL implements the profile likelihood estimator for a given likelihood and set of parameters of interest |
| RooPullVar | Class RooPullVar represents the pull of measurement w.r.t to true value using the measurement value and its error |
| RooRangeBoolean | RooRangeBoolean |
| RooRealIntegral | 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 |
| RooRealMPFE | RooRealMPFE is the multi-processor front-end for parallel calculation of RooAbsReal objects |
| RooRecursiveFraction | 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) |
| RooStats::Heaviside | Represents the Heaviside function |
| RooStats::HistFactory::FlexibleInterpVar | |
| RooStats::HistFactory::LinInterpVar | |
| RooStats::HistFactory::RooBarlowBeestonLL | |
| RooStepFunction | |
| RooTFnBinding | |
| RooAbsString | RooAbsString is the common abstract base class for objects that represent a string value |
| RooStringVar | RooStringVar implements a string values RooAbsArg |
| RooAbsBinning | RooAbsBinning is the abstract base class for RooRealVar binning definitions This class defines the interface to retrieve bin boundaries, ranges etc |
| RooBinning | 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 |
| RooLinTransBinning | RooLinTransBinning is a special binning implementation for RooLinearVar that transforms the binning of the RooLinearVar input variable in the same way that RooLinearVar does |
| RooParamBinning | Class RooParamBinning is an implementation of RooAbsBinning that constructs a binning with a range definition that depends on external RooAbsReal objects |
| RooRangeBinning | RooRangeBinning is binning/range definition that only defines a range but no binning |
| RooUniformBinning | RooUniformBinning is an implementation of RooAbsBinning that provides a uniform binning in 'n' bins between the range end points |
| RooAbsCollection | RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects |
| RooArgList | |
| RooListProxy | RooListProxy is the concrete proxy for RooArgList objects |
| RooArgSet | |
| RooSetProxy | RooSetProxy is the concrete proxy for RooArgSet objects |
| RooAbsData | RooAbsData is the common abstract base class for binned and unbinned datasets |
| RooDataHist | RooDataSet is a container class to hold N-dimensional binned data |
| RooDataSet | RooDataSet is a container class to hold unbinned data |
| RooTreeData | RooTreeData is the abstract base class for data collection that use a TTree as internal storage mechanism |
| RooAbsDataStore | RooAbsDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism |
| RooCompositeDataStore | RooCompositeDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism |
| RooTreeDataStore | RooTreeDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism |
| RooVectorDataStore | RooVectorDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism |
| RooAbsGenContext | RooAbsGenContext is the abstract base class for generator contexts of RooAbsPdf objects |
| RooAddGenContext | RooAddGenContext is an efficient implementation of the generator context specific for RooAddPdf PDFs |
| RooBinnedGenContext | RooBinnedGenContext is an efficient implementation of the generator context specific for binned pdfs |
| RooConvGenContext | RooConvGenContext is an efficient implementation of the generator context specific for RooAbsAnaConvPdf objects |
| RooEffGenContext | RooEffGenContext is a specialized generator context for p.d.fs represented by class RooEffProd, which are p.d.fs multiplied with an efficiency function |
| RooGenContext | Class RooGenContext implement a universal generator context for all RooAbsPdf classes that do not have or need a specialized generator context |
| RooProdGenContext | RooProdGenContext is an efficient implementation of the generator context specific for RooProdPdf PDFs |
| RooSimGenContext | RooSimGenContext is an efficient implementation of the generator context specific for RooSimultaneous PDFs when generating more than one of the component pdfs |
| RooSimSplitGenContext | RooSimSplitGenContext is an efficient implementation of the generator context specific for RooSimultaneous PDFs when generating more than one of the component pdfs |
| RooAbsNumGenerator | Class RooAbsNumGenerator is the abstract base class for MC event generator implementations like RooAcceptReject and RooFoam |
| RooAcceptReject | Class RooAcceptReject is a generic toy monte carlo generator implement the accept/reject sampling technique on any positively valued function |
| RooFoamGenerator | Class RooFoamGenerator is a generic toy monte carlo generator that implement the TFOAM sampling technique on any positively valued function |
| RooCatType | RooCatType is an auxilary class for RooAbsCategory and defines a a single category state |
| RooClassFactory | RooClassFactory is a clase like TTree::MakeClass() that generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names |
| RooCustomizer | |
| RooFactoryWSTool | RooFactoryWSTool is a clase like TTree::MakeClass() that generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names |
| RooFitResult | |
| RooFormula | RooFormula an implementation of ROOT::v5::TFormula that interfaces it to RooAbsArg value objects |
| RooGrid | RooGrid is a utility class for RooMCIntegrator which implements an adaptive multi-dimensional Monte Carlo numerical integration, following the VEGAS algorithm |
| RooNameSet | RooNameSet is a utility class that stores the names the objects in a RooArget |
| RooNumGenConfig | RooNumGenConfig holds the configuration parameters of the various numeric integrators used by RooRealIntegral |
| RooNumIntConfig | RooNumIntConfig holds the configuration parameters of the various numeric integrators used by RooRealIntegral |
| RooPlot | A RooPlot is a plot frame and a container for graphics objects within that frame |
| RooPlotable | 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 |
| RooCurve | A RooCurve is a one-dimensional graphical representation of a real-valued function |
| RooEllipse | A RooEllipse is a two-dimensional ellipse that can be used to represent an error contour |
| RooHist | A RooHist is a graphical representation of binned data based on the TGraphAsymmErrors class |
| RooSimWSTool | |
| RooStats::LikelihoodIntervalPlot | This class provides simple and straightforward utilities to plot a LikelihoodInterval object |
| RooStats::MCMCIntervalPlot | This class provides simple and straightforward utilities to plot a MCMCInterval object |
| RooStats::SamplingDistPlot | This class provides simple and straightforward utilities to plot SamplingDistribution objects |
| RooStats::HypoTestPlot | This class provides the plots for the result of a study performed with any of the HypoTestCalculatorGeneric (e.g |
| RooTable | RooTable is the abstract interface for table objects |
| Roo1DTable | Roo1DTable implements a one-dimensional table |
| RooQuasiRandomGenerator | 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 |
| RooRandom | This class provides a static interface for generating random numbers |
| RooRealConstant | RooRealConstant provides static functions to create and keep track of RooRealVar constants |
| RooSentinel | RooSentinel is a special purposes singleton class that terminates all other RooFit singleton services when the process exists |
| RooStreamParser | |
| ROOT::Math::RootFinder | User Class to find the Root of one dimensional functions |
| RooTMathReg | |
| RooTrace | Class RooTrace controls the memory tracing hooks in all RooFit objects |
| ROOT::Math::Rotation3D | Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix |
| ROOT::Math::RotationTraits< C > | |
| ROOT::Math::RotationTraits< AxisAngle > | |
| ROOT::Math::RotationTraits< EulerAngles > | |
| ROOT::Math::RotationTraits< LorentzRotation > | |
| ROOT::Math::RotationTraits< Quaternion > | |
| ROOT::Math::RotationTraits< Rotation3D > | |
| ROOT::Math::RotationTraits< RotationX > | |
| ROOT::Math::RotationTraits< RotationY > | |
| ROOT::Math::RotationTraits< RotationZ > | |
| ROOT::Math::RotationX | Rotation class representing a 3D rotation about the X axis by the angle of rotation |
| ROOT::Math::RotationY | Rotation class representing a 3D rotation about the Y axis by the angle of rotation |
| ROOT::Math::RotationZ | Rotation class representing a 3D rotation about the Z axis by the angle of rotation |
| ROOT::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 new Y' axis, followed by a third rotation of an angle psi (roll) about the final X'' axis |
| ROOT::Math::RowOffsets< D > | Static structure to keep the conversion from (i,j) to offsets in the storage data for a symmetric matrix |
| rr_fcn_info | |
| rsa_KEY | |
| rsa_KEY_export | |
| rsa_NUMBER | |
| ROOT::Internal::RStl | |
| TMVA::Rule | |
| TMVA::RuleCut | |
| TMVA::RuleEnsemble | |
| TMVA::RuleFit | |
| TMVA::RuleFitAPI | |
| TMVA::RuleFitParams | |
| RooStats::HistFactory::Sample | |
| ROOT::Vc::Mem::ScaleForBlend< Dst > | |
| ROOT::Vc::AVX::ScatterHelper< T > | |
| ROOT::MacOSX::Util::ScopedArray< T > | |
| Memstat::SCustomDigest | |
| ROOT::Math::SDeterminant< n, idim > | Dsfact |
| Segment_t | |
| SelectionRules | The class representing the collection of selection rules |
| ROOT::Meta::Selection::SelectNoInstance | Used to avoid to select all instances of a template |
| TMVA::SeparationBase | |
| TMVA::CrossEntropy | |
| TMVA::GiniIndex | |
| TMVA::GiniIndexWithLaplace | |
| TMVA::MisClassificationError | |
| TMVA::SdivSqrtSplusB | |
| XrdClientConn::SessionIDInfo | |
| SetWindowAttributes_t | |
| ROOT::Detail::TCollectionProxyInfo::SfinaeHelper | |
| ROOT::Vc::sfloat | |
| RooStats::HistFactory::ShapeFactor | |
| RooStats::HistFactory::EstimateSummary::ShapeSys | |
| RooStats::HistFactory::ShapeSys | |
| TString::ShortStr_t | |
| SHtmlExtensions_t | |
| SHtmlIndex_t | |
| SHtmlMargin_t | |
| SHtmlStyle_t | |
| SHtmlStyleStack_t | |
| SHtmlTokenMap_t | |
| shutterData_t | |
| ROOT::Minuit2::SimplexParameters | Class describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process |
| TMVA::SimulatedAnnealing | |
| ROOT::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 |
| ROOT::Math::SInverter< T, n, idim > | Dsinv |
| TEveCaloData::SliceInfo_t | |
| ROOT::Math::SMatrix< T, D1, D2, R > | SMatrix: a generic fixed size D1 x D2 Matrix class |
| ROOT::Math::SMatrix< double, 5, 5, ROOT::Math::MatRepStd< double, 5, 5 > > | |
| ROOT::Math::SMatrix< double, N_CITIES, N_CITIES, MatRepSym< double, N_CITIES > > | |
| ROOT::Math::SMatrix< Double32_t, 5, 5, ROOT::Math::MatRepStd< Double32_t, 5, 5 > > | |
| ROOT::Math::SMatrixIdentity | |
| ROOT::Math::SMatrixNoInit | |
| ROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow | |
| ROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow_const | |
| Roo2DMomentMorphFunction::SorterL2H | |
| RooNDKeysPdf::SorterTV_L2H | Sorter function |
| ROOT::Vc::AVX::SortHelper< T > | |
| ROOT::Vc::SSE::SortHelper< VectorType, Size > | |
| ROOT::Vc::SSE::SortHelper< M256, Size > | |
| SQLite3_Stmt_t | |
| ROOT::Math::Sqr< T > | Unary Square Operation Class |
| ROOT::Math::Sqrt< T > | Unary Square Root Operation Class |
| ROOT::Minuit2::SqrtLowParameterTransformation | Transformation from external to internal Parameter based on sqrt(1 + x**2) |
| ROOT::Minuit2::SqrtUpParameterTransformation | Transformation from external to internal Parameter based on sqrt(1 + x**2) |
| ROOT::Vc::AVX::SseVectorType< T > | |
| ROOT::Vc::AVX::SseVectorType< m128 > | |
| ROOT::Vc::AVX::SseVectorType< m128d > | |
| ROOT::Vc::AVX::SseVectorType< m128i > | |
| ROOT::Vc::AVX::SseVectorType< m256 > | |
| ROOT::Vc::AVX::SseVectorType< m256d > | |
| ROOT::Vc::AVX::SseVectorType< m256i > | |
| ROOT::Minuit2::StackAllocator | StackAllocator controls the memory allocation/deallocation of Minuit |
| ROOT::Minuit2::StackAllocatorHolder | |
| ROOT::Minuit2::StackError | |
| ROOT::Minuit2::StackOverflow | Define stack allocator symbol |
| TMVA::StatDialogBDT | |
| TMVA::StatDialogBDTReg | |
| TMVA::StatDialogMVAEffs | |
| RooStats::HistFactory::StatError | |
| RooStats::HistFactory::StatErrorConfig | |
| ROOT::Vc::AVX::StaticCastHelper< From, To > | |
| ROOT::Vc::SSE::StaticCastHelper< From, To > | |
| ROOT::Vc::AVX::StaticCastHelper< double, double > | |
| ROOT::Vc::SSE::StaticCastHelper< double, double > | |
| ROOT::Vc::AVX::StaticCastHelper< double, float > | |
| ROOT::Vc::SSE::StaticCastHelper< double, float > | |
| ROOT::Vc::AVX::StaticCastHelper< double, int > | |
| ROOT::Vc::SSE::StaticCastHelper< double, int > | |
| ROOT::Vc::AVX::StaticCastHelper< double, unsigned int > | |
| ROOT::Vc::SSE::StaticCastHelper< double, unsigned int > | |
| ROOT::Vc::AVX::StaticCastHelper< float, double > | |
| ROOT::Vc::SSE::StaticCastHelper< float, double > | |
| ROOT::Vc::AVX::StaticCastHelper< float, float > | |
| ROOT::Vc::SSE::StaticCastHelper< float, float > | |
| ROOT::Vc::AVX::StaticCastHelper< float, int > | |
| ROOT::Vc::SSE::StaticCastHelper< float, int > | |
| ROOT::Vc::AVX::StaticCastHelper< float, short > | |
| ROOT::Vc::SSE::StaticCastHelper< float, short > | |
| ROOT::Vc::AVX::StaticCastHelper< float, unsigned int > | |
| ROOT::Vc::SSE::StaticCastHelper< float, unsigned int > | |
| ROOT::Vc::AVX::StaticCastHelper< float, unsigned short > | |
| ROOT::Vc::SSE::StaticCastHelper< float, unsigned short > | |
| ROOT::Vc::SSE::StaticCastHelper< float8, short > | |
| ROOT::Vc::SSE::StaticCastHelper< float8, unsigned short > | |
| ROOT::Vc::AVX::StaticCastHelper< int, double > | |
| ROOT::Vc::SSE::StaticCastHelper< int, double > | |
| ROOT::Vc::AVX::StaticCastHelper< int, float > | |
| ROOT::Vc::SSE::StaticCastHelper< int, float > | |
| ROOT::Vc::AVX::StaticCastHelper< int, int > | |
| ROOT::Vc::SSE::StaticCastHelper< int, int > | |
| ROOT::Vc::AVX::StaticCastHelper< int, short > | |
| ROOT::Vc::AVX::StaticCastHelper< int, unsigned int > | |
| ROOT::Vc::SSE::StaticCastHelper< int, unsigned int > | |
| ROOT::Vc::AVX::StaticCastHelper< sfloat, short > | |
| ROOT::Vc::AVX::StaticCastHelper< sfloat, unsigned short > | |
| ROOT::Vc::AVX::StaticCastHelper< short, float > | |
| ROOT::Vc::SSE::StaticCastHelper< short, float8 > | |
| ROOT::Vc::AVX::StaticCastHelper< short, int > | |
| ROOT::Vc::AVX::StaticCastHelper< short, sfloat > | |
| ROOT::Vc::SSE::StaticCastHelper< short, short > | |
| ROOT::Vc::AVX::StaticCastHelper< short, short > | |
| ROOT::Vc::AVX::StaticCastHelper< short, unsigned short > | |
| ROOT::Vc::SSE::StaticCastHelper< short, unsigned short > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned int, double > | |
| ROOT::Vc::SSE::StaticCastHelper< unsigned int, double > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned int, float > | |
| ROOT::Vc::SSE::StaticCastHelper< unsigned int, float > | |
| ROOT::Vc::SSE::StaticCastHelper< unsigned int, int > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned int, int > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned int, unsigned int > | |
| ROOT::Vc::SSE::StaticCastHelper< unsigned int, unsigned int > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned int, unsigned short > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned short, float > | |
| ROOT::Vc::SSE::StaticCastHelper< unsigned short, float8 > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned short, sfloat > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned short, short > | |
| ROOT::Vc::SSE::StaticCastHelper< unsigned short, short > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned short, unsigned int > | |
| ROOT::Vc::AVX::StaticCastHelper< unsigned short, unsigned short > | |
| ROOT::Vc::SSE::StaticCastHelper< unsigned short, unsigned short > | |
| ROOT::Math::StdEngine< Generator > | Wrapper class for std::random generator to be included in ROOT |
| ROOT::Math::StdRandomEngine | |
| streambuf | |
| TGTextViewStreamBuf | |
| RooMsgService::StreamConfig | |
| TGenCollectionProxy::StreamHelper | Helper class to facilitate I/O |
| TGDMLWrite::StructLst | |
| TGL5DPainter::Surf_t | |
| TInterpreter::SuspendAutoParsing | |
| ROOT::Math::SVector< T, D > | SVector: a generic fixed size Vector class |
| TMVA::SVEvent | |
| TMVA::SVKernelFunction | |
| TMVA::SVKernelMatrix | |
| TMVA::SVWorkingSet | |
| ROOT::Minuit2::sym | |
| SysInfo_t | |
| TGTableLayout::TableData_t | |
| tableDescriptor_st | |
| TMVA::TActivation | |
| TMVA::TActivationIdentity | |
| TMVA::TActivationRadial | |
| TMVA::TActivationReLU | |
| TMVA::TActivationSigmoid | |
| TMVA::TActivationTanh | |
| TMVA::TActivationChooser | |
| TAlienPackage | |
| TApplicationImp | ABC describing GUI independent application implementation protocol |
| TRootApplication | |
| TArcBall | Implements the arc-ball rotation manipulator |
| TArray | Abstract array base class |
| TArrayC | Array of chars or bytes (8 bits per element) |
| TH1C | 1-D histogram with a bype per channel (see TH1 documentation) |
| TH2C | 2-D histogram with a bype per channel (see TH1 documentation) |
| TH3C | 3-D histogram with a bype per channel (see TH1 documentation) |
| TGLTH3Composition | |
| TArrayD | Array of doubles (64 bits per element) |
| TH1D | 1-D histogram with a double per channel (see TH1 documentation)} |
| TProfile | Profile Historam |
| TH2D | 2-D histogram with a double per channel (see TH1 documentation)} |
| TProfile2D | Profile2D histograms are used to display the mean value of Z and its RMS for each cell in X,Y |
| TH3D | 3-D histogram with a double per channel (see TH1 documentation)} |
| TProfile3D | Profile3D histograms are used to display the mean value of T and its RMS for each cell in X,Y,Z |
| TArrayF | Array of floats (32 bits per element) |
| TH1F | 1-D histogram with a float per channel (see TH1 documentation)} |
| TH1K | TH1K class supports the nearest K Neighbours method, widely used in cluster analysis |
| TH2F | 2-D histogram with a float per channel (see TH1 documentation)} |
| TH3F | 3-D histogram with a float per channel (see TH1 documentation)} |
| TArrayI | Array of integers (32 bits per element) |
| TH1I | 1-D histogram with a int per channel (see TH1 documentation)} |
| TH2I | 2-D histogram with a int per channel (see TH1 documentation)} |
| TH3I | 3-D histogram with a int per channel (see TH1 documentation)} |
| TArrayL | Array of longs (32 or 64 bits per element) |
| TArrayL64 | Array of long64s (64 bits per element) |
| TArrayS | Array of shorts (16 bits per element) |
| TH1S | 1-D histogram with a short per channel (see TH1 documentation) |
| TH2S | 2-D histogram with a short per channel (see TH1 documentation) |
| TH3S | 3-D histogram with a short per channel (see TH1 documentation) |
| ROOT::Internal::TArrayType< T, d > | |
| ROOT::Internal::TArrayType< T, 0 > | |
| TASLogHandlerGuard | |
| TAtomicCount | |
| TAtt3D | Use this attribute class when an object should have 3D capabilities |
| TEveArrow | Class used for display of a thick arrow |
| TEveCaloViz | Base class for calorimeter data visualization |
| TEveCalo2D | Visualization of a calorimeter event data in 2D |
| TEveCalo3D | Visualization of a calorimeter event data in 3D |
| TEveCaloLego | Visualization of calorimeter data as eta/phi histogram |
| TEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
| TEveBoxSet | Collection of 3D primitives (fixed-size boxes, boxes of different sizes, or arbitrary sexto-epipeds, cones) |
| TEveQuadSet | Supports various internal formats that result in rendering of a set of planar (lines, rectangles, hexagons with shared normal) objects |
| TEveProjectionAxes | Axes for non-linear projections |
| TEveShape | Abstract base-class for 2D/3D shapes |
| TEveBox | 3D box with arbitrary vertices (cuboid) |
| TEveBoxProjected | Projection of TEveBox |
| TEveGeoShape | 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) |
| TEveGeoShapeProjected | A 3D projected TEveGeoShape |
| TEveJetCone | Draws a jet cone with leading particle is specified in (eta,phi) and cone radius is given |
| TEveJetConeProjected | Projection of TEveJetCone |
| TEvePolygonSetProjected | A set of projected polygons |
| TEveStraightLineSet | Set of straight lines with optional markers along the lines |
| TEveScalableStraightLineSet | Straight-line-set with extra scaling, useful for projectables that need to be scaled in accordance with an external object |
| TEveStraightLineSetProjected | Projected replica of a TEveStraightLineSet |
| TEveText | TEveElement class used for displaying FreeType GL fonts |
| TEveTriangleSet | Made from a list of vertices and a list of triangles (triplets of vertex indices) |
| TGeoOverlap | |
| TGeoVolume | |
| TGeoVolumeAssembly | |
| TGeoVolumeMulti | |
| TH3 | The 3-D histogram classes derived from the 1-D histogram classes |
| TH3C | 3-D histogram with a bype per channel (see TH1 documentation) |
| TH3D | 3-D histogram with a double per channel (see TH1 documentation)} |
| TH3F | 3-D histogram with a float per channel (see TH1 documentation)} |
| TH3I | 3-D histogram with a int per channel (see TH1 documentation)} |
| TH3S | 3-D histogram with a short per channel (see TH1 documentation) |
| TMarker3DBox | A special 3-D marker designed for event display |
| TNode | TNode description |
| TNodeDiv | Description of parameters to divide a 3-D geometry object |
| TParticle | Description of the dynamic properties of a particle |
| TEveMCTrack | |
| TPolyLine3D | A 3-dimensional polyline |
| THelix | THelix has two different constructors |
| TPolyMarker3D | A 3D polymarker |
| TPointSet3D | TPolyMarker3D using TPointSet3DGL for direct OpenGL rendering |
| TEvePointSet | 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) |
| TEveLine | An arbitrary polyline with fixed line and marker attributes |
| TEveLineProjected | Projected copy of a TEveLine |
| TEveTrack | Visual representation of a track |
| TEveTrackProjected | Projected copy of a TEveTrack |
| TEvePointSetProjected | Projected copy of a TEvePointSet |
| TPrimary | Old version of a dynamic particle class created by event generators |
| TShape | This is the base class for all geometry shapes |
| TBRIK | A box with faces perpendicular to the axes |
| TGTRA | A general twisted trapezoid |
| TPARA | A parallelepiped |
| TTRAP | A general trapezoid |
| TTRD1 | A trapezoid with the x dimension varying along z |
| TTRD2 | A trapezoid with both x and y dimensions varying along z |
| TPCON | A polycone |
| TPGON | A polygon |
| TPolyLineShape | |
| TSPHE | A Sphere |
| TTUBE | A tube |
| TCONE | A conical tube |
| TELTU | A cylinder with an elliptical section |
| THYPE | An hyperboloid (not implemented) |
| TTUBS | A segment of a tube |
| TCONS | A segment of a conical tube |
| TCTUB | A cut tube with 11 parameters |
| TXTRU | A poly-extrusion |
| TVolume | |
| TVolumeView | |
| TAttAxis | Manages histogram axis attributes |
| TAxis | Class to manage histogram axis |
| TEveProjectionAxes | Axes for non-linear projections |
| TAttBBox | Helper for management of bounding-box information |
| TEveArrow | Class used for display of a thick arrow |
| TEveCaloViz | Base class for calorimeter data visualization |
| TEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
| TEveProjectionAxes | Axes for non-linear projections |
| TEveProjectionManager | Manager class for steering of projections and managing projected objects |
| TEveShape | Abstract base-class for 2D/3D shapes |
| TEveStraightLineSet | Set of straight lines with optional markers along the lines |
| TEveText | TEveElement class used for displaying FreeType GL fonts |
| TEveTriangleSet | Made from a list of vertices and a list of triangles (triplets of vertex indices) |
| TPointSet3D | TPolyMarker3D using TPointSet3DGL for direct OpenGL rendering |
| TAttBBox2D | Abstract base class for elements drawn in the editor |
| TBox | Create a Box |
| TPave | A TBox with a bordersize and a shadow option |
| TLegend | This class displays a legend box (TPaveText) containing several legend entries |
| TPaletteAxis | The palette painting class |
| TPaveLabel | A Pave (see TPave) with a text centered in the Pave |
| TPaveClass | A TPaveLabel specialized to process classes inside a TClassTree |
| TPaveText | A Pave (see TPave) with text, lines or/and boxes inside |
| TDiamond | Draw a Diamond |
| TPaveStats | The histogram statistics painter class |
| TPavesText | A PaveText (see TPaveText) with several stacked paves |
| TWbox | A TBox with a bordersize and a bordermode |
| TFrame | Define a Frame |
| TSliderBox | The moving box in a TSlider |
| TCurlyLine | Implements curly or wavy polylines used to draw Feynman diagrams |
| TCurlyArc | Implements curly or wavy arcs used to draw Feynman diagrams |
| TEllipse | Draw Ellipses |
| TArc | Create an Arc |
| TCrown | To draw a Crown |
| TLine | A simple line |
| TArrow | Draw all kinds of Arrows |
| TASPaletteEditor::LimitLine | |
| TGaxis | The axis painter class |
| TMarker | Manages Markers |
| TPad | The most important graphics class in the ROOT system |
| TButton | A TButton object is a user interface object |
| TGroupButton | A specialized TButton used in a group of Buttons |
| TCanvas | The Canvas class |
| TDialogCanvas | A canvas specialized to set attributes |
| TInspectCanvas | Pointer to class of the foreign object |
| TEvePad | This was intended as a TPad wrapper to allow smart updates of groups of pads |
| TSlider | A specialized TPad including a TSliderBox object |
| TText | Base class for several text objects |
| TLatex | To draw Mathematical Formula |
| TLink | Special TText object used to show hyperlinks |
| TMathText | To draw TeX Mathematical Formula |
| TAttCanvas | Manages canvas attributes |
| TAttFill | Fill Area Attributes class |
| ROOT::v5::TF1Data | |
| TArrow | Draw all kinds of Arrows |
| TBox | Create a Box |
| TBranch | A TTree is a list of TBranches |
| TBranchClones | A Branch for the case of an array of clone objects |
| TBranchElement | A Branch for the case of an object |
| TBranchObject | A Branch for the case of an object |
| TBranchRef | A branch containing and managing a TRefTable for TRef autoloading |
| TBranchSTL | A Branch handling STL collection of pointers (vectors, lists, queues, sets and multisets) while storing them in split mode |
| THbookBranch | HBOOK Branch |
| TEfficiency | Class to handle efficiency histograms |
| TEllipse | Draw Ellipses |
| TF1 | 1-Dim function class |
| TF12 | A projection of a TF2 along X or Y |
| TF2 | A 2-Dim function with parameters |
| TF3 | A 3-Dim function with parameters |
| TGeoBatemanSol | |
| TGeoMaterial | |
| TGeoMixture | |
| TGeoOverlap | |
| TGeoVolume | |
| TGraph | A Graph is a graphics object made of two arrays X and Y with npoints each |
| RooCurve | A RooCurve is a one-dimensional graphical representation of a real-valued function |
| RooEllipse | A RooEllipse is a two-dimensional ellipse that can be used to represent an error contour |
| TCutG | Graphical cut class |
| TGraphAsymmErrors | TGraph with assymetric error bars |
| RooHist | A RooHist is a graphical representation of binned data based on the TGraphAsymmErrors class |
| TGraphBentErrors | A TGraphBentErrors is a TGraph with bent, assymetric error bars |
| TGraphErrors | A TGraphErrors is a TGraph with error bars |
| TGraphPolar | To draw a polar graph |
| TGraphQQ | This class allows to draw quantile-quantile plots |
| TGraph2D | Graphics object made of three arrays X, Y and Z with the same number of points each |
| TGraph2DErrors | Graph 2D class with errors |
| TGraphNode | A graph node object which can be added in a TGraphStruct |
| TH1 | The TH1 histogram class |
| TH1C | 1-D histogram with a bype per channel (see TH1 documentation) |
| TH1D | 1-D histogram with a double per channel (see TH1 documentation)} |
| TH1F | 1-D histogram with a float per channel (see TH1 documentation)} |
| TH1I | 1-D histogram with a int per channel (see TH1 documentation)} |
| TH1K | TH1K class supports the nearest K Neighbours method, widely used in cluster analysis |
| TH1S | 1-D histogram with a short per channel (see TH1 documentation) |
| TH2 | Service class for 2-Dim histogram classes |
| TH2C | 2-D histogram with a bype per channel (see TH1 documentation) |
| TH2D | 2-D histogram with a double per channel (see TH1 documentation)} |
| TH2F | 2-D histogram with a float per channel (see TH1 documentation)} |
| TH2I | 2-D histogram with a int per channel (see TH1 documentation)} |
| TH2Poly | 2D Histogram with Polygonal Bins |
| TH2S | 2-D histogram with a short per channel (see TH1 documentation) |
| TH3 | The 3-D histogram classes derived from the 1-D histogram classes |
| TLegendEntry | Storage class for one entry of a TLegend |
| TMarker3DBox | A special 3-D marker designed for event display |
| TMaterial | Manages a detector material |
| TMixture | Manages a detector mixture |
| TMathText | To draw TeX Mathematical Formula |
| TNode | TNode description |
| TPainter3dAlgorithms | The Legos and Surfaces painter class |
| TParallelCoordVar | TParallelCoord axes |
| TPieSlice | A slice of a piechart, see the TPie class |
| TPolyLine | Defined by an array on N points in a 2-D space |
| TCurlyLine | Implements curly or wavy polylines used to draw Feynman diagrams |
| TShape | This is the base class for all geometry shapes |
| TSpider | Spider class |
| TSpline | Base class for spline implementation containing the Draw/Paint methods // |
| TMVA::TSpline1 | |
| TMVA::TSpline2 | |
| TSpline3 | |
| TSpline5 | |
| TStyle | TStyle objects may be created to define special styles |
| TTree | A TTree object has a header with a name and a title |
| TChain | A chain is a collection of files containg TTree objects |
| TProofChain | |
| THbookTree | A wrapper class supporting Hbook ntuples (CWN and RWN) |
| TNtuple | A simple TTree restricted to a list of float variables only |
| TNtupleD | A simple TTree restricted to a list of double variables only |
| TTreeSQL | Implement TTree for a SQL backend |
| TVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
| TPad | The most important graphics class in the ROOT system |
| TVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
| TImageDump | Save canvas as an image (GIF, JPEG, PNG, XPM, TIFF etc.) |
| TPDF | Interface to PDF |
| TPostScript | Interface to PostScript |
| TSVG | Interface to SVG |
| TTeXDump | Interface to TeX |
| TVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
| TGCocoa | This class implements TVirtualX interface for MacOS X, using Cocoa and Quartz 2D |
| TGQuartz | This is non-GUI part of TVirtualX interface, implemented for MacOS X, using CoreGraphics (Quartz) |
| TGWin32 | This class is the basic interface to the Win32 graphics system |
| TGWin32VirtualXProxy | |
| TGX11 | This class is the basic interface to the X11 (Xlib) graphics system |
| TGX11TTF | Interface to low level X11 (Xlib) |
| TVolume | |
| TAttImage | TImage attributes |
| TImage | An abstract interface to image processing library |
| TASImage | Image class |
| TAttLine | Line Attributes class |
| ROOT::v5::TF1Data | |
| TBox | Create a Box |
| TEfficiency | Class to handle efficiency histograms |
| TEllipse | Draw Ellipses |
| TEveLine | An arbitrary polyline with fixed line and marker attributes |
| TEveStraightLineSet | Set of straight lines with optional markers along the lines |
| TEveTrackList | A list of tracks supporting change of common attributes and selection based on track parameters |
| TEveTrackListProjected | Specialization of TEveTrackList for holding TEveTrackProjected objects |
| TF1 | 1-Dim function class |
| TGeoBatemanSol | |
| TGeoOverlap | |
| TGeoPhysicalNode | |
| TGeoVolume | |
| TGLAxis | GL Axis |
| TGraph | A Graph is a graphics object made of two arrays X and Y with npoints each |
| TGraph2D | Graphics object made of three arrays X, Y and Z with the same number of points each |
| TGraphEdge | An edge object connecting two nodes which can be added in a TGraphStruct |
| TGraphNode | A graph node object which can be added in a TGraphStruct |
| TGraphPolargram | To draw polar axis |
| TH1 | The TH1 histogram class |
| TLatex | To draw Mathematical Formula |
| TLegendEntry | Storage class for one entry of a TLegend |
| TLine | A simple line |
| TMarker3DBox | A special 3-D marker designed for event display |
| TMCParticle | This class serves as a data storage for description of one particle |
| TNode | TNode description |
| TPainter3dAlgorithms | The Legos and Surfaces painter class |
| TParallelCoordRange | A TParallelCoordRange is a range used for parallel coordinates plots |
| TParallelCoordSelect | A TParallelCoordSelect is a specialised TList to hold TParallelCoordRanges used by TParallelCoord |
| TParallelCoordVar | TParallelCoord axes |
| TParticle | Description of the dynamic properties of a particle |
| TPieSlice | A slice of a piechart, see the TPie class |
| TPolyLine | Defined by an array on N points in a 2-D space |
| TPolyLine3D | A 3-dimensional polyline |
| TPrimary | Old version of a dynamic particle class created by event generators |
| TShape | This is the base class for all geometry shapes |
| TSpider | Spider class |
| TSpline | Base class for spline implementation containing the Draw/Paint methods // |
| TStyle | TStyle objects may be created to define special styles |
| TTree | A TTree object has a header with a name and a title |
| TView | See TView3D |
| TView3D | The 3D view class |
| TVirtualGeoTrack | |
| TGeoTrack | |
| TVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
| TVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
| TVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
| TVolume | |
| TAttMarker | Marker Attributes class |
| ROOT::v5::TF1Data | |
| TEfficiency | Class to handle efficiency histograms |
| TEvePointSetArray | An array of point-sets with each point-set playing a role of a bin in a histogram |
| TEveStraightLineSet | Set of straight lines with optional markers along the lines |
| TEveTrackList | A list of tracks supporting change of common attributes and selection based on track parameters |
| TF1 | 1-Dim function class |
| TGeoBatemanSol | |
| TGraph | A Graph is a graphics object made of two arrays X and Y with npoints each |
| TGraph2D | Graphics object made of three arrays X, Y and Z with the same number of points each |
| TH1 | The TH1 histogram class |
| TLegendEntry | Storage class for one entry of a TLegend |
| TMarker | Manages Markers |
| TPolyLineShape | |
| TPolyMarker | A PolyMarker is defined by an array on N points in a 2-D space |
| TPolyMarker3D | A 3D polymarker |
| TSpline | Base class for spline implementation containing the Draw/Paint methods // |
| TStyle | TStyle objects may be created to define special styles |
| TTree | A TTree object has a header with a name and a title |
| TVirtualGeoTrack | |
| TVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
| TVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
| TAttPad | Manages default Pad attributes |
| TVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
| TAttText | Text Attributes class |
| TButton | A TButton object is a user interface object |
| TDialogCanvas | A canvas specialized to set attributes |
| TGaxis | The axis painter class |
| TGLAxis | GL Axis |
| TGLText | GL Text |
| TGraphNode | A graph node object which can be added in a TGraphStruct |
| TGraphPolargram | To draw polar axis |
| TInspectCanvas | Pointer to class of the foreign object |
| TLegend | This class displays a legend box (TPaveText) containing several legend entries |
| TLegendEntry | Storage class for one entry of a TLegend |
| TPaveLabel | A Pave (see TPave) with a text centered in the Pave |
| TPaveText | A Pave (see TPave) with text, lines or/and boxes inside |
| TPie | Draw a Pie Chart, |
| TStyle | TStyle objects may be created to define special styles |
| TText | Base class for several text objects |
| TVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
| TVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
| TBase64 | This code implements the Base64 encoding and decoding |
| RootCsg::TBaseMesh | |
| ROOT::Detail::TBranchProxy | |
| ROOT::Internal::TArrayCharProxy | |
| ROOT::Internal::TArrayProxy< T > | |
| ROOT::Internal::TClaArrayProxy< T > | |
| ROOT::Internal::TClaImpProxy< T > | |
| ROOT::Internal::TClaProxy | |
| ROOT::Internal::TImpProxy< T > | |
| ROOT::Internal::TStlArrayProxy< T > | |
| ROOT::Internal::TStlImpProxy< T > | |
| ROOT::Internal::TStlProxy | |
| ROOT::Internal::TBranchProxyDirector | |
| ROOT::Internal::TBranchProxyHelper | |
| TBrowserImp | ABC describing GUI independent browser implementation protocol |
| TGFileBrowser | |
| TRootBrowser | |
| TEveBrowser | Specialization of TRootBrowser for Eve |
| TRootBrowserLite | |
| TBtItem | Item stored in inner nodes of a TBtree |
| TBtNode | Abstract base class (ABC) of a TBtree node |
| TBtInnerNode | Inner node of a TBtree |
| TBtLeafNode | Leaf node of a TBtree |
| TBuffer3DTypes | |
| TOracleStatement::TBufferRec | |
| PyROOT::TCallContext | |
| TCanvasImp | ABC describing GUI independent main window (with menubar, scrollbars and a drawing area) |
| TQCanvasImp | |
| TRootCanvas | |
| Rgl::Mc::TCell< V > | |
| Rgl::Mc::TCell< ElementType_t > | |
| TChainIndex::TChainIndexEntry | Holds a description of indices of trees in the chain |
| TCL | |
| ROOT::Internal::TClaObjProxy< T > | |
| TClassRef | TClassRef is used to implement a permanent reference to a TClass object |
| TClassStreamer | |
| TCollectionClassStreamer | Class streamer object to implement TClassStreamer functionality for I/O emulation |
| TProofPlayer::TCleanup | |
| TClingBaseClassInfo | Emulation of the CINT BaseClassInfo class |
| TClingCallFunc | Emulation of the CINT CallFunc class |
| TClingClassInfo | Emulation of the CINT ClassInfo class |
| TClingDataMemberInfo | Emulation of the CINT DataMemberInfo class |
| TClingMethodArgInfo | Emulation of the CINT MethodInfo class |
| TClingMethodInfo | Emulation of the CINT MethodInfo class |
| TClingTypedefInfo | Emulation of the CINT TypedefInfo class |
| TClingTypeInfo | Emulation of the CINT TypeInfo class |
| TTree::TClusterIterator | Helper class to iterate over cluster of baskets |
| TCollectionProxyFactory | TCollectionProxyFactory Interface to collection proxy and streamer generator |
| ROOT::Detail::TCollectionProxyInfo | |
| TCollectionStreamer | Class streamer object to implement TClassStreamer functionality for I/O emulation |
| TCollectionClassStreamer | Class streamer object to implement TClassStreamer functionality for I/O emulation |
| TCollectionMemberStreamer | Class streamer object to implement TMemberStreamer functionality for I/O emulation |
| TGLUtil::TColorLocker | |
| TStreamerInfo::TCompInfo | |
| TComplex | |
| TStreamerInfoActions::TConfiguration | Base class of the Configurations |
| TDirectory::TContext | |
| TContextMenuImp | This class provides an interface to GUI independent context sensitive popup menus |
| TRootContextMenu | |
| TControlBarImp | ABC describing GUI independent control bar |
| TRootControlBar | |
| PyROOT::TConverter | |
| PyROOT::TCStringConverter | |
| PyROOT::TNonConstCStringConverter | |
| PyROOT::TNonConstUCStringConverter | |
| PyROOT::TNotImplementedConverter | |
| PyROOT::TRefCppObjectConverter | |
| PyROOT::TSmartPtrCppObjectConverter | |
| PyROOT::TSTLIteratorConverter | |
| PyROOT::TVoidArrayConverter | |
| PyROOT::TCppObjectConverter | |
| PyROOT::TCppObjectArrayConverter | |
| PyROOT::TCppObjectPtrConverter< ISREFERENCE > | |
| PyROOT::TStrictCppObjectConverter | |
| PyROOT::TValueCppObjectConverter | |
| PyROOT::TLongLongArrayConverter | |
| PyROOT::TVoidConverter | |
| PyROOT::TVoidPtrPtrConverter | |
| PyROOT::TVoidPtrRefConverter | |
| TCreatePrimitives | Creates new primitives |
| ROOT::Math::TDataPoint< K, _val_type > | |
| ROOT::Math::TDataPointN< _val_type > | |
| TDatime | This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130 124559) |
| TDavixFileInternal | |
| TClass::TDeclNameRegistry | |
| TGLUtil::TDrawQualityModifier | |
| TGLUtil::TDrawQualityScaler | |
| TDsKey | |
| TElementActionT< Element > | |
| TElementPosActionT< Element > | |
| cppyy.Template |
|
| template | Small helper to encapsulate whether to return the value pointed to by the iterator or its address |
| template | Small helper to implement the function to create,access and destroy iterators |
| PyROOT::TemplateProxy | Template proxy object to return functions and methods |
| ROOT::Math::TensorMulOp< Vector1, Vector2 > | Class for Tensor Multiplication (outer product) of two vectors giving a matrix |
| Rgl::Pad::Tesselator | |
| test.test | |
| RooStats::TestStatistic | TestStatistic is an interface class to provide a facility for construction test statistics distributions to the NeymanConstruction class |
| RooStats::DebuggingTestStat | |
| RooStats::MaxLikelihoodEstimateTestStat | MaxLikelihoodEstimateTestStat: TestStatistic that returns maximum likelihood estimate of a specified parameter |
| RooStats::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 |
| RooStats::NumEventsTestStat | NumEventsTestStat is a simple implementation of the TestStatistic interface used for simple number counting |
| RooStats::ProfileLikelihoodTestStat | ProfileLikelihoodTestStat is an implementation of the TestStatistic interface that calculates the profile likelihood ratio at a particular parameter point given a dataset |
| RooStats::RatioOfProfiledLikelihoodsTestStat | TestStatistic that returns the ratio of profiled likelihoods |
| RooStats::SimpleLikelihoodRatioTestStat | TestStatistic class that returns -log(L[null] / L[alt]) where L is the likelihood |
| RooStats::TestStatSampler | TestStatSampler is an interface class for a tools which produce RooStats SamplingDistributions |
| RooStats::DebuggingSampler | |
| RooStats::ToyMCSampler | ToyMCSampler is an implementation of the TestStatSampler interface |
| RooStats::ToyMCImportanceSampler | ToyMCImportanceSampler is an extension of the ToyMCSampler for Importance Sampling |
| TEveChunkManager | Vector-like container with chunked memory allocation |
| TEveChunkVector< T > | |
| TEveElement | Base class for TEveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management |
| TEveArrow | Class used for display of a thick arrow |
| TEveCaloData | A central manager for calorimeter event data |
| TEveCaloDataHist | A central manager for calorimeter data of an event written in TH2F |
| TEveCaloDataVec | Calo data for universal cell geometry |
| TEveCaloViz | Base class for calorimeter data visualization |
| TEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
| TEveElementList | A list of TEveElements |
| TEveCompound | Description of TEveCompound |
| TEveCompoundProjected | Description of TEveCompoundProjected |
| TEveElementListProjected | A projected element list – required for proper propagation of render state to projected views |
| TEveEventManager | Base class for event management and navigation |
| TEvePlot3D | Description of TEvePlot3D |
| TEveProjectionManager | Manager class for steering of projections and managing projected objects |
| TEveScene | Eve representation of TGLScene |
| TEveSceneList | List of Scenes providing common operations on TEveScene collections |
| TEveSelection | Make sure there is a SINGLE running TEveSelection for each selection type (select/highlight) |
| TEveShape | Abstract base-class for 2D/3D shapes |
| TEveTrackList | A list of tracks supporting change of common attributes and selection based on track parameters |
| TEveTrackPropagator | Holding structure for a number of track rendering parameters |
| TEveTriangleSet | Made from a list of vertices and a list of triangles (triplets of vertex indices) |
| TEveViewerList | List of Viewers providing common operations on TEveViewer collections |
| TEveWindow | Abstract base-class for representing eve-windows |
| TEveWindowFrame | Encapsulates TGFrame into an eve-window |
| TEveViewer | Eve representation of TGLViewer |
| TEveWindowPack | Encapsulates TGPack into an eve-window |
| TEveWindowSlot | Description of TEveWindowSlot |
| TEveWindowTab | Encapsulates TGTab into an eve-window |
| TEveWindowManager | Manager for EVE windows |
| TEveElementObjectPtr | TEveElement with external TObject as a holder of visualization data |
| TEveGeoNode | Wrapper for TGeoNode that allows it to be shown in GUI and controlled as a TEveElement |
| TEveGeoTopNode | A wrapper over a TGeoNode, possibly displaced with a global trasformation stored in TEveElement |
| TEveParamList | Collection of named parameters |
| TEvePointSet | 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) |
| TEvePointSetArray | An array of point-sets with each point-set playing a role of a bin in a histogram |
| TEveProjectionAxes | Axes for non-linear projections |
| TEveSceneInfo | TEveUtil representation of TGLSceneInfo |
| TEveStraightLineSet | Set of straight lines with optional markers along the lines |
| TEveText | TEveElement class used for displaying FreeType GL fonts |
| TEveFrameBoxGL | A class encapsulating GL rendering of TEveFrameBox via a static member function |
| TEveGeoManagerHolder | Exception safe wrapper for setting gGeoManager |
| TEveElement::TEveListTreeInfo | Structure holding information about TGListTree and TGListTreeItem that represents given TEveElement |
| TEveMagField | Abstract base-class for interfacing to magnetic field needed by the TEveTrackPropagator |
| TEveMagFieldConst | Implements constant magnetic field, given by a vector fB |
| TEveMagFieldDuo | Implements constant magnetic filed that switches on given axial radius fR2 from vector fBIn to fBOut |
| TEveManager | Central application manager for Eve |
| TEvePadHolder | Exception safe wrapper for setting gPad |
| TEvePathMarkT< TT > | Special-point on track: |
| TEvePointSelectorConsumer | TEvePointSelectorConsumer is a virtual base for classes that can be filled from TTree data via the TEvePointSelector class |
| TEvePointSet | 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) |
| TEvePointSetArray | An array of point-sets with each point-set playing a role of a bin in a histogram |
| TEveProjectable | Abstract base-class for non-linear projectable objects |
| TEveCaloViz | Base class for calorimeter data visualization |
| TEveElementList | A list of TEveElements |
| TEvePointSet | 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) |
| TEveStraightLineSet | Set of straight lines with optional markers along the lines |
| TEveProjected | Abstract base class for classes that hold results of a non-linear projection transformation |
| TEveBoxProjected | Projection of TEveBox |
| TEveCalo2D | Visualization of a calorimeter event data in 2D |
| TEveCompoundProjected | Description of TEveCompoundProjected |
| TEveElementListProjected | A projected element list – required for proper propagation of render state to projected views |
| TEveGeoShapeProjected | A 3D projected TEveGeoShape |
| TEveJetConeProjected | Projection of TEveJetCone |
| TEveLineProjected | Projected copy of a TEveLine |
| TEvePointSetProjected | Projected copy of a TEvePointSet |
| TEvePolygonSetProjected | A set of projected polygons |
| TEveStraightLineSetProjected | Projected replica of a TEveStraightLineSet |
| TEveTrackListProjected | Specialization of TEveTrackList for holding TEveTrackProjected objects |
| TEveTrackProjected | Projected copy of a TEveTrack |
| TEveProjection | Base-class for non-linear projections |
| TEve3DProjection | 3D scaling projection |
| TEveRhoZProjection | Transformation from 3D to 2D |
| TEveRPhiProjection | XY projection with distortion around given center |
| TEveRefCnt | Base-class for reference-counted objects |
| TEveRefBackPtr | Base-class for reference-counted objects with reverse references to TEveElement objects |
| TEveFrameBox | Description of a 2D or 3D frame that can be used to visually group a set of objects |
| TEveTrackPropagator | Holding structure for a number of track rendering parameters |
| TEveRGBAPalette | A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes |
| TEveSecondarySelectable | Semi-abstract interface for classes supporting secondary-selection |
| TEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
| TEveUtil | Standard utility functions for Eve |
| TEveVector2T< TT > | Minimal, templated two-vector |
| TEveVectorT< TT > | Minimal, templated three-vector |
| TEveVector4T< TT > | Minimal, templated four-vector |
| TEveVectorT< Double_t > | |
| TEveVectorT< Float_t > | |
| PyROOT::TExecutor | |
| PyROOT::TCppObjectBySmartPtrExecutor | |
| PyROOT::TCppObjectBySmartPtrPtrExecutor | |
| PyROOT::TCppObjectExecutor | |
| PyROOT::TCppObjectArrayExecutor | |
| PyROOT::TCppObjectByValueExecutor | |
| PyROOT::TCppObjectPtrPtrExecutor | |
| PyROOT::TCppObjectPtrRefExecutor | |
| PyROOT::TRefExecutor | |
| PyROOT::TCppObjectBySmartPtrRefExecutor | |
| PyROOT::TCppObjectRefExecutor | |
| TExMapIter | |
| ROOT::Quartz::TextLine | |
| TLatex::TextSpec_t | TLatex helper struct holding the attributes of a piece of text |
| ROOT::Internal::TF1Builder< Func > | Internal class used by TF1 for defining template specialization for different TF1 constructors |
| ROOT::Internal::TF1Builder< const char * > | TF1 building from a string used to build a TFormula based on a lambda function |
| TF1Convolution | Class wrapping convolution of two functions |
| TF1NormSum | Class adding two functions: c1*f1+c2*f2 |
| TF1Parameters | TF1 Parameters class |
| TFileMergeInfo | |
| TFitResultPtr | Provides an indirection to the TFitResult class and with a semantics identical to a TFitResult pointer, i.e |
| TFormulaFunction | Helper class for TFormula |
| TFormulaParamOrder | Functor defining the parameter order |
| TFormulaVariable | Another helper class for TFormula |
| TTree::TFriendLock | Helper class to prevent infinite recursion in the usage of TTree Friends |
| ROOT::Internal::TFriendProxy | |
| TFUMILI | |
| TGDimension | |
| TGDMAssignmentHelper< T > | |
| ROOT::TGenericClassInfo | |
| TGenericCollectionIterator | |
| TGenericCollectionIterator::RegularIterator | |
| TGenericCollectionIterator::VectorIterator | |
| TGeoAtt | |
| TGeoNode | |
| TGeoNodeMatrix | |
| TGeoNodeOffset | |
| TGeoVolume | |
| TVirtualGeoTrack | |
| TGeoElemIter | |
| TGeoIterator | |
| TGeoRCPtr< T > | |
| TGeoStateInfo | |
| TGeoToOCC | |
| TGFileInfo | |
| TGInsets | |
| TGLAxisPainter | |
| TGLAxisPainterBox | Utility class to paint axis in GL |
| TGLBoundingBox | Concrete class describing an orientated (free) or axis aligned box of 8 vertices |
| TGLBoxCut | Used by plot-painters to determine the area of the plot that is cut away |
| TGLCapabilityEnabler | |
| TGLCapabilitySwitch | |
| TGLColor | Class encapsulating color information in preferred GL format - an array of four unsigned bytes |
| TGLColorSet | Class encapsulating a set of colors used throughout standard rendering |
| TGLContext | This class encapsulates window-system specific information about a GL-context and alows their proper management in ROOT |
| TGLContextIdentity | Identifier of a shared GL-context |
| TGLContextPrivate | |
| TGLDisableGuard | |
| TGLEnableGuard | |
| TGLFaderHelper | |
| TGLFBO | Frame-buffer object |
| TGLFloatHolder | |
| TGLFont | A wrapper class for FTFont |
| TGLFontManager | A FreeType GL font manager |
| TGLFormat | Encapsulation of format / contents of an OpenGL buffer |
| TGListTreeItem | |
| TEveListTreeItem | Special list-tree-item for Eve |
| TGListTreeItemStd | |
| TGLLevelPalette | |
| TGLLine3 | 3D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex' |
| TGLLockable | Simple locking interface used by viewer and scene |
| TGLSceneBase | Scene base-class – provides basic interface expected by the TGLViewer or its sub-classes: |
| TGLScene | TGLScene provides management and rendering of ROOT's default 3D /object representation as logical and physical shapes |
| TGLScenePad | Implements VirtualViewer3D interface and fills the base-class visualization structures from pad contents |
| TGLViewerBase | Base class for GL viewers |
| TGLViewer | Base GL viewer object - used by both standalone and embedded (in pad) GL |
| TGLEmbeddedViewer | Minimal GL-viewer that can be embedded in a standard ROOT frames |
| TGLSAViewer | The top level standalone GL-viewer - created via plugin manager |
| TGLLogicalShape | Abstract logical shape - a GL 'drawable' - base for all shapes - faceset sphere etc |
| TGLCylinder | Implements a native ROOT-GL cylinder that can be rendered at different levels of detail |
| TGLFaceSet | Implements a native ROOT-GL representation of an arbitrary set of polygons |
| TGLObject | Base-class for direct OpenGL renderers |
| TEveArrowGL | OpenGL renderer class for TEveArrow |
| TEveBoxGL | OpenGL renderer class for TEveBox |
| TEveBoxProjectedGL | OpenGL renderer class for TEveBoxProjected |
| TEveCalo2DGL | OpenGL renderer class for TEveCalo2D |
| TEveCalo3DGL | OpenGL renderer class for TEveCalo3D |
| TEveCaloLegoGL | OpenGL renderer class for TEveCaloLego |
| TEveDigitSetGL | OpenGL renderer class for TEveDigitSet |
| TEveBoxSetGL | A GL rendering class for TEveBoxSet |
| TEveQuadSetGL | GL-renderer for TEveQuadSet class |
| TEveJetConeGL | OpenGL renderer class for TEveJetCone |
| TEveJetConeProjectedGL | OpenGL renderer class for TEveJetConeProjected |
| TEvePlot3DGL | OpenGL renderer class for TEvePlot3D |
| TEvePolygonSetProjectedGL | GL-renderer for TEvePolygonSetProjected class |
| TEveProjectionAxesGL | OpenGL renderer class for TEveProjectionAxes |
| TEveStraightLineSetGL | GL-renderer for TEveStraightLineSet class |
| TEveTextGL | OpenGL renderer class for TEveText |
| TEveTriangleSetGL | GL-renderer for TEveTriangleSet class |
| TGLPlot3D | Description of TGLPlot3D |
| TF2GL | GL renderer for TF2 |
| TGLParametricEquationGL | GL-renderer wrapper for TGLParametricEquation |
| TH2GL | Rendering of TH2 and derived classes |
| TH3GL | OpenGL renderer class for TH3 |
| TPointSet3DGL | Direct OpenGL renderer for TPointSet3D |
| TEveLineGL | GL-renderer for TEveLine class |
| TEveTrackGL | GL-renderer for TEveTrack class |
| TEveTrackProjectedGL | GL-renderer for TEveTrackProjected class |
| TGLPolyLine | To draw a 3D polyline in a GL window |
| TGLPolyMarker | |
| TGLSphere | Implements a native ROOT-GL sphere that can be rendered at different levels of detail |
| TGLMatrix | 16 component (4x4) transform matrix - column MAJOR as per GL |
| TGLongPosition | |
| TGLOutput | Wrapper class for GL capture & output routines |
| TGLOverlayElement | An overlay element |
| TEveRGBAPaletteOverlay | Description of TEveRGBAPaletteOverlay |
| TGLAnnotation | GL-overlay annotation |
| TGLCameraGuide | Draws arrows showing camera orientation in the overlay |
| TGLCameraOverlay | A GL overlay element which displays camera furstum |
| TEveCaloLegoOverlay | GL-overlay control GUI for TEveCaloLego |
| TGLClipSet | A collection of concrete TGLClip objects to be selected from |
| TGLManipSet | Combine all available manipulators in a collection |
| TGLOverlayButton | GL-overlay button |
| TGLOverlayList | Manage a collection of overlay elements |
| TGLPaintDevice | |
| TGLAdapter | Allow plot-painters to be used for gl-inpad and gl-viewer |
| TGLWidget | GL window with context |
| TGLPhysicalShape | Concrete physical shape - a GL drawable |
| TGLClip | Abstract clipping shape - derives from TGLPhysicalShape Adds clip mode (inside/outside) and pure virtual method to approximate shape as set of planes |
| TGLClipBox | Concrete clip box object |
| TGLClipPlane | Concrete clip plane object |
| TGLPlane | 3D plane class - of format Ax + By + Cz + D = 0 |
| TGLPlotBox | Implementation of a box around a histogram/function for plot-painters |
| TGLPlotCamera | Camera for TGLPlotPainter and sub-classes |
| TGLPlotCoordinates | Helper class for plot-painters holding information about axis ranges, numbers of bins and flags if certain axis is logarithmic |
| TGLPShapeRef | Base class for references to TGLPysicalShape that need to be notified when the shape is destroyed |
| TGLManipSet | Combine all available manipulators in a collection |
| TGLPShapeObjEditor | GUI editor for TGLPShapeObj |
| TGLQuadric | Wrapper class for GLU quadric shape drawing object |
| TGLRect | Viewport (pixel base) 2D rectangle class |
| TGLRnrCtx | Aggregates data for a given redering context as needed by various parts of the ROOT's OpenGL infrastructure |
| TGLSceneInfo | Base class for extended scene context |
| TGLScene::TSceneInfo | |
| TGLSelectBuffer | Encapsulates OpenGL select buffer |
| TGLSelectionBuffer | |
| TGLSelectRecordBase | |
| TGLOvlSelectRecord | Selection record for overlay objects |
| TGLSelectRecord | Standard selection record including information about containing scene and details ob out selected object (TGLPhysicalShape*, TObject* or simply a void* for foreign scenes) |
| TGLStopwatch | Stopwatch object for timing GL work |
| TGLUtil | Wrapper class for various misc static functions - error checking, draw helpers etc |
| TGLVertex3 | 3 component (x/y/z) vertex class |
| TGLVector3 | 3 component (x/y/z) vector class |
| TGMainFrame | |
| gui_ex.pMainFrame | |
| TGMdiFrameList | |
| TGMdiGeometry | |
| TGNumberFormat | |
| TGNumberEntry | |
| TGNumberEntryField | |
| TGPasswdDialog | |
| TGPosition | |
| ROOT::TF1Helper::TGradientParFunction | Function class representing the derivative with respect a parameter of a given TF1 |
| TGRectangle | |
| TGRedirectOutputGuard | |
| Rgl::Mc::TGridGeometry< V > | |
| Rgl::Mc::TDefaultSplitter< H, E, V > | |
| Rgl::Mc::TGridGeometry< Double_t > | |
| Rgl::Mc::TF3Adapter | |
| Rgl::Mc::TF3EdgeSplitter | |
| Rgl::Mc::TGridGeometry< Float_t > | |
| Rgl::Fgt::TKDEAdapter | |
| TGSearchType | |
| TGText | |
| TGTextBuffer | |
| TGTextLine | |
| Rgl::TGuardBase | |
| Rgl::TOneArgGuard< Func, Arg > | |
| Rgl::TTwoArgsGuard< Func, Arg1, Arg2 > | |
| TGuiBuilder | |
| TRootGuiBuilder | |
| TGWidget | |
| TEveGTriVecValuator | Composite GUI element for setting three numerical values (label, three number-entries) |
| TEveGValuatorBase | Base class for composite GUI elements for setting of numeric values |
| TEveGDoubleValuator | Composite GUI element for selection of range (label, two number-entries and double-slider) |
| TEveGValuator | Composite GUI element for single value selection (supports label, number-entry and slider) |
| TGButton | |
| TGDockButton | |
| TGDockHideButton | |
| TGPictureButton | |
| TGImageMap | |
| TGTextButton | |
| TEveGedNameTextButton | Specialization of TGTextButton for EVE name frame |
| TGCheckButton | |
| TGColorSelect | |
| TGedSelect | |
| TGedMarkerSelect | |
| TGedPatternSelect | |
| TGRadioButton | |
| TGSplitButton | |
| TGuiBldHintsButton | |
| TGColorPalette | |
| TGColorPick | |
| TGComboBox | |
| TGFontTypeComboBox | |
| TGFSComboBox | |
| TGLineStyleComboBox | |
| TGLineWidthComboBox | |
| TGDockableFrame | |
| TGDoubleSlider | |
| TGDoubleHSlider | |
| TGTripleHSlider | |
| TGDoubleVSlider | |
| TGTripleVSlider | |
| TGeoPconSection | |
| TGListBox | |
| TGMdiWinResizer | |
| TGMdiCornerWinResizer | |
| TGMdiHorizontalWinResizer | |
| TGMdiVerticalWinResizer | |
| TGNumberEntry | |
| TGScrollBar | |
| TGHScrollBar | |
| TGVScrollBar | |
| TGShutterItem | |
| TGSlider | |
| TGHSlider | |
| TGVSlider | |
| TGSpeedo | |
| TGTab | |
| TGTable | |
| TGSimpleTable | |
| TGTreeTable | TGTreeTable is a TGTable that owns it's own interface |
| TGTextEntry | |
| TGNumberEntryField | |
| TGView | |
| TGHtml | |
| TGTextView | |
| TGTextEdit | |
| TGTextViewostream | |
| TGWin32ProxyBase | |
| TGWin32GLManagerProxy | |
| TGWin32VirtualXProxy | |
| Rgl::Mc::TH3Adapter< H, E > | |
| ROOT::Internal::THnBaseBinIter | Iterator over THnBase bins (internal implementation) |
| TGeoXtru::ThreadData_t | |
| TGeoBoolNode::ThreadData_t | |
| TGeoPatternFinder::ThreadData_t | |
| TGeoPgon::ThreadData_t | |
| TGeoVolumeAssembly::ThreadData_t | |
| TIdleTOTimerGuard | |
| ROOT::Math::test::Timer | |
| TimeStampCounter | |
| TIndArray | |
| ROOT::Internal::TInitBehavior | |
| ROOT::Internal::TDefaultInitBehavior | |
| ROOT::Internal::TQObjectInitBehavior | |
| ROOT::Internal::TTableInitBehavior< T > | |
| TInspectorImp | ABC describing GUI independent object inspector (abstraction mainly needed for Win32 |
| TVirtualCollectionPtrIterators::TInternalIterator | |
| TClassEdit::TInterpreterLookupHelper | |
| ROOT::TMetaUtils::TClingLookupHelper | |
| TInterpreterValue | |
| TClingValue | Bridge between cling::Value and ROOT |
| Rgl::Mc::TIsoMesh< V > | |
| Rgl::Mc::TIsoMesh< Double_t > | |
| Rgl::Mc::TIsoMesh< Float_t > | |
| TIter | |
| TIterCategory< T > | |
| TIterator | Iterator abstract base class |
| RooDataHistSliceIter | RooDataHistSliceIter iterates over all bins in a RooDataHist that occur in a slice defined by the bin coordinates of the input sliceSet |
| RooLinkedListIter | RooLinkedListIter is the TIterator implementation for RooLinkedList |
| RooMultiCatIter | RooMultiCatIter iterators over all state permutations of a list of categories |
| TBtreeIter | Iterator of btree |
| THashTableIter | Iterator of hash table |
| TListIter | Iterator of linked list |
| TMapIter | Iterator of map |
| TObjArrayIter | Iterator of object array |
| TOrdCollectionIter | Iterator of ordered collection |
| TRefArrayIter | Iterator of object array |
| TTreeFriendLeafIter | Iterator on all the leaves in a TTree and its friend |
| TViewPubDataMembersIter | Iterator of over the view's content |
| TViewPubFunctionsIter | Iterator of over the view's content |
| TKDEFGT | |
| TLatex::TLatexFormSize | TLatex helper class used to compute the size of a portion of a formula |
| TLimit | Algorithm to compute 95% C.L |
| TLockGuard | |
| TStreamerInfoActions::TLoopConfiguration | Base class of the Configurations for the member wise looping routines |
| TLorentzRotation::TLorentzRotationRow | |
| TMakeProject | |
| TMapRec | Keep track of an object in the mapped file |
| TMatrixDEigen | |
| TMatrixDSymEigen | |
| TMatrixTColumn_const< Element > | |
| TMatrixTColumn< Element > | |
| TMatrixTDiag_const< Element > | |
| TMatrixTDiag< Element > | |
| TMatrixTFlat_const< Element > | |
| TMatrixTFlat< Element > | |
| TMatrixTRow_const< Element > | |
| TMatrixTRow< Element > | |
| TMatrixTSparseDiag_const< Element > | |
| TMatrixTSparseDiag< Element > | |
| TMatrixTSparseRow_const< Element > | |
| TMatrixTSparseRow< Element > | |
| TMatrixTSub_const< Element > | |
| TMatrixTSub< Element > | |
| TMD5 | This code implements the MD5 message-digest algorithm |
| TMemberInspector | Abstract base class for accessing the data-members of a class |
| TMemberStreamer | |
| TCollectionMemberStreamer | Class streamer object to implement TMemberStreamer functionality for I/O emulation |
| TConvertClonesArrayToProxy | Small helper to read a TBuffer containing a TClonesArray into any valid collection |
| TConvertMapToProxy | |
| TMemFile::TMemBlock | |
| Memstat::TMemStatFAddrContainer | |
| TMemStatHook | |
| TMINUIT | |
| TMPClient | Base class for multiprocess applications' clients |
| TProcPool | This class provides a simple interface to execute the same task multiple times in parallel, possibly with different arguments every time |
| TMPWorker | This class works in conjuction with TMPClient, reacting to messages received from it as specified by the Notify and HandleInput methods |
| TPoolProcessor< F > | |
| TPoolWorker< F, T, R > | This class works together with TProcPool to allow the execution of functions in server processes |
| TPoolWorker< F, T, void > | |
| TPoolWorker< F, void, R > | |
| ROOT::Internal::TMultiArrayType< T, d > | |
| TMVA::TMVAGaussPair | |
| TMVA::TMVAGUI | |
| TNDArrayRef< T > | |
| TMVA::TNeuronInput | |
| TMVA::TNeuronInputAbs | |
| TMVA::TNeuronInputSqSum | |
| TMVA::TNeuronInputSum | |
| TMVA::TNeuronInputChooser | |
| TNonCopyable | |
| TThreadPool< aTask, aParam > | |
| ROOT::TMetaUtils::TNormalizedCtxt | |
| TObject | Mother of all ROOT objects |
| Hit | |
| Jet | |
| JetEvent | |
| Memstat::TMemStatMng | |
| PyROOT::TMemoryRegulator | |
| RooAbsCollection | RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects |
| RooAbsIntegrator | RooAbsIntegrator is the abstract interface for integrators of real-valued functions that implement the RooAbsFunc interface |
| RooAdaptiveGaussKronrodIntegrator1D | RooAdaptiveGaussKronrodIntegrator1D implements the Gauss-Kronrod integration algorithm |
| RooAdaptiveIntegratorND | RooAdaptiveIntegratorND implements an adaptive one-dimensional numerical integration algorithm |
| RooBinIntegrator | RooBinIntegrator implements an adaptive one-dimensional numerical integration algorithm |
| RooGaussKronrodIntegrator1D | RooGaussKronrodIntegrator1D implements the Gauss-Kronrod integration algorithm |
| RooImproperIntegrator1D | Special numeric integrator that can handle integrals over open domains |
| RooIntegrator1D | RooIntegrator1D implements an adaptive one-dimensional numerical integration algorithm |
| RooIntegrator2D | RooIntegrator2D implements a numeric two-dimensiona integrator in terms of a recursive application of RooIntegrator1D |
| RooMCIntegrator | RooMCIntegrator implements an adaptive multi-dimensional Monte Carlo numerical integration, following the VEGAS algorithm originally described in G |
| RooSegmentedIntegrator1D | RooSegmentedIntegrator1D implements an adaptive one-dimensional numerical integration algorithm |
| RooSegmentedIntegrator2D | RooSegmentedIntegrator2D implements an adaptive one-dimensional numerical integration algorithm |
| RooCatType | RooCatType is an auxilary class for RooAbsCategory and defines a a single category state |
| RooCFunction1Ref< VO, VI > | |
| RooCFunction2Ref< VO, VI1, VI2 > | |
| RooCFunction3Ref< VO, VI1, VI2, VI3 > | |
| RooCFunction4Ref< VO, VI1, VI2, VI3, VI4 > | |
| RooCmdConfig | Class RooCmdConfig is a configurable parser for RooCmdArg named arguments |
| RooExpensiveObjectCache | RooExpensiveObjectCache is a singleton class that serves as repository for objects that are expensive to calculate |
| RooGrid | RooGrid is a utility class for RooMCIntegrator which implements an adaptive multi-dimensional Monte Carlo numerical integration, following the VEGAS algorithm |
| RooHashTable | RooHashTable implements a hash table for TObjects |
| RooLinkedList | RooLinkedList is an collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list |
| RooRefCountList | A RooRefCountList is a RooLinkedList that keeps a reference counter with each added node |
| RooMinimizer | RooMinimizer is a wrapper class around ROOT::Fit:Fitter that provides a seamless interface between the minimizer functionality and the native RooFit interface |
| RooMinuit | RooMinuit is a wrapper class around TFitter/TMinuit that provides a seamless interface between the MINUIT functionality and the native RooFit interface |
| RooMsgService | Singleton class that organizes informational, debugging, warning and errors messages generated by the RooFit core code |
| RooNameSet | RooNameSet is a utility class that stores the names the objects in a RooArget |
| RooNumGenConfig | RooNumGenConfig holds the configuration parameters of the various numeric integrators used by RooRealIntegral |
| RooNumGenFactory | RooNumGenFactory is a factory to instantiate numeric integrators from a given function binding and a given configuration |
| RooNumIntConfig | RooNumIntConfig holds the configuration parameters of the various numeric integrators used by RooRealIntegral |
| RooNumIntFactory | RooNumIntFactory is a factory to instantiate numeric integrators from a given function binding and a given configuration |
| RooSetPair | RooSetPair is a utility class that stores a pair of RooArgSets |
| RooSharedProperties | Class RooSharedProperties is the base class for shared properties that can be stored in RooSharedPropertiesList |
| RooCategorySharedProperties | RooCategorySharedProperties is the container for all properties that are shared between instance of RooCategory objects that are clones of each other |
| RooRealVarSharedProperties | Class RooRealVarSharedProperties is an implementation of RooSharedProperties that stores the properties of a RooRealVar that are shared among clones |
| RooSharedPropertiesList | Class RooSharedPropertiesList maintains the properties of RooRealVars and RooCategories that are clones of each other |
| RooSimPdfBuilder | |
| RooStats::AcceptanceRegion | |
| RooStats::HistFactory::EstimateSummary | |
| RooStats::HistFactory::HistoToWorkspaceFactory | |
| RooStats::HistFactory::HistoToWorkspaceFactoryFast | |
| RooStats::MetropolisHastings | This class uses the Metropolis-Hastings algorithm to construct a Markov Chain of data points using Monte Carlo |
| RooStats::ProposalFunction | ProposalFunction is an interface for all proposal functions that would be used with a Markov Chain Monte Carlo algorithm |
| RooStats::PdfProposal | PdfProposal is a concrete implementation of the ProposalFunction interface |
| RooStats::SequentialProposal | Class implementing a proposal function that samples the parameter space by moving only in one coordinate (choosen randomly) at each step |
| RooStats::UniformProposal | UniformProposal is a concrete implementation of the ProposalFunction interface for use with a Markov Chain Monte Carlo algorithm |
| RooStats::ProposalHelper | |
| RooStats::SamplingSummary | |
| RooStats::SamplingSummaryLookup | |
| ROOT::Detail::TSchemaRuleSet | |
| ROOT::Internal::TNamedBranchProxy | |
| ROOT::Internal::TTreeReaderDescriptor | |
| ROOT::R::TRDataFrame | This is a class to create DataFrames from ROOT to R
|
| ROOT::R::TRFunctionExport | This is a class to pass functions from ROOT to R
|
| ROOT::R::TRFunctionImport | This is a class to pass functions from ROOT to R |
| ROOT::R::TRInterface | |
| ROOT::R::TRObject | This is a class to get ROOT's objects from R's objects
|
| ROOT::TSchemaRule | |
| RooThreshEntry | Class RooThreshEntry is a utility class for RooThresholdCategory |
| RooWorkspace::CodeRepo | |
| TAFS | |
| TAliEnFind | |
| TApplication | This class creates the ROOT Application Environment that interfaces to the windowing system eventloop and eventhandlers |
| PyROOT::TPyROOTApplication | |
| TApplicationRemote | |
| TApplicationServer | |
| TGApplication | |
| TProofServ | Class providing the PROOF server |
| TProofServLite | Version of the PROOF worker server for local running |
| TXProofServ | This class implements the XProofD version of TProofServ, with respect to which it differs only for the underlying connection technology |
| TQApplication | |
| TRint | |
| TArchiveFile | Class describing an archive file containing multiple sub-files, like a ZIP or TAR archive |
| TZIPFile | Describes a ZIP archive file containing multiple sub-files |
| TArchiveMember | |
| TZIPMember | A ZIP archive consists of files compressed with the popular ZLIB compression algorithm; this class records the information about a single archive member |
| TASPaletteEditor::PaintPalette | |
| TAuthenticate | |
| TBinomialEfficiencyFitter | Binomial fitter for the division of two histograms |
| TBits | Container of bits |
| TBonjourBrowser | |
| TBonjourRecord | |
| TBonjourRegistrar | |
| TBonjourResolver | |
| TBox | Create a Box |
| TBuffer | Buffer base class used for serializing objects |
| TBufferFile | The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket |
| TBufferSQL | Implement TBuffer for a SQL backend |
| TBufferSQL2 | Converts data to SQL statements or read data from SQL tables |
| TBufferXML | Class for serializing/deserializing object to/from xml |
| TMessage | |
| TBufferJSON | |
| TBuffer3D | Generic 3D primitive description class |
| TBuffer3DSphere | Sphere description class - see TBuffer3DTypes for producer classes Supports hollow and cut spheres |
| TBuffer3DTube | Complete tube description class - see TBuffer3DTypes for producer classes |
| TBuffer3DTubeSeg | Tube segment description class - see TBuffer3DTypes for producer classes |
| TBuffer3DCutTube | Cut tube segment description class - see TBuffer3DTypes for producer classes |
| TClassDocInfo | |
| TClassGenerator | Objects following this interface can be passed onto the TROOT object to implement a user customized way to create the TClass objects |
| TPyClassGenerator | |
| TClassMenuItem | Describes one element of the context menu associated to a class The menu item may describe |
| TClassTable | This class registers for all classes their name, id and dictionary function in a hash table |
| TCollection | Collection abstract base class |
| THashTable | THashTable implements a hash table to store TObject's |
| TListOfTypes | A collection of TDataType designed to hold the typedef information and numerical type information |
| TMap | 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) |
| TSeqCollection | Sequenceable collection abstract base class |
| TBtree | B-tree class |
| TList | A doubly linked list |
| RooList | A RooList is a TList with extra support for working with options that are associated with each node |
| TGridJobStatusList | |
| TAlienJobStatusList | |
| TGridResult | |
| TAlienResult | |
| TGLiteResult | |
| THashList | THashList implements a hybrid collection class consisting of a hash table and a list to store TObject's |
| TListOfDataMembers | 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 |
| TListOfEnums | A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum that were described unloaded enum |
| TListOfEnumsWithLock | A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum that were described unloaded enum |
| TListOfFunctions | A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFunction that were described unloaded function |
| TListOfFunctionTemplates | A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFunction that were described unloaded function |
| TSelectorList | 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) |
| TParallelCoordSelect | A TParallelCoordSelect is a specialised TList to hold TParallelCoordRanges used by TParallelCoord |
| TProofOutputList | Derivation of TList with an overload of ls() and Print() allowing to filter out some of the variables |
| TQCommand | The Command design pattern is based on the idea, that all editing in an application is done by creating instances of command objects |
| TQUndoManager | Recorder of operations for undo and redo |
| TQConnection | TQConnection class is an internal class, used in the object communication mechanism |
| TSortedList | A sorted doubly linked list |
| TViewPubDataMembers | 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 |
| TViewPubFunctions | 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 |
| TObjArray | An array of TObjects |
| RooRefArray | |
| TClonesArray | An array of clone (identical) objects |
| TGeoNavigatorArray | |
| TOrdCollection | Ordered collection |
| TRefArray | An array of references to TObjects |
| TCondition | |
| TConditionImp | |
| TPosixCondition | |
| TWin32Condition | |
| TCondor | |
| TCondorSlave | |
| TConfidenceLevel | Class to compute 95% CL limits |
| TDataSetIter | |
| TVolumeViewIter | |
| TDataSetManager | |
| TDataSetManagerAliEn | |
| TDataSetManagerFile | |
| TDecayChannel | Description of the decay channel |
| TDecompBase | |
| TDecompBK | |
| TDecompChol | |
| TDecompLU | |
| TDecompQRH | |
| TDecompSparse | |
| TDecompSVD | |
| TDictAttributeMap | The ROOT object has a list of properties which are stored and retrieved using TDictAttributeMap |
| TDNDData | |
| TDocMethodWrapper | |
| TDocOutput | |
| TClassDocOutput | |
| TDocParser | |
| TDrawFeedback | Utility class to draw objects in the feedback list during queries |
| TEllipse | Draw Ellipses |
| TEntryListBlock | Used by TEntryList to store the entry numbers |
| TEnv | Reads config files, by default named .rootrc |
| TEnvRec | |
| TEveCluster | |
| TEveElementObjectPtr | TEveElement with external TObject as a holder of visualization data |
| TEveFrameBox | Description of a 2D or 3D frame that can be used to visually group a set of objects |
| TEveGeoNode | Wrapper for TGeoNode that allows it to be shown in GUI and controlled as a TEveElement |
| TEveGridStepper | Provide discrete position coordinates for placement of objects on regular grids |
| TEveHit | |
| TEveMCRecCrossRef | |
| TEventIter | Special iterator class used in TProofPlayer to iterate over events or objects in the packets |
| TEventIterObj | |
| TEventIterTree | |
| TEventIterUnit | |
| TEveRecCascade | |
| TEveRecKink | |
| TEveRecTrackT< TT > | |
| TEveRecTrackT< Float_t > | |
| TEveRecV0 | |
| TEveRGBAPalette | A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes |
| TEveTrans | TEveTrans is a 4x4 transformation matrix for homogeneous coordinates stored internally in a column-major order to allow direct usage by GL |
| TEveVSD | Visualization Summary Data - a collection of trees holding standard event data in experiment independent format |
| TExMap | This class stores a (key,value) pair using an external hash |
| TFeldmanCousins | |
| TFileCacheRead | A cache when reading files over the network |
| TTreeCache | A specialized TFileCacheRead object for a TTree |
| TTreeCacheUnzip | Specialization of TTreeCache for parallel Unzipping |
| TFileCacheWrite | A cache when writing files over the network |
| TFileMerger | This class provides file copy and merging services |
| TFilePrefetch | The prefetching mechanism uses two classes (TFilePrefetch and TFPBlock) to prefetch in advance a block of tree entries |
| TFoam | |
| TFoamCell | |
| TFoamIntegrand | |
| RooTFoamBinding | Lightweight interface adaptor that binds a RooAbsPdf to TFOAM |
| TFoamMaxwt | |
| TFoamVect | |
| TFormLeafInfo | This class is a small helper class to implement reading a data member on an object stored in a TTree |
| TFormLeafInfoCast | A small helper class to implement casting an object to a different type (equivalent to dynamic_cast) |
| TFormLeafInfoClones | A small helper class to implement reading a data member on a TClonesArray object stored in a TTree |
| TFormLeafInfoCollection | A small helper class to implement reading a data member on a generic collection object stored in a TTree |
| TFormLeafInfoCollectionObject | A small helper class to implement reading a data member on a TClonesArray object stored in a TTree |
| TFormLeafInfoCollectionSize | Used to return the size of a collection |
| TFormLeafInfoDirect | A small helper class to implement reading a data member on an object stored in a TTree |
| TFormLeafInfoMethod | Asmall helper class to implement executing a method of an object stored in a TTree |
| TFormLeafInfoMultiVarDim | A helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree |
| TFormLeafInfoMultiVarDimClones | A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree |
| TFormLeafInfoMultiVarDimCollection | A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree |
| TFormLeafInfoMultiVarDimDirect | A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree |
| TFormLeafInfoNumerical | A small helper class to implement reading a numerical value inside a collection |
| TFormLeafInfoPointer | A small helper class to implement reading a data member by following a pointer inside a branch of TTree |
| TFormLeafInfoReference | A small helper class to implement the following of reference objects stored in a TTree |
| TFormLeafInfoTTree | A small helper class to implement reading from the containing TTree object itself |
| TFPBlock | This class represents the encapsulation of a block request |
| TFractionFitter | Fits MC fractions to data histogram |
| TFree | Service class for TFile |
| TFTP | |
| TGClient | |
| TGDMLParse | |
| TGDMLRefl | |
| TGDMLWrite | |
| TGDNDManager | |
| TGedFrame::TGedSubFrame | |
| TGenPhaseSpace | |
| TGeoBatemanSol | |
| TGeoBoolNode | |
| TGeoIntersection | |
| TGeoSubtraction | |
| TGeoUnion | |
| TGeoBranchArray | |
| TGeoBuilder | |
| TGeoCacheState | |
| TGeoChecker | |
| TGeoDecayChannel | |
| TGeoElementTable | |
| TGeoExtension | |
| TGeoRCExtension | |
| TGeoGlobalMagField | |
| TGeoHelix | |
| TGeoIteratorPlugin | |
| TGeoNavigator | |
| TGeoNodeCache | |
| TGeoPatternFinder | |
| TGeoPatternCylPhi | |
| TGeoPatternCylR | |
| TGeoPatternHoneycomb | |
| TGeoPatternParaX | |
| TGeoPatternParaY | |
| TGeoPatternParaZ | |
| TGeoPatternSphPhi | |
| TGeoPatternSphR | |
| TGeoPatternSphTheta | |
| TGeoPatternTrapZ | |
| TGeoPatternX | |
| TGeoPatternY | |
| TGeoPatternZ | |
| TGeoPolygon | |
| TGeoTabManager | |
| TGeoToStep | |
| TGeoVoxelFinder | |
| TGFrameElement | |
| TGFrameElementPack | |
| TGGC | |
| TGHtmlElement | |
| TGHtmlBlock | |
| TGHtmlMarkupElement | |
| TGHtmlAnchor | |
| TGHtmlCell | |
| TGHtmlForm | |
| TGHtmlHr | |
| TGHtmlImageMarkup | |
| TGHtmlInput | |
| TGHtmlLi | |
| TGHtmlListStart | |
| TGHtmlMapArea | |
| TGHtmlRef | |
| TGHtmlScript | |
| TGHtmlTable | |
| TGHtmlSpaceElement | |
| TGHtmlTextElement | |
| TGHtmlImage | |
| TGHtmlLayoutContext | |
| TGHtmlUri | |
| TGIdleHandler | |
| TGItemContext | Empty object used as context menu support for TGLVTreeEntries |
| TGLAutoRotator | Automatically rotates GL camera |
| TGLayoutHints | |
| TGTableLayoutHints | |
| TGXYLayoutHints | |
| TGLayoutManager | |
| TGMatrixLayout | |
| TGNumberEntryLayout | |
| TGTabLayout | |
| TGTableLayout | |
| TGTileLayout | |
| TGListDetailsLayout | |
| TGListLayout | |
| TGVerticalLayout | |
| TGHorizontalLayout | |
| TGRowLayout | |
| TGColumnLayout | |
| TGXYLayout | |
| TGLCamera | Abstract base camera class - concrete classes for orthographic and perspective cameras derive from it |
| TGLOrthoCamera | Orthographic projection camera |
| TGLPerspectiveCamera | Perspective projection camera - with characteristic foreshortening |
| TGLLightSet | Encapsulates a set of lights for OpenGL |
| TGLPShapeObj | Wrap TGLPysicalShape into TObject so that it can be edited using GED |
| TGMainFrame::TGMapKey | |
| TGMenuEntry | |
| TGMime | |
| TGMimeTypes | |
| TGObject | |
| TGFontPool | |
| TGGCPool | |
| TGResourcePool | |
| TGWindow | |
| TGFrame | |
| TGButton | |
| TGCanvas | |
| TGListView | |
| TGMdiMainFrame | |
| TRootEmbeddedCanvas | |
| TGColorFrame | |
| TGColorPalette | |
| TGColorPick | |
| TGCompositeFrame | |
| TEditQueryFrame | |
| TEveCompositeFrame | Abstract base-class for frame-slots that encompass EVE-windows (sub-classes of TEveWindow) |
| TEveCompositeFrameInMainFrame | An EVE window-slot contained within a TGMainFrame |
| TEveCompositeFrameInPack | An EVE window-slot contained within one frame of a TGPack |
| TEveCompositeFrameInTab | An EVE window-slot contained within one tab of a TGTab |
| TEveGTriVecValuator | Composite GUI element for setting three numerical values (label, three number-entries) |
| TEveGValuatorBase | Base class for composite GUI elements for setting of numeric values |
| TG16ColorSelector | |
| TGColorPopup | |
| TGComboBox | |
| TGComboBoxPopup | |
| TGContainer | |
| TGLBContainer | |
| TGListTree | |
| TGLVContainer | |
| TGFileContainer | |
| TTVLVContainer | This class represent the list view container for the |
| TGDockableFrame | |
| TGedFrame | |
| TArrowEditor | |
| TAttFillEditor | |
| TAttLineEditor | |
| TAttMarkerEditor | |
| TAttTextEditor | |
| TAxisEditor | |
| TCurlyArcEditor | |
| TCurlyLineEditor | |
| TEveArrowEditor | GUI editor for TEveArrow |
| TEveCalo3DEditor | GUI editor for TEveCalo3D |
| TEveCaloLegoEditor | GUI editor for TEveCaloLego |
| TEveCaloVizEditor | GUI editor for TEveCaloEditor |
| TEveDigitSetEditor | Editor for TEveDigitSet class |
| TEveElementEditor | Editor for TEveElement class |
| TEveGedNameFrame | Specialization of TGedNameFrame used in EVE |
| TEveGeoNodeEditor | Editor for TEveGeoNode class |
| TEveGeoTopNodeEditor | Editor for TEveGeoTopNode class |
| TEveGridStepperEditor | Editor for TEveGridStepper class |
| TEveJetConeEditor | GUI editor for TEveJetCone |
| TEveLineEditor | Editor for TEveLine class |
| TEveParamListEditor | GUI editor for TEveParamList |
| TEvePointSetArrayEditor | Editor for TEvePointSetArray class |
| TEveProjectionAxesEditor | GUI editor for TEveProjectionAxes |
| TEveProjectionManagerEditor | GUI editor for TEveProjectionManager class |
| TEveRGBAPaletteEditor | Editor for TEveRGBAPalette class |
| TEveShapeEditor | GUI editor for TEveShape |
| TEveStraightLineSetEditor | Editor for TEveStraightLineSet class |
| TEveTextEditor | GUI editor for TEveText |
| TEveTrackEditor | Editor for TEveTrack class |
| TEveTrackListEditor | Editor for TEveTrackList class |
| TEveTrackPropagatorEditor | GUI editor for TEveTrackPropagator |
| TEveTransEditor | Editor for TEveTrans class |
| TEveTriangleSetEditor | Editor for TEveTriangleSet class |
| TEveViewerListEditor | GUI editor for TEveViewerList |
| TEveWindowEditor | GUI editor for TEveWindow |
| TF1Editor | |
| TFrameEditor | |
| TGedNameFrame | |
| TGeoGedFrame | |
| TGeoBBoxEditor | |
| TGeoCombiTransEditor | |
| TGeoConeEditor | |
| TGeoConeSegEditor | |
| TGeoEltuEditor | |
| TGeoHypeEditor | |
| TGeoMaterialEditor | |
| TGeoMixtureEditor | |
| TGeoMediumEditor | |
| TGeoNodeEditor | |
| TGeoParaEditor | |
| TGeoPconEditor | |
| TGeoPgonEditor | |
| TGeoRotationEditor | |
| TGeoSphereEditor | |
| TGeoTorusEditor | |
| TGeoTranslationEditor | |
| TGeoTrapEditor | |
| TGeoGtraEditor | |
| TGeoTrd1Editor | |
| TGeoTrd2Editor | |
| TGeoTubeEditor | |
| TGeoTubeSegEditor | |
| TGeoCtubEditor | |
| TGeoVolumeEditor | |
| TGeoManagerEditor | |
| TGL5DDataSetEditor | GUI editor for OpenGL 5D Painter |
| TGLClipSetEditor | GUI editor for TGLClipSet |
| TGLLightSetEditor | |
| TGLPShapeObjEditor | GUI editor for TGLPShapeObj |
| TGLViewerEditor | GUI editor for TGLViewer |
| TGraphEditor | |
| TH1Editor | |
| TH2Editor | |
| TLineEditor | |
| TPadEditor | |
| TParallelCoordEditor | This is the TParallelCoord editor |
| TPaveStatsEditor | |
| TPieEditor | |
| TPieSliceEditor | |
| TSpiderEditor | The TSpider editor class |
| TStructNodeEditor | |
| TTextEditor | |
| TGedPatternSelector | |
| TGedPopup | |
| TGedMarkerPopup | |
| TGedPatternPopup | |
| TGeoPconSection | |
| TGGroupFrame | |
| TGButtonGroup | |
| TGHButtonGroup | |
| TGVButtonGroup | |
| TGHorizontalFrame | |
| TGHeaderFrame | |
| TGMenuBar | |
| TGStatusBar | |
| TGListBox | |
| TGMainFrame | |
| numberEntry.pMyMainFrame | |
| TASPaletteEditor | This is a GUI window to edit a color palette |
| TestMainFrame | |
| TEveGListTreeEditorFrame | Composite GUI frame for parallel display of a TGListTree and TEveGedEditor |
| TFitEditor | |
| TGCommandPlugin | |
| TGedEditor | |
| TEveGedEditor | Specialization of TGedEditor for proper update propagation to TEveManager |
| TGeoTransientPanel | |
| TGFileBrowser | |
| TGHtmlBrowser | |
| TGLSAFrame | Standalone GL Viewer GUI main frame |
| TGRecorder | |
| TGTextEditor | |
| TGTransientFrame | |
| Editor | |
| TAdvancedGraphicsDialog | |
| TestDialog | |
| TestMsgBox | |
| TestProgress | |
| TestShutter | |
| TestSliders | |
| TFitParametersDialog | |
| TFunctionParametersDialog | |
| TGColorDialog | |
| TGeoTreeDialog | |
| TGeoMaterialDialog | |
| TGeoMatrixDialog | |
| TGeoMediumDialog | |
| TGeoShapeDialog | |
| TGeoVolumeDialog | |
| TGFileDialog | |
| TGFontDialog | |
| TGGotoDialog | |
| TGInputDialog | |
| TGMsgBox | |
| TGPrintDialog | |
| TGSearchDialog | |
| TGSelectBox | This class represent a specialized expression editor for TTVLVEntry 'true name' and 'alias' data members |
| TGUndockedFrame | |
| TNewChainDlg | |
| TNewQueryDlg | |
| TProofProgressLog | |
| TProofProgressMemoryPlot | |
| TRootDialog | |
| TRootHelpDialog | |
| TSessionLogView | |
| TStyleDialog | |
| TStylePreview | |
| TTreeInput | |
| TUploadDataSetDlg | |
| TRootBrowser | |
| TRootBrowserLite | |
| TRootCanvas | |
| TRootControlBar | |
| TRootGuiBuilder | |
| TSessionViewer | |
| TStructViewerGUI | |
| TStyleManager | |
| TTreeViewer | A graphic user interface designed to handle ROOT trees and to take advantage of TTree class features |
| TGMdiButtons | |
| TGMdiDecorFrame | |
| TGMdiFrame | |
| TGMdiMenuBar | |
| TGMdiTitleBar | |
| TGNumberEntry | |
| TGPack | |
| TGShapedFrame | |
| TGShutter | |
| TGSplitFrame | |
| TGSplitTool | |
| TGTab | |
| TGTable | |
| TGTableHeaderFrame | |
| TGToolBar | |
| TGToolTip | |
| TGuiBldNameFrame | |
| TGVerticalFrame | |
| TEveGridStepperSubEditor | Sub-editor for TEveGridStepper class |
| TEveRGBAPaletteSubEditor | Sub-editor for TEveRGBAPalette class |
| TEveTrackPropagatorSubEditor | Sub-editor for TEveTrackPropagator class |
| TEveTransSubEditor | Sub-editor for TEveTrans class |
| TGLClipSetSubEditor | GUI sub-editor for TGLClipSet |
| TGLLightSetSubEditor | Sub-editor for TGLLightSet |
| TGShutterItem | |
| TGuiBldEditor | |
| TGuiBldGeometryFrame | |
| TGuiBldHintsEditor | |
| TGView | |
| TGViewFrame | |
| TGViewPort | |
| TileFrame | |
| TSessionFrame | |
| TSessionInputFrame | |
| TSessionOutputFrame | |
| TSessionQueryFrame | |
| TSessionServerFrame | |
| TGDoubleSlider | |
| TGDragWindow | |
| TGedPatternFrame | |
| TGHorizontal3DLine | |
| TGIcon | |
| TGMdiTitleIcon | |
| TGLabel | |
| TGLBEntry | |
| TGTextLBEntry | |
| TGIconLBEntry | |
| TGLineLBEntry | |
| TGTreeLBEntry | |
| TGLVEntry | |
| TGFileItem | |
| TTVLVEntry | This class represent entries that goes into the TreeViewer listview container |
| TGLWidget | GL window with context |
| TGMdiContainer | |
| TGMdiWinResizer | |
| TGMenuTitle | |
| TGPopupMenu | |
| TRootContextMenu | |
| TGProgressBar | |
| TGHProgressBar | |
| TGVProgressBar | |
| TGScrollBar | |
| TGScrollBarElement | |
| TGSlider | |
| TGSpeedo | |
| TGSplitter | |
| TGHSplitter | |
| TGVSplitter | |
| TGVFileSplitter | |
| TGTabElement | |
| TGTableCell | |
| TGTableHeader | |
| TGTextEntry | |
| TGuiBldDragManager | |
| TGVertical3DLine | |
| TGPicture | |
| TGSelectedPicture | |
| TGPicturePool | |
| TGraph2DPainter | The TGraphDelaunay painting class |
| TGraphEdge | An edge object connecting two nodes which can be added in a TGraphStruct |
| TGraphStruct | The Graph Structure is an interface to the graphviz package |
| TGRectMap | |
| TGRegion | |
| TGRegionWithId | |
| TGrid | |
| TAlien | |
| TGLite | |
| TGridCollection | |
| TAlienCollection | |
| TGridJDL | |
| TAlienJDL | |
| TGridJob | |
| TAlienJob | |
| TAlienMasterJob | |
| TGLiteJob | |
| TGTextLayout | |
| TGUnknownWindowHandler | |
| TH2PolyBin | Helper class to represent a bin in the TH2Poly histogram |
| THLimitsFinder | Class to find nice axis limits |
| TProofLimitsFinder | Class to find axis limits and synchronize them between workers |
| THnIter | Iterator over THnBase bins |
| THnSparseArrayChunk | THnSparseArrayChunk is used internally by THnSparse |
| THostAuth | |
| THtml | |
| THtml::TFileSysEntry | |
| THtml::TFileSysDir | |
| THtml::TFileSysDB | |
| THtml::TFileSysRoot | |
| THtml::THelperBase | |
| THtml::TFileDefinition | |
| THtml::TModuleDefinition | |
| THtml::TPathDefinition | |
| THttpCallArg | |
| TImagePalette | A class to define a conversion from pixel values to pixel color |
| TImagePlugin | |
| TASImagePlugin | |
| TASPluginGS | Allows to read PS/EPS/PDF files via GhostScript |
| TInetAddress | This class represents an Internet Protocol (IP) address |
| TKDTree< Index, Value > | Kd-tree |
| TKDTreeBinning | <- TKDTreeBinning - A class providing multidimensional binning -> |
| TKSocket | |
| TLDAPEntry | |
| TLDAPResult | |
| TLDAPServer | |
| TLegendEntry | Storage class for one entry of a TLegend |
| TLimitDataSource | This class serves as interface to feed data into the TLimit routines |
| TLine | A simple line |
| TLockFile | A scoped lock based on files |
| TLorentzRotation | |
| TLorentzVector | |
| TMapFile | This class implements a shared memory region mapped to a file |
| TMarker | Manages Markers |
| TMarker3DBox | A special 3-D marker designed for event display |
| TMatrixTBase< Element > | |
| TMatrixT< Element > | |
| TMatrixT< Double_t > | |
| TMatrixTSparse< Element > | |
| TMatrixTSparse< Double_t > | |
| TMatrixTSym< Element > | |
| TMatrixTSym< Double_t > | |
| TMatrixTLazy< Element > | |
| THaarMatrixT< Element > | |
| THilbertMatrixT< Element > | |
| TMatrixTSymLazy< Element > | |
| THilbertMatrixTSym< Element > | |
| TMCParticle | This class serves as a data storage for description of one particle |
| TMCVerbose | Class for printing a detailed information from MC application |
| TMemStat | |
| TMemStatShow | Utility class post-processing the file generated by TMemStat (default memstat.root) |
| TMergerInfo | |
| TMethodCall | Method or function calling interface |
| TMLPAnalyzer | |
| TMonitor | |
| TMrbSubevent_Caen | |
| TUsrSevtData1 | |
| TUsrSevtData2 | |
| TMultiLayerPerceptron | |
| TMutexImp | |
| TPosixMutex | |
| TWin32Mutex | |
| TMVA::Configurable | |
| TMVA::Factory | |
| TMVA::FitterBase | |
| TMVA::GeneticFitter | |
| TMVA::MCFitter | |
| TMVA::MinuitFitter | |
| TMVA::SimulatedAnnealingFitter | |
| TMVA::MethodBase | |
| TMVA::PDF | |
| TMVA::Reader | |
| TMVA::DataSetInfo | |
| TMVA::MsgLogger | |
| TMVA::OptionBase | |
| TMVA::Option< T > | |
| TMVA::Option< T * > | |
| TMVA::PDEFoam | |
| TMVA::PDEFoamDiscriminant | |
| TMVA::PDEFoamDecisionTree | |
| TMVA::PDEFoamEvent | |
| TMVA::PDEFoamMultiTarget | |
| TMVA::PDEFoamTarget | |
| TMVA::PDEFoamCell | |
| TMVA::PDEFoamDensityBase | |
| TMVA::PDEFoamDecisionTreeDensity | |
| TMVA::PDEFoamDiscriminantDensity | |
| TMVA::PDEFoamEventDensity | |
| TMVA::PDEFoamTargetDensity | |
| TMVA::PDEFoamKernelBase | |
| TMVA::PDEFoamKernelGauss | |
| TMVA::PDEFoamKernelLinN | |
| TMVA::PDEFoamKernelTrivial | |
| TMVA::PDEFoamVect | |
| TMVA::RootFinder | |
| TMVA::TNeuron | |
| TMVA::TSynapse | |
| TMVA::VariableTransformBase | |
| TMVA::VariableDecorrTransform | |
| TMVA::VariableGaussTransform | |
| TMVA::VariableIdentityTransform | |
| TMVA::VariableNormalizeTransform | |
| TMVA::VariablePCATransform | |
| TMVA::VariableRearrangeTransform | |
| TNamed | Base class for all named ROOT classes |
| RooAbsArg | 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 |
| RooAbsBinning | RooAbsBinning is the abstract base class for RooRealVar binning definitions This class defines the interface to retrieve bin boundaries, ranges etc |
| RooAbsData | RooAbsData is the common abstract base class for binned and unbinned datasets |
| RooAbsDataStore | RooAbsDataStore is the abstract base class for data collection that use a TTree as internal storage mechanism |
| RooAbsGenContext | RooAbsGenContext is the abstract base class for generator contexts of RooAbsPdf objects |
| RooAbsMCStudyModule | RooAbsMCStudyModule is a base class for add-on modules to RooMCStudy that can perform additional calculations on each generate+fit cycle managed by RooMCStudy |
| RooChi2MCSModule | 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 |
| RooDLLSignificanceMCSModule | 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) |
| RooRandomizeParamMCSModule | RooRandomizeParamMCSModule is an add-on modules to RooMCStudy that allows you to randomize input generation parameters |
| RooStats::UpperLimitMCSModule | This class allow to compute in the ToyMcStudy framework the ProfileLikelihood upper limit for each toy-MC sample generated |
| RooAbsNumGenerator | Class RooAbsNumGenerator is the abstract base class for MC event generator implementations like RooAcceptReject and RooFoam |
| RooAbsStudy | RooAbsStudy is an abstract base class for RooStudyManager modules |
| RooGenFitStudy | RooGenFitStudy is an abstract base class for RooStudyManager modules |
| RooStats::ToyMCStudy | ToyMCStudy is an implementation of RooAbsStudy for toy Monte Carlo sampling |
| RooArgProxy | RooArgProxy is the abstact interface for RooAbsArg proxy classes |
| RooClassFactory | RooClassFactory is a clase like TTree::MakeClass() that generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names |
| RooCmdArg | 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 |
| RooCustomizer | |
| RooDouble | RooDouble is a minimal implementation of a TObject holding a Double_t value |
| RooFactoryWSTool | RooFactoryWSTool is a clase like TTree::MakeClass() that generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names |
| RooFitResult | |
| RooInt | RooInt is a minimal implementation of a TObject holding a Int_t value |
| RooMapCatEntry | |
| RooMCStudy | 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 |
| RooNameReg | RooNameReg is a registry for 'const char*' name |
| RooPlot | A RooPlot is a plot frame and a container for graphics objects within that frame |
| RooSimWSTool | |
| RooSimWSTool::SplitRule | |
| RooStats::BayesianCalculator | BayesianCalculator is a concrete implementation of IntervalCalculator, providing the computation of a credible interval using a Bayesian method |
| RooStats::ConfidenceBelt | ConfidenceBelt is a concrete implementation of the ConfInterval interface |
| RooStats::ConfInterval | ConfInterval is an interface class for a generic interval in the RooStats framework |
| RooStats::LikelihoodInterval | LikelihoodInterval is a concrete implementation of the RooStats::ConfInterval interface |
| RooStats::PointSetInterval | PointSetInterval is a concrete implementation of the ConfInterval interface |
| RooStats::SimpleInterval | |
| RooStats::HypoTestInverterResult | HypoTestInverterResult class: holds the array of hypothesis test results and compute a confidence interval |
| RooStats::HistFactory::Measurement | |
| RooStats::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 |
| RooStats::HybridCalculatorOriginal | HybridCalculatorOriginal class |
| RooStats::HybridPlot | This class provides the plots for the result of a study performed with the HybridCalculatorOriginal class |
| RooStats::HypoTestInverterOriginal | This class is now depratcated and to be replaced by the HypoTestInverter |
| RooStats::HypoTestInverterPlot | Class to plot an HypoTestInverterResult, result of the HypoTestInverter calculator |
| RooStats::HypoTestResult | HypoTestResult is a base class for results from hypothesis tests |
| RooStats::HybridResult | |
| RooStats::LikelihoodIntervalPlot | This class provides simple and straightforward utilities to plot a LikelihoodInterval object |
| RooStats::MarkovChain | Stores the steps in a Markov Chain of points |
| RooStats::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 |
| RooStats::MCMCIntervalPlot | This class provides simple and straightforward utilities to plot a MCMCInterval object |
| RooStats::ModelConfig | ModelConfig is a simple class that holds configuration information specifying how a model should be used in the context of various RooStats tools |
| RooStats::SamplingDistPlot | This class provides simple and straightforward utilities to plot SamplingDistribution objects |
| RooStats::SamplingDistribution | This class simply holds a sampling distribution of some test statistic |
| RooStats::SPlot | This class calculates sWeights used to create an sPlot |
| RooStats::ToyMCPayload | |
| RooStudyManager | RooStudyManager is a utility class to manage studies that consist of repeated applications of generate-and-fit operations on a workspace |
| RooStudyPackage | RooStudyPackage is a utility class to manage studies that consist of repeated applications of generate-and-fit operations on a workspace |
| ROOT::Internal::TBranchDescriptor | |
| ROOT::Internal::TBranchProxyClassDescriptor | |
| ROOT::Internal::TBranchProxyDescriptor | |
| ROOT::Internal::TFriendProxyDescriptor | |
| ROOT::Internal::THnBaseBrowsable | TBrowser helper for THnBase |
| ROOT::TSchemaRule::TSources | |
| ROOT::v5::TFormula | |
| RooFormula | RooFormula an implementation of ROOT::v5::TFormula that interfaces it to RooAbsArg value objects |
| ROOT::v5::TF1Data | |
| TTreeFormula | Used to pass a selection expression to the Tree drawing routine |
| ROOT::v5::TFormulaPrimitive | |
| RooTable | RooTable is the abstract interface for table objects |
| RooTObjWrap | RooInt is a minimal implementation of a TNamed holding a TObject |
| RooUnitTest | 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 |
| RooWorkspace | The RooWorkspace is a persistable container for RooFit projects |
| TAlienDirectory | |
| TAlienDirectoryEntry | |
| TApplicationRemote::TARFileStat | |
| TAttParticle | Particle definition, partly based on GEANT3 particle definition |
| TAxis | Class to manage histogram axis |
| TAxis3D | The 3D axis painter class |
| TBenchmark | This class is a ROOT utility to help benchmarking applications |
| TBranch | A TTree is a list of TBranches |
| TBrowser | Using a TBrowser one can browse all ROOT objects |
| TBrowserPlugin | |
| TChainElement | A TChainElement describes a component of a TChain |
| TClassTree | Draw inheritance tree and their relations for a list of classes |
| TColor | The color creation and management class |
| TColorGradient | TColorGradient extends basic TColor |
| TLinearGradient | Define a linear color gradient |
| TRadialGradient | Define a radial color gradient |
| TColorWheel | Draw the ROOT Color Wheel |
| TContextMenu | This class provides an interface to context sensitive popup menus |
| TEveContextMenu | Specialization of TContext menu |
| TControlBarButton | Created by the TControlBar |
| TControlBar | A Control Bar is a fully user configurable tool which provides fast access to frequently used operations |
| TCut | A specialized string object used for TTree selections |
| TDatabasePDG | Particle database manager class |
| TDataSet | |
| TChair | |
| TColumnView | |
| TFileSet | |
| TObjectSet | |
| TVolume | |
| TVolumeView | |
| TTable | |
| TGenericTable | |
| TResponseTable | |
| TIndexTable | |
| TTableDescriptor | |
| TDictionary | This class defines an abstract interface that must be implemented by all classes that contain dictionary information |
| TBaseClass | Each class (see TClass) has a linked list of its base class(es) |
| TClass | The ROOT global object gROOT contains a list of all defined classes |
| TQClass | |
| TDataMember | All ROOT classes may have RTTI (run time type identification) support added |
| TDataType | Basic data type descriptor (datatype information is obtained from CINT) |
| TEnum | Implements the enum type |
| TFunction | Global functions class (global functions are obtained from CINT) |
| TMethod | Each ROOT class (see TClass) has a linked list of methods |
| TFunctionTemplate | Dictionary for function template This class describes one single function template |
| TGlobal | Global variables class (global variables are obtained from CINT) |
| TEnumConstant | Implements the constants of the enum type |
| TGlobalMappedFunction | |
| TMethodArg | Each ROOT method (see TMethod) has a linked list of its arguments |
| TDirectory | Describe directory structure in memory |
| TDirectoryFile | A ROOT file is structured in Directories (like a file system) |
| RooWorkspace::WSDir | |
| TFile | A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format |
| TChirpFile | Read and write data via a Chirp server |
| TDavixFile | |
| TDCacheFile | 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/ |
| TGFALFile | Read and write data via the underlying Grid access mechanism |
| THDFSFile | Reads and writes its data via the HDFS protocols |
| TMemFile | A TMemFile is like a normal TFile except that it reads and writes only from memory |
| TParallelMergingFile | |
| TNetFile | |
| TCastorFile | A TNetFile interfaced to the Castor storage backend |
| TXNetFile | |
| TAlienFile | |
| TNetXNGFile | |
| TRFIOFile | A ROOT file that reads/writes via a rfiod server |
| TSQLFile | Access an SQL db via the TFile interface |
| TWebFile | |
| TS3WebFile | |
| TXMLFile | |
| TROOT | ROOT top level object description |
| TDocDirective | |
| TDocHtmlDirective | |
| TDocLatexDirective | |
| TDocMacroDirective | |
| TDSet | This class implements a data set to be used for PROOF processing |
| TDSetProxy | |
| TDSetElement | Manages an element of a TDSet |
| TEfficiency | Class to handle efficiency histograms |
| TEntryList | A List of entry numbers in a TTree or TChain |
| TEntryListArray | A list of entries and subentries in a TTree or TChain |
| TEntryListArray | A list of entries and subentries in a TTree or TChain |
| TEntryListFromFile | Manages entry lists from different files, when they are not loaded in memory at the same time |
| TEveArrow | Class used for display of a thick arrow |
| TEveCaloData | A central manager for calorimeter event data |
| TEveCaloViz | Base class for calorimeter data visualization |
| TEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
| TEveElementList | A list of TEveElements |
| TEveGeoShapeExtract | Globally positioned TGeoShape with rendering attributes and an optional list of daughter shape-extracts |
| TEventIterTree::TFileTree | |
| TEventList | A TEventList object is a list of selected events (entries) in a TTree |
| TEveParamList | Collection of named parameters |
| TEvePointSetArray | An array of point-sets with each point-set playing a role of a bin in a histogram |
| TEveProjectionAxes | Axes for non-linear projections |
| TEveSceneInfo | TEveUtil representation of TGLSceneInfo |
| TEveStraightLineSet | Set of straight lines with optional markers along the lines |
| TEveText | TEveElement class used for displaying FreeType GL fonts |
| TExec | TExec is a utility class that can be used to execute a C++ command when some event happens in a pad |
| TF1 | 1-Dim function class |
| TFileCollection | Class that contains a list of TFileInfo's and accumulated meta data information about its entries |
| TFileDrawMap | This class is automatically called by TFile::DrawMap |
| TFileInfo | Class describing a generic file including meta information |
| TFileInfoMeta | |
| TFileOpenHandle | Class holding info about the file being opened |
| TFileStager | |
| TNetFileStager | |
| TNetXNGFileStager | |
| TXNetFileStager | |
| TFitResult | Extends the ROOT::Fit::Result class with a TNamed inheritance providing easy possibility for I/O |
| TFITSHDU | FITS file interface class |
| TFolder | A TFolder object is a collection of objects and folders |
| TFormula | The F O R M U L A class |
| TFriendElement | A TFriendElement TF describes a TTree object TF in a file |
| TGenerator | The interface to various event generators |
| TPythia6 | TPythia is an interface class to F77 version of Pythia 6.2 |
| TPythia8 | TPythia8 is an interface class to C++ version of Pythia 8.1 event generators, written by T.Sjostrand |
| TGeoElement | |
| TGeoElementRN | |
| TGeoIsotope | |
| TGeoManager | |
| TGeoMaterial | |
| TGeoMatrix | |
| TGeoCombiTrans | |
| TGeoGenTrans | |
| TGeoHMatrix | |
| TGeoIdentity | |
| TGeoRotation | |
| TGeoScale | |
| TGeoTranslation | |
| TGeoMedium | |
| TGeometry | TGeometry description |
| TGeoNode | |
| TGeoOverlap | |
| TGeoParallelWorld | |
| TGeoPhysicalNode | |
| TGeoPNEntry | |
| TGeoShape | |
| TGeoBBox | |
| TEveGeoPolyShape | Description of TEveGeoPolyShape |
| TGeoArb8 | |
| TGeoTrap | |
| TGeoGtra | |
| TGeoCompositeShape | |
| TGeoCone | |
| TGeoConeSeg | |
| TGeoHalfSpace | |
| TGeoPara | |
| TGeoParaboloid | |
| TGeoPcon | |
| TGeoPgon | |
| TGeoScaledShape | |
| TGeoShapeAssembly | |
| TGeoSphere | |
| TGeoTorus | |
| TGeoTrd1 | |
| TGeoTrd2 | |
| TGeoTube | |
| TGeoEltu | |
| TGeoHype | |
| TGeoTubeSeg | |
| TGeoCtub | |
| TGeoXtru | |
| TGeoVolume | |
| TGEventHandler | |
| TGLEventHandler | Base-class and default implementation of event-handler for TGLViewer |
| TEveLegoEventHandler | A base class of TGLEventHandler |
| TGFont | |
| TGL5DDataSet | |
| TGLManager | |
| TGOSXGLManager | |
| TGWin32GLManager | |
| TGWin32GLManagerProxy | |
| TX11GLManager | The TX11GLManager is X11 implementation of TGLManager |
| TGLParametricEquation | A parametric surface is a surface defined by a parametric equation, involving two parameters (u, v): |
| TGLTH3Slice | A slice of a TH3 |
| TGraph | A Graph is a graphics object made of two arrays X and Y with npoints each |
| TGraph2D | Graphics object made of three arrays X, Y and Z with the same number of points each |
| TGraphDelaunay | TGraphDelaunay generates a Delaunay triangulation of a TGraph2D |
| TGraphDelaunay2D | TGraphDelaunay2D generates a Delaunay triangulation of a TGraph2D |
| TGraphNode | A graph node object which can be added in a TGraphStruct |
| TGraphPolargram | To draw polar axis |
| TGraphSmooth | A helper class to smooth TGraph |
| TGraphTime | TGraphTime is used to draw a set of objects evolving with nsteps in time between tmin and tmax |
| TGridJobStatus | |
| TAlienJobStatus | |
| TAlienMasterJobStatus | |
| TGLiteJobStatus | |
| TGuiBldAction | |
| TGuiFactory | This ABC is a factory for GUI components |
| TQtRootGuiFactory | |
| TRootGuiFactory | |
| TQRootGuiFactory | |
| TH1 | The TH1 histogram class |
| THbookFile | This class is an interface to the Hbook objects in Hbook files |
| THbookKey | HBOOK Key |
| THnBase | Multidimensional histogram base |
| THn | Multidimensional histogram |
| THnT< T > | Templated implementation of the abstract base THn |
| THnSparse | Efficient multidimensional histogram |
| THnSparseT< CONT > | Templated implementation of the abstract base THnSparse |
| THStack | The Histogram stack class |
| THttpEngine | |
| TCivetweb | |
| TFastCgi | |
| THttpServer | |
| TImage | An abstract interface to image processing library |
| TInterpreter | This class defines an abstract interface to a generic command line interpreter |
| TCling | This class defines an interface to the cling C++ interpreter |
| TKDE | Kernel Density Estimation class |
| TKey | Book space in a file, create I/O buffers, to fill them, (un)compress them |
| TBasket | Manages buffers for branches of a Tree |
| TBasketSQL | Implement TBasket for a SQL backend |
| TKeySQL | TKeySQL represents metainforamtion about object, which was written to SQL database |
| TKeyXML | |
| TKeyMapFile | Utility class for browsing TMapFile objects |
| TLDAPAttribute | |
| TLeaf | A TLeaf describes individual elements of a TBranch See TBranch structure in TTree |
| TLeafB | A TLeaf for an 8 bit Integer data type |
| TLeafC | A TLeaf for a variable length string |
| TLeafD | A TLeaf for a 64 bit floating point data type |
| TLeafElement | A TLeaf for the general case when using the branches created via a TStreamerInfo (i.e |
| TLeafF | A TLeaf for a 32 bit floating point data type |
| TLeafI | A TLeaf for an Integer data type |
| TLeafL | A TLeaf for a 64 bit Integer data type |
| TLeafO | A TLeaf for a bool data type |
| TLeafObject | A TLeaf for a general object derived from TObject |
| TLeafS | A TLeaf for a 16 bit Integer data type |
| TLibraryDocInfo | |
| TMacro | Class supporting a collection of lines with C++ code |
| TEveMacro | Sub-class of TMacro, overriding Exec to unload the previous version and cleanup after the execution |
| TMaterial | Manages a detector material |
| TMessageHandler | Handle messages that might be generated by the system |
| TMinuit | Implementation in C++ of the Minuit package written by F |
| TMVA::MinuitWrapper | |
| TMinuit2TraceObject | |
| TModuleDocInfo | |
| TMonaLisaText | |
| TMonaLisaValue | |
| TMultiDimFit | Multidimensional Fits in ROOT |
| TMultiGraph | A TMultiGraph is a collection of TGraph (or derived) objects |
| TMVA::MethodInfo | |
| TNeuron | |
| TNode | TNode description |
| TParallelCoord | Parallel Coordinates class |
| TParallelCoordRange | A TParallelCoordRange is a range used for parallel coordinates plots |
| TParallelCoordVar | TParallelCoord axes |
| TParticleClassPDG | Utility class used internally by TDatabasePDG |
| TParticlePDG | Description of the static properties of a particle |
| TPie | Draw a Pie Chart, |
| TPieSlice | A slice of a piechart, see the TPie class |
| TPrincipal | Principal Components Analysis (PCA) |
| TProcessID | A TProcessID identifies a ROOT job in a unique way in time and space |
| TProcessUUID | This class is a specialized TProcessID managing the list of UUIDs |
| TProof | This class controls a Parallel ROOT Facility, PROOF, cluster |
| TProofCondor | |
| TProofLite | This class starts a PROOF session on the local machine: no daemons, client and master merged, communications via UNIX-like sockets |
| TProofSuperMaster | Implementation of TProof controlling PROOF federated clusters |
| TProofDesc | |
| TProofLockPath | |
| TProofLog | Implementation of the PROOF session log handler |
| TProofLogElem | |
| TProofMgr | 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 |
| TProofMgrLite | Basic TProofMgr functionality implementation in the case of Lite session |
| TXProofMgr | Implementation of the functionality provided by TProofMgr in the case of a xproofd-based session |
| TProofMonSender | Provides the interface for PROOF monitoring to different writers |
| TProofMonSenderML | TProofMonSender implementation for the ML writer |
| TProofMonSenderSQL | TProofMonSender implementation for the SQL writers |
| TProofMonSender::TDSetPlet | |
| TProofOutputFile | Class to steer the merging of files produced on the workers |
| TProofPerfAnalysis | Set of tools to analyse the performance tree |
| TProofVectorContainer< T > | |
| TProofVectorContainer< TProofDrawListOfGraphs::Point3D_t > | |
| TProofVectorContainer< TProofDrawListOfPolyMarkers3D::Point4D_t > | |
| TProtoClass | Persistent version of a TClass |
| TQueryResult | A container class for query results |
| TProofQueryResult | TQueryResult version adapted to PROOF neeeds |
| TRandom | This is the base class for the ROOT Random number generators |
| TRandom1 | The Ranlux Random number generator class |
| TRandom2 | Random number generator class based on the maximally quidistributed combined Tausworthe generator by L'Ecuyer |
| TRandom3 | Random number generator class based on M |
| TRemoteObject | Protocol for browsing ROOT objects from a remote ROOT session |
| TRootSniffer | |
| TRotMatrix | Manages a detector rotation matrix |
| TShape | This is the base class for all geometry shapes |
| TSocket | |
| TPSocket | |
| TServerSocket | |
| TPServerSocket | |
| TSSLSocket | |
| TXSocket | High level handler of connections to XProofD |
| TXUnixSocket | Implementation of TXSocket using PF_UNIX sockets |
| TSpectrum | Advanced Spectra Processing |
| TSpectrum2 | Advanced 2-dimensional spectra processing |
| TSpectrum2Fit | Advanced 2-dimensional spectra fitting functions |
| TSpectrum2Painter | |
| TSpectrum3 | Advanced 3-dimensional spectra processing functions |
| TSpectrumFit | Advanced 1-dimensional spectra fitting functions |
| TSpectrumTransform | Advanced 1-dimensional orthogonal transform functions |
| TSpline | Base class for spline implementation containing the Draw/Paint methods // |
| TSQLColumnInfo | |
| TSQLTableInfo | |
| TStatus | This class holds the status of an ongoing operation and collects error messages |
| TStreamerElement | |
| TStreamerArtificial | |
| TStreamerBase | |
| TStreamerBasicPointer | |
| TStreamerBasicType | |
| TStreamerLoop | |
| TStreamerObject | |
| TStreamerObjectAny | |
| TStreamerObjectAnyPointer | |
| TStreamerObjectPointer | |
| TStreamerSTL | |
| TStreamerSTLstring | |
| TStreamerString | |
| TStructNodeProperty | |
| TStyle | TStyle objects may be created to define special styles |
| TSystem | Abstract base class defining a generic interface to the underlying Operating System |
| TAlienSystem | |
| TChirpSystem | |
| TDavixSystem | |
| TDCacheSystem | |
| TGFALSystem | Directory handler for GFAL |
| THDFSSystem | Directory handler for HDFS (THDFSFile) |
| TNetSystem | |
| TXNetSystem | |
| TNetXNGSystem | |
| TRFIOSystem | Directory handler for RFIO |
| TUnixSystem | |
| TMacOSXSystem | |
| TWebSystem | |
| TWinNTSystem | |
| TSystemFile | A TSystemFile describes an operating system file |
| TSystemDirectory | Describes an Operating System directory for the browser |
| TTableSorter | |
| TTask | TTask is a base class that can be used to build a complex tree of Tasks |
| TText | Base class for several text objects |
| TThread | |
| TThreadFactory | |
| TPosixThreadFactory | |
| TWin32ThreadFactory | |
| TToggle | This class defines toggling facility for both - object's method or variables |
| TToggleGroup | This class defines check-box facility for TToggle objects It is used in context menu "selectors" for picking up a value |
| TTree | A TTree object has a header with a name and a title |
| TUDPSocket | |
| TUnfoldBinning | This class serves as a container of analysis bins analysis bins are specified by defining the axes of a distribution |
| TVirtualBranchBrowsable | TVirtualBranchBrowsable is a base class (not really abstract, but useless by itself) for helper objects that extend TBranch's browsing support |
| TCollectionPropertyBrowsable | 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 |
| TMethodBrowsable | This helper object allows the browsing of methods of objects stored in branches |
| TCollectionMethodBrowsable | TCollectionMethodBrowsable extends TCollectionPropertyBrowsable by showing all methods of the collection itself |
| TNonSplitBrowsable | Allows a TBrowser to browse non-split branches as if they were split |
| TVirtualFitter | Abstract Base Class for Fitting |
| TBackCompFitter | Backward compatible implementation of TVirtualFitter |
| TFitter | |
| TFumili | |
| TLinearFitter | The Linear Fitter - For fitting functions that are LINEAR IN PARAMETERS |
| TVirtualIndex | Abstract interface for Tree Index |
| TChainIndex | A Chain Index |
| TTreeIndex | A Tree Index with majorname and minorname |
| TVirtualMagField | |
| TGeoUniformMagField | |
| TVirtualMC | Abstract Monte Carlo interface |
| TVirtualMCApplication | Interface to a user Monte Carlo application |
| TVirtualMCGeometry | Interface to Monte Carlo geometry construction |
| TGeoMCGeometry | Implementation of the TVirtualMCGeometry interface for building TGeo geometry |
| TVirtualMonitoringReader | |
| TVirtualMonitoringWriter | |
| TMonaLisaWriter | |
| TSQLMonitoringWriter | |
| TVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
| TVirtualStreamerInfo | Abstract Interface class describing Streamer information for one class |
| TStreamerInfo | Describe Streamer information for one class version |
| TVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
| TXrdClientAdminWrapper | |
| TNDArray | |
| TNDArrayT< T > | |
| TNDArrayT< Double_t > | |
| TObjectRefSpy | |
| TObjectSpy | Monitors objects for deletion and reflects the deletion by reverting the internal pointer to zero |
| TObjectTable | This class registers all instances of TObject and its derived classes in a hash table |
| TObjString | Collectable string class |
| TClass::TNameMapNode | |
| TOptionListItem | |
| TOutputListSelectorDataMap | Set the selector's data members to the corresponding elements of the output list |
| TPackageDescription | |
| TPainter3dAlgorithms | The Legos and Surfaces painter class |
| TPair< A, B > | Class used by TMap to store (key,value) pairs |
| TParameter< AParamType > | Named parameter, streamable and storable |
| TParameter< Long64_t > | |
| TSelectorScalar | Named scalar type, based on Long64_t, streamable, storable and mergable |
| TParticle | Description of the dynamic properties of a particle |
| TPBHandleDSType | |
| TPBHistType | |
| TPBReadType | |
| TPerfEvent | |
| TPluginHandler | |
| TPluginManager | This class implements a plugin library manager |
| TPoints3DABC | Abstract class to define Arrays of 3D points |
| TPoints3D | |
| TPointsArray3D | |
| TTablePoints | |
| TTable3Points | |
| TPolyLine | Defined by an array on N points in a 2-D space |
| TPolyLine3D | A 3-dimensional polyline |
| TPolyMarker | A PolyMarker is defined by an array on N points in a 2-D space |
| TPolyMarker3D | A 3D polymarker |
| TPrimary | Old version of a dynamic particle class created by event generators |
| TProofBench | Steering class for PROOF benchmarks |
| TProofBenchDataSet | Handle operations on datasets used by ProofBench |
| TProofBenchRun | Abstract base class for PROOF benchmark runs |
| TProofBenchRunCPU | CPU-intensive PROOF benchmark test generates events and fill 1, 2, or 3-D histograms |
| TProofBenchRunDataRead | I/O-intensive PROOF benchmark test reads in event files distributed on the cluster |
| TProofNodeInfo | The purpose of this class is to provide a complete node description for masters, submasters and workers |
| TProofNodes | PROOF worker node information |
| TProofProgressInfo | |
| TProofProgressStatus | Container class for processing statistics |
| TProofResources | |
| TProofResourcesStatic | The purpose of this class is to provide a standard interface to static config files |
| TPyDispatcher | |
| TQpDataBase | |
| TQpDataDens | |
| TQpDataSparse | |
| TQpLinSolverBase | |
| TQpLinSolverDens | |
| TQpLinSolverSparse | |
| TQpProbBase | |
| TQpProbDens | |
| TQpProbSparse | |
| TQpResidual | |
| TQpSolverBase | |
| TGondzioSolver | |
| TMehrotraSolver | |
| TQpVar | |
| TQuaternion | |
| TQueryDescription | |
| TQueryResultManager | Class managing the query-result area |
| Track | |
| TRealData | Manages the effective list of all data members for a given class |
| TRecEvent | |
| TRecCmdEvent | |
| TRecExtraEvent | |
| TRecGuiEvent | |
| TRecorder | |
| TRecWinPair | |
| TRef | Persistent Reference link to a TObject A TRef is a lightweight object pointing to any TObject |
| TRefTable | A TRefTable maintains the association between a referenced object and the parent object supporting this referenced object |
| TRobustEstimator | |
| TRolke | |
| TRootSnifferStore | Abstract interface for storage of hierarchy scan in TRootSniffer |
| TRootSnifferStoreJson | Storage of hierarchy scan in TRootSniffer in JSON format |
| TRootSnifferStoreXml | Storage of hierarchy scan in TRootSniffer in XML format |
| TRotation | |
| TRWLock | |
| TS3HTTPRequest | |
| TSecContext | |
| TRootSecContext | |
| TSecContextCleanup | |
| TSelector | A TSelector object is used by the TTree::Draw, TTree::Scan, TTree::Process to navigate in a TTree and make selections |
| h1analysis | |
| h1analysisTreeReader | |
| RooProofDriverSelector | |
| TProofDraw | Implement Tree drawing using PROOF |
| TProofDrawEntryList | |
| TProofDrawEventList | |
| TProofDrawGraph | |
| TProofDrawHist | |
| TProofDrawListOfGraphs | |
| TProofDrawListOfPolyMarkers3D | |
| TProofDrawPolyMarker3D | |
| TProofDrawProfile | |
| TProofDrawProfile2D | |
| TPySelector | |
| TSelectorCint | This class is a special version of TSelector for user interpreted classes |
| TSelectorDraw | A specialized TSelector for TTree::Draw |
| TEvePointSelector | TEvePointSelector is a sub-class of TSelectorDraw for direct extraction of point-like data from a Tree |
| TEveSelectorToEventList | TSelector that stores entry numbers of matching TTree entries into an event-list |
| TSelectorEntries | The class is derived from the ROOT class TSelector |
| TSelEvent | Selector for PROOF I/O benchmark test |
| TSelEventGen | Selector for event file generation |
| TSelHandleDataSet | PROOF selector for file cache release |
| TSelHist | PROOF selector for CPU-intensive benchmark test |
| TSelVerifyDataSet | Selector to verify dataset in parallel on workers |
| TSemaphore | |
| TSessionDescription | |
| TSlave | Class describing a PROOF worker server |
| TSlaveLite | Version of TSlave for local worker servers |
| TXSlave | This is the version of TSlave for workers servers based on XProofD |
| TSlaveInfo | |
| TSpectrum2Transform | Advanced 2-dimensional orthogonal transform functions |
| TSpider | Spider class |
| TSplinePoly | |
| TSplinePoly3 | |
| TSplinePoly5 | |
| TSPlot | |
| TSQLClassColumnInfo | |
| TSQLClassInfo | Contains information about tables specific to one class and version |
| TSQLColumnData | |
| TSQLObjectData | TSQLObjectData is used in TBufferSQL2 class in reading procedure |
| TSQLObjectDataPool | XML object keeper class |
| TSQLObjectInfo | Info (classname, version) about object in database |
| TSQLResult | |
| TMySQLResult | |
| TODBCResult | |
| TOracleResult | |
| TPgSQLResult | |
| TSapDBResult | |
| TSQLiteResult | |
| TTreeResult | Class defining interface to a TTree query result with the same interface as for SQL databases |
| TSQLRow | |
| TMySQLRow | |
| TODBCRow | |
| TOracleRow | |
| TPgSQLRow | |
| TSapDBRow | |
| TSQLiteRow | |
| TTreeRow | Class defining interface to a row of a TTree query result |
| TSQLServer | |
| TMySQLServer | |
| TODBCServer | |
| TOracleServer | |
| TPgSQLServer | |
| TSapDBServer | |
| TSQLiteServer | |
| TSQLStatement | |
| TMySQLStatement | |
| TODBCStatement | |
| TOracleStatement | |
| TPgSQLStatement | |
| TSQLiteStatement | |
| TSQLStructure | This is hierarhical structure, which is created when data is written by TBufferSQL2 |
| TSQLTableData | |
| TStatistic | Statistical variable, defined by its mean and variance (RMS) |
| TStatsFeedback | Utility class to display PROOF stats feedback histos during queries |
| TStopwatch | Stopwatch class |
| TMVA::Timer | |
| TStreamerInfoActions::TActionSequence | |
| TStreamerInfoActions::TConfiguredAction | |
| TStructNode | |
| TStructViewer | |
| TSVDUnfold | SVD Approach to Data Unfolding |
| TSynapse | |
| TSysEvtHandler | Abstract base class for handling system events |
| TFileHandler | |
| TASLogHandler | |
| TProofInputHandler | |
| TProofServLogHandler | |
| TXSocketHandler | Input handler for XProofD sockets |
| TSignalHandler | |
| TARInterruptHandler | |
| TProofInterruptHandler | |
| TStdExceptionHandler | |
| TEveManager::TExceptionHandler | Exception handler for Eve exceptions |
| TTimer | Handles synchronous and a-synchronous timer events |
| TGLRedrawTimer | |
| TIdleTOTimer | |
| TProcessEventTimer | |
| TReaperTimer | |
| TShutdownTimer | |
| TThreadTimer | |
| TViewTimer | |
| TTableIter | |
| TTableMap | |
| TThreadImp | |
| TPosixThread | |
| TWin32Thread | |
| TTreeDrawArgsParser | A class that parses all parameters for TTree::Draw() |
| TTreeFormulaManager | Used to coordinate one or more TTreeFormula objects |
| TTreeReader | TTreeReader is a simple, robust and fast interface to read values from a TTree, TChain or TNtuple |
| TTVRecord | I/O classes for TreeViewer session handling |
| TTVSession | I/O classes for TreeViewer session handling |
| TUnfold | TUnfold is used to decompose a measurement y into several sources x given the measurement uncertainties and a matrix of migrations A |
| TUnfoldSys | TUnfold is used to decompose a measurement y into several sources x given the measurement uncertainties and a matrix of migrations A |
| TUnfoldDensity | |
| TUri | This class represents a RFC 3986 compatible URI |
| TUrl | This class represents a WWW compatible URL |
| TUsrHit | |
| TUsrHitBuffer | |
| TVector2 | |
| TVector3 | |
| TVectorT< Element > | |
| TVectorT< Double_t > | |
| TView | See TView3D |
| TVirtualFFT | TVirtualFFT is an interface class for Fast Fourier Transforms |
| TFFTComplex | |
| TFFTComplexReal | |
| TFFTReal | |
| TFFTRealComplex | |
| TVirtualGeoPainter | |
| TGeoPainter | |
| TVirtualGeoTrack | |
| TVirtualGraphPainter | Abstract interface to a histogram painter |
| TGraphPainter | The graph painter class |
| TVirtualHistPainter | Abstract interface to a histogram painter |
| TGLHistPainter | The histogram painter class using OpenGL |
| THistPainter | The histogram painter class |
| TVirtualMCDecayer | Abstract base class for particle decays |
| TPythia6Decayer | This class implements the TVirtualMCDecayer interface |
| TPythia8Decayer | This class implements the TVirtualMCDecayer interface using TPythia8 |
| TVirtualMCStack | Interface to a user defined particles stack |
| TVirtualMutex | This class implements a mutex interface |
| TMutex | |
| TVirtualPacketizer | The packetizer is a load balancing object created for each query |
| TPacketizer | This class generates packets to be processed on PROOF worker servers |
| TPacketizerAdaptive | This packetizer is based on TPacketizer but uses different load-balancing algorithms and data structures |
| TPacketizerFile | This packetizer generates packets which contain a single file path to be used in process |
| TPacketizerMulti | 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 |
| TPacketizerUnit | 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 |
| TVirtualPacketizer::TVirtualSlaveStat | |
| TVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
| TVirtualPerfStats | Provides the interface for the PROOF internal performance measurement and event tracing |
| TPerfStats | Provides the interface for the PROOF internal performance measurement and event tracing |
| TTreePerfStats | TTree I/O performance measurement |
| TVirtualProofPlayer | Abstract interface for the PROOF player |
| TProofPlayer | Internal class steering processing in PROOF |
| TProofPlayerLocal | |
| TProofPlayerRemote | |
| TProofPlayerLite | Version of TProofPlayerRemote merges the functionality needed by clients and masters |
| TProofPlayerSuperMaster | |
| TProofPlayerSlave | |
| TVirtualTreePlayer | Abstract base class defining the interface for the plugins that implement Draw, Scan, Process, MakeProxy, etc |
| TTreePlayer | Implement some of the functionality of the class TTree requiring access to extra libraries (Histogram, display, etc) |
| TVirtualViewer3D | Abstract 3D shapes viewer |
| TGLScenePad | Implements VirtualViewer3D interface and fills the base-class visualization structures from pad contents |
| TGLViewer | Base GL viewer object - used by both standalone and embedded (in pad) GL |
| TViewer3DPad | Provides 3D viewer interface (TVirtualViewer3D) support on a pad |
| TVolumePosition | |
| TXMLAttr | TXMLAttribute is the attribute of an Element |
| TXMLDocument | TXMLDocument contains a pointer to an xmlDoc structure, after the parser returns a tree built during the document analysis |
| TXMLEngine | |
| TXMLNode | TXMLNode contains a pointer to xmlNode, which is a node under the DOM tree |
| TXMLParser | TXMLParser is an abstract class which interfaces with Libxml2 |
| TDOMParser | |
| TSAXParser | TSAXParser is a subclass of TXMLParser, it is a wraper class to libxml library |
| TXMLPlayer | |
| TObjLink | Wrapper around a TObject so it can be stored in a TList |
| TObjOptLink | |
| ROOT::Internal::TObjProxy< T > | |
| ROOT::Internal::TStlSimpleProxy< T > | |
| TOCCToStep | |
| Memstat::ToLower_t | |
| ToolBarData_t | |
| TMVA::Tools | |
| ROOT::Internal::TOperatorNewHelper | |
| ROOT::v5::TOperOffset | |
| TPaletteEditor | Edit the palette via a GUI |
| TASPaletteEditor | This is a GUI window to edit a color palette |
| TMySQLStatement::TParamData | |
| PyROOT::TParameter | |
| TPickerStackGuard | |
| TPoint | |
| TStreamerInfo::TPointerCollectionAdapter | |
| TPoints | 2-D graphics point (world coordinates) |
| TPosixThreadCleanUp | |
| TPRegexp | |
| TPMERegexp | Wrapper for PCRE library (Perl Compatible Regular Expressions) |
| TProfileHelper | |
| TProofDebug | |
| TProofLockPathGuard | |
| TProofMergePrg | |
| TProofProgressDialog | |
| TProofServLogHandlerGuard | |
| TProtoClass::TProtoRealData | |
| TVirtualCollectionProxy::TPushPop | |
| TPwdCtx | |
| TPyArg | |
| PyROOT::TPyBufferFactory | Factory for python buffers of non-string type |
| TPyReturn | |
| TPythia6::TPythia6Cleaner | Utility class to manage the TPythia6 instance |
| TPython | |
| TQObject | This is the ROOT implementation of the Qt object communication mechanism (see also http://www.troll.no/qt/metaobjects.html) |
| TApplication | This class creates the ROOT Application Environment that interfaces to the windowing system eventloop and eventhandlers |
| TBonjourBrowser | |
| TBonjourRegistrar | |
| TBonjourResolver | |
| TDrawFeedback | Utility class to draw objects in the feedback list during queries |
| TEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
| TEveParamList | Collection of named parameters |
| TEvePointSet | 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) |
| TEveRGBAPalette | A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes |
| TEveSelection | Make sure there is a SINGLE running TEveSelection for each selection type (select/highlight) |
| TEveStraightLineSet | Set of straight lines with optional markers along the lines |
| TEveWindowManager | Manager for EVE windows |
| TGClient | |
| TGEventHandler | |
| TGFrame | |
| TGLOverlayButton | GL-overlay button |
| TGLViewer | Base GL viewer object - used by both standalone and embedded (in pad) GL |
| TGTableFrame | |
| TMessageHandler | Handle messages that might be generated by the system |
| TMonitor | |
| TProof | This class controls a Parallel ROOT Facility, PROOF, cluster |
| TProofLog | Implementation of the PROOF session log handler |
| TQClass | |
| TQCommand | The Command design pattern is based on the idea, that all editing in an application is done by creating instances of command objects |
| TQConnection | TQConnection class is an internal class, used in the object communication mechanism |
| TQObjSender | |
| TStatsFeedback | Utility class to display PROOF stats feedback histos during queries |
| TSysEvtHandler | Abstract base class for handling system events |
| TVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
| TVirtualProofPlayer | Abstract interface for the PROOF player |
| TXMLParser | TXMLParser is an abstract class which interfaces with Libxml2 |
| TrackD | |
| TrackD32 | |
| ROOT::Math::Transform3D | 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 |
| TMVA::TransformationHandler | |
| ROOT::Math::Translation3D | Class describing a 3 dimensional translation |
| ROOT::Math::TransposeOp< Matrix, T, D1, D2 > | Class for Transpose Operations |
| ROOT::Math::TranspPolicy< T, D1, D2, R > | Matrix transpose policy |
| ROOT::Math::TranspPolicy< T, D1, D2, MatRepSym< T, D1 > > | |
| TRecorderState | |
| TRecorderInactive | |
| TRecorderPaused | |
| TRecorderRecording | |
| TRecorderReplaying | |
| TRedirectOutputGuard | |
| TEveManager::TRedrawDisabler | |
| TMVA::TreeInfo | |
| TRefCnt | Definitions for TRefCnt, base class for reference counted objects |
| TGFont | |
| TGGC | |
| TGLayoutHints | |
| TGPicture | |
| TBits::TReference | |
| TRegexp | Regular expression class |
| ROOT::Math::Delaunay2D::Triangle | |
| triangulateio | |
| ROOT::Vc::Trigonometric< Impl > | |
| TRootIOCtor | |
| TRootSnifferScanRec | |
| TRotation::TRotationRow | |
| TRSA_fun | |
| TRuby | |
| ROOT::Internal::TSchemaHelper | |
| ROOT::Internal::TSchemaRuleProcessor | |
| ROOT::Internal::TSchemaType | |
| ROOT::TSeq< T > | A pseudo container class which is a generator of indices |
| Rgl::Mc::TSlice< V > | |
| Rgl::Mc::TSlice< ElementType_t > | |
| Rgl::Mc::TSourceAdapterSelector< class > | |
| Rgl::Mc::TSourceAdapterSelector< TF3 > | |
| Rgl::Mc::TSourceAdapterSelector< TH3C > | |
| Rgl::Mc::TSourceAdapterSelector< TH3D > | |
| Rgl::Mc::TSourceAdapterSelector< TH3F > | |
| Rgl::Mc::TSourceAdapterSelector< TH3I > | |
| Rgl::Mc::TSourceAdapterSelector< TH3S > | |
| Rgl::Mc::TSourceAdapterSelector< TKDEFGT > | |
| TClass::TSpinLockGuard | |
| Rgl::Mc::TSplitterSelector< class, class > | |
| Rgl::Mc::TSplitterSelector< TF3, V > | |
| Rgl::Mc::TSplitterSelector< TH3C, V > | |
| Rgl::Mc::TSplitterSelector< TH3D, V > | |
| Rgl::Mc::TSplitterSelector< TH3F, V > | |
| Rgl::Mc::TSplitterSelector< TH3I, V > | |
| Rgl::Mc::TSplitterSelector< TH3S, V > | |
| Rgl::Mc::TSplitterSelector< TKDEFGT, V > | |
| TClassEdit::TSplitType | |
| TGenCollectionProxy::TStaging | Small helper to stage the content of an associative container when reading and before inserting it in the actual collection |
| ROOT::Internal::TStdBitsetHelper< T > | |
| ROOT::Internal::TStlObjProxy< T > | |
| TStorage | Storage manager |
| TString | Basic string class |
| TEveException | Exception class thrown by TEve classes and macros |
| TGString | |
| TGHotString | |
| TStringLong | ATTENTION: this class is obsolete |
| TStringToken | Provides iteration through tokens of a given string |
| TSubString | A zero length substring is legal |
| TTabCom | |
| TTablePadView3D | |
| TTableRange | |
| TTF | Interface to the freetype 2 library |
| TTF::TTGlyph | TTF helper class containing glyphs description |
| TThreadCleaner | |
| TThreadPoolTask< aTask, aParam > | |
| TThreadPoolTaskImp< aTask, aParam > | |
| TThreadPoolTaskImp< TTestTask, EProc > | |
| TTime | Basic time type with millisecond precision |
| TTimeStamp | The TTimeStamp encapsulates seconds and ns since EPOCH |
| TTreeCloner | Class implementing or helping the various TTree cloning method |
| ROOT::Internal::TTreeGeneratorBase | |
| ROOT::Internal::TTreeProxyGenerator | |
| ROOT::Internal::TTreeReaderGenerator | |
| ROOT::Internal::TTreeReaderValueBase | |
| ROOT::Internal::TTreeReaderArrayBase | |
| TTreeReaderArray< T > | Extracts array data from a TTree |
| TTreeReaderArray< Float_t > | |
| TTreeReaderArray< Int_t > | |
| TTreeReaderValue< T > | Extracts data from a TTree |
| TTreeReaderValue< Float_t > | |
| TTreeReaderValue< Int_t > | |
| TCling::TUniqueString | |
| TGLLockable::TUnlocker | |
| TUnuran | TUnuran class |
| TUnuranBaseDist | TUnuranBaseDist, base class for Unuran distribution classees such as TUnuranContDist (for one-dimension) or TUnuranMultiContDist (multi-dimension) |
| TUnuranContDist | TUnuranContDist class describing one dimensional continuous distribution |
| TUnuranDiscrDist | TUnuranDiscrDist class for one dimensional discrete distribution |
| TUnuranEmpDist | TUnuranEmpDist class for describing empiral distributions |
| TUnuranMultiContDist | TUnuranMultiContDist class describing multi dimensional continuous distributions |
| TUUID | This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDentifier) |
| TVersionCheck | |
| TVirtualArray | 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 |
| TVirtualAuth | |
| TRootAuth | |
| TVirtualCollectionIterators | Small helper class to generically acquire and release iterators |
| TVirtualCollectionProxy | |
| TGenCollectionProxy | Proxy around an arbitrary container, which implements basic functionality and iteration |
| AnyCollectionProxy< T > | |
| TEmulatedCollectionProxy | Streamer around an arbitrary STL like container, which implements basic container functionality |
| TEmulatedMapProxy | Streamer around a map container |
| TGenCollectionStreamer | |
| AnyCollectionStreamer< T > | |
| TVirtualCollectionPtrIterators | |
| ROOT::Internal::TVirtualCollectionReader | |
| TVirtualDragManager | |
| TGuiBldDragManager | |
| TVirtualGLManip | |
| TGLManip | 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 |
| TGLRotateManip | Rotate manipulator - attaches to physical shape and draws local axes widgets - rings drawn from attached physical center, in plane defined by axis |
| TGLScaleManip | Scale manipulator - attaches to physical shape and draws local axes widgets with box heads |
| TGLTransManip | Translation manipulator - attaches to physical shape and draws local axes widgets with arrow heads |
| TVirtualGLPainter | |
| TGLPlotPainter | Base class for plot-painters that provide GL rendering of various 2D and 3D histograms, functions and parametric surfaces |
| TGL5DPainter | TGL5DPainter implements "gl5d" option for TTree::Draw |
| TGLBoxPainter | Paints TH3 histograms by rendering variable-sized boxes matching the bin contents |
| TGLH2PolyPainter | Paint TH2Poly |
| TGLIsoPainter | "gliso" option for TH3 |
| TGLLegoPainter | Plot-painter implementing LEGO rendering of TH2 histograms in cartesian, polar, cylindrical and spherical coordinates |
| TGLParametricPlot | |
| TGLSurfacePainter | Implements painting of TH2 with "SURF" option |
| TGLTF3Painter | Plot-painter for TF3 functions |
| TGLTH3CompositionPainter | |
| TGLVoxelPainter | |
| TVirtualIsAProxy | |
| TInstrumentedIsAProxy< T > | |
| TIsAProxy | TIsAProxy implementation class |
| TVirtualObject | 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 |
| TVirtualPadEditor | Abstract base class used by ROOT graphics editor |
| TGedEditor | |
| TVirtualPadPainter | To make it possible to use GL for 2D graphic in a TPad/TCanvas |
| TGLPadPainter | "Delegating" part of TGLPadPainter |
| TPadPainter | Implement TVirtualPadPainter which abstracts painting operations |
| TVirtualRefProxy | |
| TRefProxy | |
| TRefArrayProxy | A container proxy, which allows to access references stored in a TRefArray from TTree::Draw |
| TVirtualTableInterface | |
| TGSimpleTableInterface | |
| TTreeTableInterface | TTreeTableInterface is used to interface to data that is stored in a TTree |
| TVirtualVectorIterators | |
| TWin32SplashThread | |
| TWin32ThreadCleanUp | |
| TXHandler | Handler of asynchronous events for XProofD sockets |
| TXProofMgr | Implementation of the functionality provided by TProofMgr in the case of a xproofd-based session |
| TXProofServ | This class implements the XProofD version of TProofServ, with respect to which it differs only for the underlying connection technology |
| TXSlave | This is the version of TSlave for workers servers based on XProofD |
| TXMLSetup | |
| TBufferXML | Class for serializing/deserializing object to/from xml |
| TXMLFile | |
| TXNetSystemConnectGuard | |
| TXSemaphoreGuard | |
| TXSockBuf | |
| TXSockPipe | |
| type | |
| cppyy._ns_meta | |
| cppyy._global_cpp | |
| cppyy._stdmeta | |
| cppyy._global_cpp.std | |
| TCollectionProxyInfo::Type | Small helper to encapsulate basic data accesses for all STL continers |
| Type_t | |
| Rgl::Mc::TMeshBuilder< DataSource, ValueType > | |
| Rgl::Mc::TMeshBuilder< TKDEFGT, Float_t > | |
| Type_t | |
| Rgl::Mc::TMeshBuilder< DataSource, ValueType > | |
| Rgl::Mc::TMeshBuilder< TKDEFGT, Float_t > | |
| ROOT::Vc::Common::TypenameForLdexp< T > | |
| ROOT::Vc::Common::TypenameForLdexp< Vc::sfloat > | |
| TMVA::Types | |
| unary_function | |
| hash< std::experimental::basic_string_view< _CharT, _Traits > > | |
| TMVA::compose_unary_t< F, G > | |
| ROOT::Math::UnaryOp< Operator, RHS, T > | UnaryOperation class A class representing unary operators in the parse tree |
| RooRandomizeParamMCSModule::UniParam | |
| RooRandomizeParamMCSModule::UniParamSet | |
| UnuRanDist | |
| UnuranDistr< Function > | UnuranDistr Provides free function based on TF1 to be called by unuran |
| UnuranDistrMulti< Function > | Free functions for multidimensional functions needed bby UNURAN |
| UnuranRng< Random > | UnuranRng class for interface ROOT random generators to Unuran |
| UserGroup_t | |
| TString::UStr_t | |
| TUUID::uuid_time_t | |
| PyROOT::TParameter::Value | |
| TGenCollectionProxy::Value | Small helper to describe the Value_type or the key_type of an STL container |
| TMVA::VariableInfo | |
| ROOT::Minuit2::VariableMetricEDMEstimator | |
| TMVA::Config::VariablePlotting | |
| TMVA::TransformationHandler::VariableStat | |
| TMVA::MethodCFMlpANN_Utils::VARn2 | |
| ROOT::Math::Vavilov | Base class describing a Vavilov distribution |
| ROOT::Math::VavilovAccurate | Class describing a Vavilov distribution |
| ROOT::Math::VavilovFast | Class describing a Vavilov distribution |
| ROOT::Math::VavilovTest | Test class for class Vavilov and its subclasses |
| ROOT::Minuit2::vec | |
| ROOT::Math::VecExpr< ExprType, T, D > | Expression wrapper class for Vector objects |
| ROOT::Vc::AVX::Vector< T > | |
| ROOT::Vc::AVX::SwizzledVector< T > | |
| ROOT::Vc::SSE::Vector< T > | |
| ROOT::Vc::SSE::SwizzledVector< T > | |
| ROOT::Vc::Scalar::Vector< T > | |
| ROOT::Vc::Scalar::SwizzledVector< T > | |
| std::vector< T > | STL class |
| ROOT::Detail::TSchemaRuleSet::TMatches | |
| TGL2DArray< T > | |
| TGL2DArray< Double_t > | |
| TGL2DArray< std::pair< TGLVector3, TGLVector3 > > | |
| TGL2DArray< TGLParametricPlot::Vertex_t > | |
| TGL2DArray< TGLVector3 > | |
| TGL2DArray< TGLVertex3 > | |
| TTableMap | |
| VecTVecDouble | |
| VecVecDouble | |
| ROOT::Vc::Scalar::VectorAlignedBaseT< V > | |
| ROOT::Vc::AVX::VectorHelper< T > | |
| ROOT::Vc::SSE::VectorHelper< T > | |
| ROOT::Vc::SSE::VectorHelper< _M128 > | |
| ROOT::Vc::SSE::VectorHelper< _M128D > | |
| ROOT::Vc::SSE::VectorHelper< _M128I > | |
| ROOT::Vc::AVX::VectorHelper< char > | |
| ROOT::Vc::AVX::VectorHelper< double > | |
| ROOT::Vc::SSE::VectorHelper< double > | |
| ROOT::Vc::AVX::VectorHelper< float > | |
| ROOT::Vc::AVX::VectorHelper< sfloat > | |
| ROOT::Vc::SSE::VectorHelper< float > | |
| ROOT::Vc::SSE::VectorHelper< float8 > | |
| ROOT::Vc::AVX::VectorHelper< int > | |
| ROOT::Vc::SSE::VectorHelper< int > | |
| ROOT::Vc::AVX::VectorHelper< m128i > | |
| ROOT::Vc::SSE::VectorHelper< M256 > | |
| ROOT::Vc::AVX::VectorHelper< m256 > | |
| ROOT::Vc::AVX::VectorHelper< m256d > | |
| ROOT::Vc::AVX::VectorHelper< m256i > | |
| ROOT::Vc::SSE::VectorHelper< signed short > | |
| ROOT::Vc::AVX::VectorHelper< signed short > | |
| ROOT::Vc::AVX::VectorHelper< unsigned char > | |
| ROOT::Vc::SSE::VectorHelper< unsigned int > | |
| ROOT::Vc::AVX::VectorHelper< unsigned int > | |
| ROOT::Vc::SSE::VectorHelper< unsigned short > | |
| ROOT::Vc::AVX::VectorHelper< unsigned short > | |
| ROOT::Vc::SSE::VectorHelperSize< T > | |
| ROOT::Vc::AVX::VectorHelperSize< T > | |
| ROOT::Math::VectorMatrixColOp< Vector, Matrix, D1 > | Class for Vector-Matrix multiplication |
| ROOT::Math::VectorMatrixRowOp< Matrix, Vector, D2 > | |
| VectorMemoryHelper< Vec > | |
| ROOT::Vc::Common::VectorMemoryUnion< _VectorType, _EntryType, VectorTypeBase > | |
| ROOT::Vc::Common::VectorMemoryUnion< VectorType, EntryType > | |
| ROOT::Minuit2::VectorOuterProduct< M, T > | |
| ROOT::Vc::VectorPointerHelper< V, A > | Helper class for the Memory::vector(size_t) class of functions |
| ROOT::Vc::VectorPointerHelperConst< V, A > | Helper class for the Memory::vector(size_t) class of functions |
| ROOT::Vc::SSE::VectorTraits< T > | |
| ROOT::Vc::Common::VectorTuple< Length, V > | |
| ROOT::Vc::Common::VectorTuple< 2, const V > | |
| ROOT::Vc::Common::VectorTuple< 2, V > | |
| ROOT::Vc::AVX::VectorTypeHelper< T > | |
| ROOT::Vc::SSE::VectorTypeHelper< T > | |
| ROOT::Vc::AVX::VectorTypeHelper< char > | |
| ROOT::Vc::SSE::VectorTypeHelper< double > | |
| ROOT::Vc::AVX::VectorTypeHelper< double > | |
| ROOT::Vc::SSE::VectorTypeHelper< float > | |
| ROOT::Vc::AVX::VectorTypeHelper< float > | |
| ROOT::Vc::AVX::VectorTypeHelper< int > | |
| ROOT::Vc::SSE::VectorTypeHelper< sfloat > | |
| ROOT::Vc::AVX::VectorTypeHelper< sfloat > | |
| ROOT::Vc::AVX::VectorTypeHelper< short > | |
| ROOT::Vc::AVX::VectorTypeHelper< unsigned char > | |
| ROOT::Vc::AVX::VectorTypeHelper< unsigned int > | |
| ROOT::Vc::AVX::VectorTypeHelper< unsigned short > | |
| VecTrackD | |
| ROOT::Math::VegasParameters | Structures collecting parameters for VEGAS multidimensional integration FOr implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h |
| TGLParametricPlot::Vertex_t | |
| ROOT::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 |
| ROOT::Math::VirtualIntegratorMultiDim | Interface (abstract) class for multi numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLMCIntegrator |
| ROOT::Math::AdaptiveIntegratorMultiDim | Class for adaptive quadrature integration in multi-dimensions using rectangular regions |
| ROOT::Math::GSLMCIntegrator | |
| ROOT::Math::VirtualIntegratorOneDim | Interface (abstract) class for 1D numerical integration It must be implemented by the concrate Integrator classes like ROOT::Math::GSLIntegrator |
| ROOT::Math::GaussIntegrator | User class for performing function integration |
| ROOT::Math::GaussLegendreIntegrator | User class for performing function integration |
| ROOT::Math::GSLIntegrator | Class for performing numerical integration of a function in one dimension |
| TMVA::Volume | |
| WindowAttributes_t | |
| with_metaclass | |
| cppyy._global_cpp | |
| cppyy._global_cpp.std | |
| ROOT::Vc::Scalar::WriteMaskedVector< T > | |
| ROOT::Vc::AVX::WriteMaskedVector< T > | |
| ROOT::Vc::SSE::WriteMaskedVector< T > | |
| <X11Drawable> | |
| QuartzImage | |
| QuartzPixmap | |
| <X11Window> | |
| QuartzView | |
| QuartzWindow | |
| XColor_t | Description of a X11 color |
| XHandleErr_t | |
| XHandleIn_t | |
| ROOT::MacOSX::X11::XLFDName | |
| XMLReader | |
| XPClientArchiveRequest | |
| XPClientInterruptRequest | |
| XPClientLoginRequest | |
| XPClientProofRequest | |
| XPClientReadbufRequest | |
| XPClientRequest | |
| XPClientSendRcvRequest | |
| XpdAdminCpCmd | |
| XpdClientSessions | |
| XpdEnv | |
| XpdGroupEff_t | |
| XpdGroupGlobal_t | |
| XpdManagerCron_t | |
| XpdMsg | |
| XpdObject | |
| XpdSrvMgrCreateCnt | |
| XpdSrvMgrCreateGuard | |
| XrdClientAbsUnsolMsgHandler | |
| TXSocket | High level handler of connections to XProofD |
| XrdClientConnectionMgr | |
| XrdClientLogConnection | |
| XrdProofConn | |
| XrdProofPhyConn | |
| XrdClientCacheInterval | |
| XrdClientConn | |
| XrdClientID | |
| XrdClientInputBuffer | |
| XrdClientMessage | |
| XrdClientPhyConnLocker | |
| XrdClientReadCache | |
| XrdClientReadCacheItem | |
| XrdClientSock | |
| XrdClientSockConnectParms | |
| XrdClientUnsolMsgSender | |
| XrdClientConnectionMgr | |
| XrdClientLogConnection | |
| XrdClientPhyConnection | |
| XrdJob | |
| XpdObjectQ | |
| XrdPoll | |
| XrdProofdAux | |
| XrdProofdClient | |
| XrdProofdConfig | |
| XrdProofdAdmin | |
| XrdProofdClientMgr | |
| XrdProofdManager | |
| XrdProofdNetMgr | |
| XrdProofdPriorityMgr | |
| XrdProofdProofServMgr | |
| XrdProofSched | |
| XrdROOTMgr | |
| XrdProofdDirective | |
| XrdProofdDSInfo | |
| XrdProofdFile | |
| XrdProofdMultiStr | |
| XrdProofdMultiStrToken | |
| XrdProofdPInfo | |
| XrdProofdPipe | |
| XrdProofdPriority | |
| XrdProofdProofServ | |
| XrdProofdResponse | |
| XrdProofdSandbox | |
| XrdProofdSessionEntry | |
| XrdProofGI | |
| XrdProofGroup | |
| XrdProofGroupMember | |
| XrdProofGroupMgr | |
| XrdProofQuery | |
| XrdProofSessionInfo | |
| XrdProofUI | |
| XrdProofWorker | |
| XrdProtocol | |
| XrdProofdProtocol | |
| XrdROOT | |
| XrdSrvBuffer | |
| XrdSysPriv | |
| XrdSysPrivGuard | |
| XShapeEvent | |
| TGDMLWrite::Xyz | |
| FunctionType | |
| ROOT::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) |
| IPFType | |
| ROOT::Math::ParamFunction< IPFType > | Base template class for all Parametric Functions |
| Magic | |
| JupyROOT.kernel.magics.cppmagic.CppMagics | |
| MetaKernel | |
| JupyROOT.kernel.rootkernel.ROOTKernel | |
| Preprocessor | |
| JupyROOT.html.cpphighlighter.CppHighlighter | |
| VectorAlignedBaseT | |
| ROOT::Vc::Memory< V, Size *Size > | |
| ROOT::Vc::Memory< V, Size1, Size2 > | A helper class for fixed-size two-dimensional arrays |
| ROOT::Vc::Memory< V, Size, 0u > | A helper class to simplify usage of correctly aligned and padded memory, allowing both vector and scalar access |
ROOT 6.07/01 - Reference Guide Generated on Wed Dec 9 2015 00:30:51 using Doxygen 1.8.6.
