C__argb32__ | |
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, N, M > | Struct to do a Cholesky decomposition |
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 0, M > | Struct to do a Cholesky decomposition (specialized, N = 0) |
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 1, M > | Struct to do a Cholesky decomposition (specialized, N = 1) |
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 2, M > | Struct to do a Cholesky decomposition (specialized, N = 2) |
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 3, M > | Struct to do a Cholesky decomposition (specialized, N = 3) |
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 4, M > | Struct to do a Cholesky decomposition (specialized, N = 4) |
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 5, M > | Struct to do a Cholesky decomposition (specialized, N = 5) |
CROOT::Math::CholeskyDecompHelpers::_decomposer< F, 6, M > | Struct to do a Cholesky decomposition (specialized, N = 6) |
CROOT::Math::CholeskyDecompHelpers::_decomposerGenDim< F, M > | Struct to do a Cholesky decomposition (general dimensionality) |
C_EdgeTableEntry | |
CROOT::Math::CholeskyDecompHelpers::_inverter< F, N, M > | Struct to obtain the inverse from a Cholesky decomposition |
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 0, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 0) |
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 1, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 1) |
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 2, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 2) |
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 3, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 3) |
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 4, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 4) |
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 5, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 5) |
CROOT::Math::CholeskyDecompHelpers::_inverter< F, 6, M > | Struct to obtain the inverse from a Cholesky decomposition (N = 6) |
CROOT::Math::CholeskyDecompHelpers::_inverterGenDim< F, M > | Struct to obtain the inverse from a Cholesky decomposition (general dimensionality) |
C_PROCESS_MEMORY_COUNTERS | |
C_root_std_complex< T > | |
C_ScanLineList | |
C_ScanLineListBlock | |
CROOT::Math::CholeskyDecompHelpers::_solver< F, N, V > | Struct to solve a linear system using its Cholesky decomposition |
CROOT::Math::CholeskyDecompHelpers::_solver< F, 0, V > | Struct to solve a linear system using its Cholesky decomposition (N=0) |
CROOT::Math::CholeskyDecompHelpers::_solver< F, 1, V > | Struct to solve a linear system using its Cholesky decomposition (N=1) |
CROOT::Math::CholeskyDecompHelpers::_solver< F, 2, V > | Struct to solve a linear system using its Cholesky decomposition (N=2) |
CROOT::Math::CholeskyDecompHelpers::_solver< F, 3, V > | Struct to solve a linear system using its Cholesky decomposition (N=3) |
CROOT::Math::CholeskyDecompHelpers::_solver< F, 4, V > | Struct to solve a linear system using its Cholesky decomposition (N=4) |
CROOT::Math::CholeskyDecompHelpers::_solver< F, 5, V > | Struct to solve a linear system using its Cholesky decomposition (N=5) |
CROOT::Math::CholeskyDecompHelpers::_solver< F, 6, V > | Struct to solve a linear system using its Cholesky decomposition (N=6) |
CROOT::Math::CholeskyDecompHelpers::_solverGenDim< F, V > | Struct to solve a linear system using its Cholesky decomposition (generalised dimensionality) |
C_x3d_data_ | |
C_x3d_sizeof_ | |
CROOT::Minuit2::ABObj< mtype, M, T > | |
CROOT::Minuit2::ABObj< sym, LASymMatrix, double > | |
CROOT::Minuit2::ABObj< vec, LAVector, double > | |
CROOT::Minuit2::ABProd< M1, M2 > | |
CRooBatchCompute::AbsBuffer | |
CRooBatchCompute::AbsBufferManager | |
CROOT::Minuit2::ABSum< M1, M2 > | |
CTMVA::AbsValue | |
►CROOT::option::Parser::Action | |
CROOT::option::Parser::StoreOptionAction | |
CROOT::option::Stats::CountOptionsAction | |
CROOT::Math::AddOp< T > | Addition Operation Class |
CROOT::Math::AddPolicy< T, D1, D2, R1, R2 > | Matrix addition policy |
CROOT::Math::AddPolicy< T, D1, D2, MatRepSym< T, D1 >, MatRepSym< T, D1 > > | |
CROOT::Detail::TCollectionProxyInfo::Address< T > | |
►CROOT::Detail::TCollectionProxyInfo::Address< const Bool_t & > | |
►CROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > > | |
CROOT::Detail::TCollectionProxyInfo::Pushback< Internal::TStdBitsetHelper< Bitset_t > > | |
►CROOT::Detail::TCollectionProxyInfo::Address< T::const_reference > | |
►CROOT::Detail::TCollectionProxyInfo::Type< T > | Small helper to encapsulate basic data accesses for all STL continers |
CROOT::Detail::TCollectionProxyInfo::Insert< T > | Small helper to encapsulate all necessary data accesses for containers like set, multiset etc |
CROOT::Detail::TCollectionProxyInfo::MapInsert< T > | Small helper to encapsulate all necessary data accesses for containers like set, multiset etc |
CROOT::Detail::TCollectionProxyInfo::Pushback< T > | Small helper to encapsulate all necessary data accesses for containers like vector, list, deque |
CROOT::Detail::TCollectionProxyInfo::Pushfront< T > | Small helper to encapsulate all necessary data accesses for containers like forward_list |
Cah | |
CROOT::Minuit2::AlgebraicProdType< A, B > | |
CROOT::Minuit2::AlgebraicProdType< gen, gen > | |
CROOT::Minuit2::AlgebraicProdType< gen, sym > | |
CROOT::Minuit2::AlgebraicProdType< gen, vec > | |
CROOT::Minuit2::AlgebraicProdType< sym, gen > | |
CROOT::Minuit2::AlgebraicProdType< sym, sym > | |
CROOT::Minuit2::AlgebraicProdType< sym, vec > | |
CROOT::Minuit2::AlgebraicProdType< T, T > | |
CROOT::Minuit2::AlgebraicProdType< vec, gen > | |
CROOT::Minuit2::AlgebraicProdType< vec, sym > | |
CROOT::Minuit2::AlgebraicSumType< A, B > | |
CROOT::Minuit2::AlgebraicSumType< gen, vec > | |
CROOT::Minuit2::AlgebraicSumType< sym, vec > | |
CROOT::Minuit2::AlgebraicSumType< T, T > | |
CROOT::Minuit2::AlgebraicSumType< vec, gen > | |
CROOT::Minuit2::AlgebraicSumType< vec, sym > | |
CAlternateTupleIntDoubleAsc | |
CAlternateTupleIntDoubleDes | |
CRooAbsCachedPdf::AnaIntConfig | |
CRooMultiVarGaussian::AnaIntData | |
CRScanner::AnnotatedNamespaceDecl | |
CROOT::TMetaUtils::AnnotatedRecordDecl | |
CROOT::Fit::AreaComparer | |
►CROOT::option::Arg | Functions for checking the validity of option arguments |
CROOT::option::FullArg | |
CReadSpeed::Args | |
►Cstd::array< double, DIMENSIONS > | |
CROOT::Experimental::Hist::RCoordArray< DIMENSIONS > | |
CRooVectorDataStore::ArraysStruct::ArrayInfo< T > | |
CRooVectorDataStore::ArraysStruct | Output struct for the RooVectorDataStore::getArrays() helper function |
►Carrow::ArrayVisitor | |
CROOT::Internal::RDF::ArrayPtrVisitor | |
CRooStats::HistFactory::Asimov | TODO Here, we are missing some documentation |
CROOT::Math::Assign< T, D1, D2, A, R1, R2 > | Structure to assign from an expression based to general matrix to general matrix |
CROOT::Math::Assign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > > | Dummy Structure which flags an error to avoid assignment from expression based on a general matrix to a symmetric matrix |
CROOT::Math::Assign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > > | Structure to assign from an expression based to symmetric matrix to symmetric matrix |
CROOT::Math::AssignItr< T, D1, D2, R > | Structure for assignment to a general matrix from iterator |
CROOT::Math::AssignItr< T, D1, D2, MatRepSym< T, D1 > > | Specialized structure for assignment to a symmetrix matrix from iterator |
CROOT::Math::AssignSym | Force Expression evaluation from general to symmetric |
CTExMap::Assoc_t | |
CTStreamerInfoActions::AssociativeLooper | |
CROOT::Experimental::XRooFit::xRooFit::Asymptotics | |
CXMLReader::Attributes | |
CROOT::MacOSX::Util::AutoreleasePool | |
CAutoRestorer | |
CROOT::Math::AxisAngle | AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis |
CROOT::Experimental::Internal::AxisConfigToType< EKind > | Converts a RAxisConfig of whatever kind to the corresponding RAxisBase-derived object |
CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kEquidistant > | |
CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kGrow > | |
CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kIrregular > | |
CROOT::Experimental::Internal::AxisConfigToType< RAxisConfig::kLabels > | |
►CB1 | |
CROOT::Internal::RDF::Disjunction< B1 > | |
CRooStats::HistFactory::RooBarlowBeestonLL::BarlowCache | |
►CBase_t | |
CRooAbsSelfCached< Base_t > | Abstract base class for functions whose output is cached in terms of a histogram in all observables between getVal() and evaluate() |
►CBaseClass | |
CRooFit::Detail::RooPyBind< BaseClass > | |
►CBaseCounterT | |
CROOT::Experimental::Detail::RNTupleTickCounter< BaseCounterT > | An either thread-safe or non thread safe counter for CPU ticks |
►CROOT::Math::BaseIntegratorOptions | Base class for Numerical integration options common in 1D and multi-dimension This is an internal class and is not supposed to be instantiated by the user |
CROOT::Math::IntegratorMultiDimOptions | Numerical multi dimensional integration options |
CROOT::Math::IntegratorOneDimOptions | Numerical one dimensional integration options |
►CROOT::Math::KDTree< _DataPoint >::BaseNode | |
►CROOT::Math::KDTree< _DataPoint >::BinNode | |
CROOT::Math::KDTree< _DataPoint >::TerminalNode | |
CROOT::Math::KDTree< _DataPoint >::HeadNode | |
CROOT::Math::KDTree< _DataPoint >::SplitNode | |
►CBaseSelectionRule | |
CClassSelectionRule | |
CVariableSelectionRule | |
CBasicGRULayer | Generic implementation |
CBasicLSTMLayer | Generic implementation |
CBasicRNNLayer | Generic implementation |
CBasisFunction< Func > | |
CTTreePerfStats::BasketInfo | |
CBatch | |
CRooBatchCompute::Batch | |
CTMVA::DNN::Batch | Encapsulates one mini-batch |
CBatches | These classes encapsulate the necessary data for the computations |
CRooBatchCompute::Batches | |
Cbvh::v2::BBox< T, N > | |
CTMVA::BDTEventWrapper | |
CRooStats::BernsteinCorrection | BernsteinCorrection is a utility in RooStats to augment a nominal PDF with a polynomial correction term |
CBeta_interval_length | |
CROOT::Minuit2::BFGSMinimizerType | |
CROOT::Minuit2::VariableMetricMinimizer::BFGSType | |
Cbvh::v2::BinnedSahBuilder< Node, BinCount >::Bin | |
Cbvh::v2::MiniTreeBuilder< Node, MortonCode >::Bin | |
CROOT::Math::BinaryOp< Operator, LHS, RHS, T > | BinaryOperation class A class representing binary operators in the parse tree |
CROOT::Math::BinaryOpCopyL< Operator, LHS, RHS, T > | Binary Operation class with value storage for the left argument |
CROOT::Math::BinaryOpCopyR< Operator, LHS, RHS, T > | Binary Operation class with value storage for the right argument |
CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Op1 > | |
CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Add > | |
CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Div > | |
CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Mul > | |
CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Pow > | |
CTMVA::Experimental::SOFIE::BinaryOperatorTrait< T, Sub > | |
CBinaryOpPolicy | |
►CTMVA::BinaryTree | Base class for BinarySearch and Decision Trees |
CTMVA::BinarySearchTree | A simple Binary search tree including a volume search method |
CTMVA::DecisionTree | Implementation of a Decision Tree |
CROOT::R::TRDataFrame::Binding | |
CROOT::R::TRInterface::Binding | |
CTMVA::OptionMap::Binding | |
CBinEdges | |
CRooHelpers::BinnedLOutput | |
CBinningRestorer | |
CBinomialNeymanInterval< Sorter > | Implement noncentral binomial confidence intervals using the Neyman construction |
►CBinomialNeymanInterval< FeldmanCousinsSorter > | |
CFeldmanCousinsBinomialInterval | |
CBinomialProbHelper | Helper class impelementing the binomial probability and the likelihood ratio used for ordering the interval in the FeldmanCousins interval class |
CRooMultiVarGaussian::BitBlock | |
CROOT::Math::GenVector_detail::BitReproducible | |
CTStreamerInfoActions::BitsMarker | |
CROOT::Experimental::RStyle::Block_t | |
CTEveParamList::BoolConfig_t | |
CBoolNameTable_t | |
CROOT::Math::Boost | Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix |
CROOT::Math::BoostX | Class representing a Lorentz Boost along the X axis, by beta |
CROOT::Math::BoostY | Class representing a Lorentz Boost along the Y axis, by beta |
CROOT::Math::BoostZ | Class representing a Lorentz Boost along the Z axis, by beta |
CRgl::Pad::BoundingRect< ValueType > | |
CROOT::Fit::Box | |
CROOT::Fit::BoxContainer | |
CRooNDKeysPdf::BoxInfo | |
CRooBatchCompute::BracketAdapter< T > | Little adapter that gives a bracket operator to types that don't have one |
CRooBatchCompute::BracketAdapterWithMask | |
CRooStats::BranchStore | |
CBRESINFO | |
CTGeoBatemanSol::BtCoef_t | |
►CRooSimWSTool::BuildConfig | |
CRooSimWSTool::MultiBuildConfig | |
CBuildNodeInfo | |
Cbvh::v2::MiniTreeBuilder< Node, MortonCode >::BuildTask | |
Cbvh::v2::Bvh< Node > | |
Cbvh::v2::Bvh< bvh::v2::Node > | |
CReadSpeed::ByteData | |
CROOT::Detail::CallableTraitsImpl< T, HasCallOp > | Extract types from the signature of a callable object. See CallableTraits |
CROOT::Detail::CallableTraitsImpl< R(*)(Args...), false > | |
CROOT::Detail::CallableTraitsImpl< R(Args...), false > | |
CROOT::Detail::CallableTraitsImpl< R(T::*)(Args...) const, false > | |
CROOT::Detail::CallableTraitsImpl< R(T::*)(Args...), false > | |
CROOT::Detail::CallableTraitsImpl< T, true > | |
CCPyCppyy::CallContext | |
CCPyCppyy::CallContextRAII< F > | |
CTInterpreter::CallFuncIFacePtr_t | |
CROOT::Internal::RDF::CallGuaranteedOrder | Struct to wrap the call to a function with a guaranteed order of execution of its arguments |
Cbvh::v2::ReinsertionOptimizer< Node >::Candidate | |
CCanvasPainterGenerator | Creates RCanvasPainter objects |
CROOT::Math::Cartesian2D< T > | Class describing a 2D cartesian coordinate system (x, y coordinates) |
CROOT::Math::Cartesian3D< T > | Class describing a 3D cartesian coordinate system (x, y, z coordinates) |
CROOT::Math::Cartesian3D< double > | |
CROOT::Math::Cartesian3D< Scalar > | |
CRooVectorDataStore::CatVector | |
CTMVA::CCPruner | A helper class to prune a decision tree using the Cost Complexity method (see Classification and Regression Trees by Leo Breiman et al) |
CTMVA::CCTreeWrapper | |
CTFITSHDU::Cell | |
CTEveCaloLegoGL::Cell2D_t | |
CCellData_t | Cell data inner structure |
CCellGeom_t | Cell geometry inner structure |
►CROOT::Experimental::REveCaloData::CellGeom_t | |
CROOT::Experimental::REveCaloData::CellData_t | |
►CTEveCaloData::CellGeom_t | Cell geometry inner structure |
CTEveCaloData::CellData_t | Cell data inner structure |
CROOT::Experimental::REveCaloData::CellId_t | |
CTEveCaloData::CellId_t | |
CROOT::MacOSX::Util::CFScopeGuard< RefType > | |
CROOT::MacOSX::Util::CFScopeGuard< CGContextRef > | |
CROOT::MacOSX::Util::CFScopeGuard< CGImageRef > | |
CROOT::MacOSX::Util::CFStrongReference< RefType > | |
CROOT::Quartz::CGAAStateGuard | |
Ccgi_environment | |
CROOT::Quartz::CGStateGuard | |
CChangeGuard | RAII guard for locking Eve manager (ctor) and processing changes (dtor) |
CROOT::Experimental::REveManager::ChangeGuard | |
CChangeOperModeRAII | Struct to temporarily change the operation mode of a RooAbsArg until it goes out of scope |
CRooStats::HistFactory::Channel | This class encapsulates all information for the statistical interpretation of one experiment |
CCHAR64LONG16 | |
CTCling::CharPtrCmp_t | |
CROOT::Math::ChebyshevApprox | Class describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials |
CROOT::Math::ChebyshevPol | |
CROOT::TestSupport::CheckDiagsRAII | Install a ROOT diagnostic handler to analyse diagnostics |
CRooFit::Detail::JSONNode::child_iterator_t< Nd > | |
CRooFit::Detail::JSONNode::children_view_t< Nd > | |
CROOT::Math::CholeskyDecomp< F, N > | Class to compute the Cholesky decomposition of a matrix |
CROOT::Math::CholeskyDecompGenDim< F > | Class to compute the Cholesky decomposition of a matrix |
CROOT::Math::CholInverter< idim > | |
►CRcpp::class_ | |
CROOT::R::class_< T > | |
CROOT::Browsable::RProvider::ClassArg | |
CROOT::Meta::Selection::ClassAttributes< classAttributes > | Used to specify attributes of classes in the "DictSelection" syntax |
CRooWorkspace::CodeRepo::ClassFiles | |
CClassification | Class to perform two class classification |
CClassificationResult | Class to save the results of the classifier |
CTMVA::ClassifierFactory | This is the MVA factory |
CRooWorkspace::CodeRepo::ClassRelInfo | |
Cclnt_HS_t | |
CRooFit::TestStatistics::RooAbsL::ClonePdfData | Convenience wrapper class used to distinguish between pdf/data owning and non-owning constructors |
CROOT::Internal::TThreadedObjectUtils::Cloner< T, isCopyConstructible > | Return a copy of the object or a "Clone" if the copy constructor is not implemented |
CROOT::Internal::TThreadedObjectUtils::Cloner< T, false > | |
CROOT::MacOSX::Details::CocoaPrivate | |
CRooFit::Experimental::CodegenContext | A class to maintain the context for squashing of RooFit models into code |
CRooFit::Experimental::CodegenIntegralImplCaller< Arg_t > | |
CTStreamerInfoActions::CollectionLooper< Looper > | |
►CTStreamerInfoActions::CollectionLooper< GenericLooper > | |
CTStreamerInfoActions::GenericLooper | |
►CTStreamerInfoActions::CollectionLooper< ScalarLooper > | |
CTStreamerInfoActions::ScalarLooper | |
►CTStreamerInfoActions::CollectionLooper< VectorLooper > | |
CTStreamerInfoActions::VectorLooper | |
►CTStreamerInfoActions::CollectionLooper< VectorPtrLooper > | |
CTStreamerInfoActions::VectorPtrLooper | |
CCollectionManager | |
CROOT::MacOSX::X11::ColorParser | |
CColorStruct_t | |
CTFITSHDU::Column | |
CROOT::Internal::RDF::ColumnType< VaryExpressionRet_t, IsSingleColumn > | |
CROOT::Internal::RDF::ColumnType< ROOT::RVec< ROOT::RVec< T > >, false > | |
CROOT::Internal::RDF::ColumnType< ROOT::RVec< T >, true > | |
CRooJSONFactoryWSTool::CombinedData | |
►CROOT::MacOSX::X11::Command | |
CROOT::MacOSX::X11::ClearArea | |
CROOT::MacOSX::X11::CopyArea | |
CROOT::MacOSX::X11::DeletePixmap | |
CROOT::MacOSX::X11::DrawBoxXor | |
CROOT::MacOSX::X11::DrawLine | |
CROOT::MacOSX::X11::DrawLineXor | |
CROOT::MacOSX::X11::DrawRectangle | |
CROOT::MacOSX::X11::DrawSegments | |
CROOT::MacOSX::X11::DrawString | |
CROOT::MacOSX::X11::FillPolygon | |
CROOT::MacOSX::X11::FillRectangle | |
CROOT::MacOSX::X11::UpdateWindow | |
CROOT::MacOSX::X11::CommandBuffer | |
CROOT::Experimental::Internal::RPageSinkFile::CommitBatch | |
CCompareAsc< T > | |
CTKDTreeBinning::CompareAsc | |
CcompareBAasc | |
CcompareBAdesc | |
CROOT::TMetaUtils::AnnotatedRecordDecl::CompareByName | |
CCompareDataHistBins | |
CCompareDesc< T > | |
CTKDTreeBinning::CompareDesc | |
CTTreeCloner::CompareEntry | |
CROOT::Math::KDTree< _DataPoint >::ComparePoints | |
CTTreeCloner::CompareSeek | |
CCompareSparseHistBins | |
CCompareVectorIndices | |
CTMVA::Experimental::SOFIE::ComparisionTrait< T, Op1 > | |
CTMVA::Experimental::SOFIE::ComparisionTrait< T, Eq > | |
CTMVA::Experimental::SOFIE::ComparisionTrait< T, Greater > | |
CTMVA::Experimental::SOFIE::ComparisionTrait< T, GreaterEq > | |
CTMVA::Experimental::SOFIE::ComparisionTrait< T, Less > | |
CTMVA::Experimental::SOFIE::ComparisionTrait< T, LessEq > | |
CRooFit::Detail::CompileContext | |
CROOT::Math::CompileTimeChecker< bool > | |
CROOT::Math::CompileTimeChecker< false > | |
CTMVA::Experimental::Internal::ComputeHelper< I, T, F > | Compute helper |
►Cstd::conditional_t | |
CROOT::Internal::RDF::Disjunction< B1, Bn... > | |
Cbvh::v2::ReinsertionOptimizer< Node >::Config | |
►Cbvh::v2::TopDownSahBuilder< Node >::Config | |
Cbvh::v2::DefaultBuilder< Node >::Config | |
Cbvh::v2::MiniTreeBuilder< Node, MortonCode >::Config | |
CRooBatchCompute::Config | Minimal configuration struct to steer the evaluation of a single node with the RooBatchCompute library |
CRooFit::MultiProcess::Config | Configuration for MultiProcess infrastructure |
CRooLagrangianMorphFunc::Config | |
CRooMinimizer::Config | Config argument to RooMinimizer constructor |
CTMVA::Config | Singleton class for global configuration settings used by TMVA |
CRooStats::HistFactory::ConfigParser | TODO Add documentation |
CRooAbsTestStatistic::Configuration | |
CRooStats::HistFactory::HistoToWorkspaceFactoryFast::Configuration | |
CROOT::Experimental::REveManager::Conn | |
CROOT::Experimental::RAxisBase::const_iterator | Random const_iterator through bins |
►Cstd::vector< T >::const_iterator | STL iterator class |
CROOT::Experimental::XRooFit::xRooNode::xRooNodeIterator | |
CROOT::Math::Constant< T > | Constant expression class A class representing constant expressions (literals) in the parse tree |
CRooFit::TestStatistics::ConstantTermsOptimizer | Analyzes a function given a dataset/observables for constant terms and caches those in the dataset |
CContDist | Free functions adapter needed by UNURAN for onedimensional continuous distributions |
CROOT::Minuit2::ContoursError | |
►CTMVA::ConvergenceTest | Check for convergence |
CTMVA::MethodMLP | Multilayer Perceptron class built off of MethodANNBase |
CTStreamerInfoActions::ConvertBasicType< From, To > | |
CTStreamerInfoActions::GenericLooper::ConvertBasicType< From, To, Converter > | |
CTStreamerInfoActions::VectorLooper::ConvertBasicType< From, To > | |
CTStreamerInfoActions::VectorPtrLooper::ConvertBasicType< From, To > | |
CTStreamerInfoActions::ConvertBasicType< BitsMarker, To > | |
CTStreamerInfoActions::VectorLooper::ConvertBasicType< BitsMarker, To > | |
CTStreamerInfoActions::VectorPtrLooper::ConvertBasicType< BitsMarker, To > | |
CTStreamerInfoActions::GenericLooper::ConvertBasicType< BitsMarker, To, Generic > | |
CTStreamerInfoActions::ConvertBasicType< NoFactorMarker< From >, To > | |
CTStreamerInfoActions::VectorLooper::ConvertBasicType< NoFactorMarker< From >, To > | |
CTStreamerInfoActions::VectorPtrLooper::ConvertBasicType< NoFactorMarker< From >, To > | |
CTStreamerInfoActions::GenericLooper::ConvertBasicType< NoFactorMarker< From >, To, Converter > | |
CTStreamerInfoActions::ConvertBasicType< WithFactorMarker< From >, To > | |
CTStreamerInfoActions::VectorLooper::ConvertBasicType< WithFactorMarker< From >, To > | |
CTStreamerInfoActions::VectorPtrLooper::ConvertBasicType< WithFactorMarker< From >, To > | |
CTStreamerInfoActions::GenericLooper::ConvertBasicType< WithFactorMarker< From >, To, Converter > | |
CTStreamerInfoActions::AssociativeLooper::ConvertCollectionBasicType< From, To > | |
CTStreamerInfoActions::GenericLooper::ConvertCollectionBasicType< From, To > | |
CTStreamerInfoActions::VectorLooper::ConvertCollectionBasicType< From, To > | |
CTStreamerInfoActions::VectorLooper::ConvertCollectionBasicType< NoFactorMarker< From >, To > | |
►CCPyCppyy::Converter | |
►CCPyCppyy::VoidArrayConverter | |
►CCPyCppyy::InstancePtrConverter< false > | |
CCPyCppyy::StrictInstancePtrConverter | |
CCPyCppyy::InstancePtrConverter< ISCONST > | |
CTStreamerInfoActions::AssociativeLooper::ConvertRead< From, To > | |
CTStreamerInfoActions::AssociativeLooper::ConvertRead< NoFactorMarker< From >, To > | |
CTStreamerInfoActions::AssociativeLooper::ConvertRead< WithFactorMarker< From >, To > | |
CROOT::Experimental::RPadLength::CoordSysBase< DERIVED > | |
►CROOT::Experimental::RPadLength::CoordSysBase< Normal > | |
CROOT::Experimental::RPadLength::Normal | A normalized coordinate |
►CROOT::Experimental::RPadLength::CoordSysBase< Pixel > | |
CROOT::Experimental::RPadLength::Pixel | A pixel coordinate |
►CROOT::Experimental::RPadLength::CoordSysBase< User > | |
CROOT::Experimental::RPadLength::User | A user coordinate |
Ccout_redirect | |
CCPyCppyy::CPPDataMember | |
CCPyCppyy::CPPExcInstance | |
CCPyCppyy::CPPInstance | |
CCPyCppyy::CPPOverload | |
►CCPyCppyy::CPPScope | |
CCPyCppyy::CPPSmartClass | |
CCPPYY_G__p2p | |
CCPPYY_G__value | |
CCpuInfo_t | |
CCPyCppyy_tagCDataObject | |
CCPyCppyy_tagPyCArgObject | |
CRooStats::HistFactory::Detail::CreateGammaConstraintsOutput | |
CCreateMethodPlugins | Plugins analysis |
►CROOT::RWebDisplayHandle::Creator | !< page content |
►CROOT::RWebDisplayHandle::BrowserCreator | |
CROOT::RWebDisplayHandle::ChromeCreator | |
CROOT::RWebDisplayHandle::FirefoxCreator | |
CROOT::RWebDisplayHandle::SafariCreator | |
CROOT::Minuit2::MnCross::CrossFcnLimit | |
CROOT::Minuit2::MnCross::CrossNewMin | |
CROOT::Minuit2::MnCross::CrossParLimit | |
CCrossValidation | |
CTMVA::CrossValidationFoldResult | |
CTMVA::CrossValidationResult | Class to save the results of cross validation, the metric for the classification ins ROC and you can ROC curves ROC integrals, ROC average and ROC standard deviation |
CTMVA::DNN::CudaActivationDescriptor | |
CTMVA::DNN::CudaConvolutionBwdDataAlgo | |
CTMVA::DNN::CudaConvolutionBwdFilterAlgo | |
CTMVA::DNN::CudaConvolutionDescriptor | |
CTMVA::DNN::CudaConvolutionFwdAlgo | |
CTMVA::DNN::CudaDataType | |
CTMVA::DNN::CudaDropoutDescriptor | |
CTMVA::DNN::CudaEmptyDescriptor | |
CRooBatchCompute::CudaInterface::CudaEvent | |
CTMVA::DNN::CudaFilterDescriptor | |
CTMVA::DNN::CudaPoolingDescriptor | |
CRooBatchCompute::CudaInterface::CudaStream | |
CTMVA::Experimental::RSofieReader::CustomOperatorData | |
CROOT::Math::KDTree< _DataPoint >::Cut | |
CTMVA::CvSplitKFoldsExpr | |
CROOT::Math::Cylindrical3D< T > | Class describing a cylindrical coordinate system based on rho, z and phi |
CROOT::Math::CylindricalEta3D< T > | Class describing a cylindrical coordinate system based on eta (pseudorapidity) instead of z |
Cd_iov_t | Iovec for memory buffer |
Cd_sg_list_t | Scatter/gather list for memory buffers |
Cdaos_cont_info_t | Container information |
Cdaos_event | Event and event queue |
Cdaos_handle_t | Generic handle for various DAOS components like container, object, etc |
Cdaos_iod_t | |
Cdaos_iom_t | |
Cdaos_obj_id_t | |
Cdaos_pool_info_t | Storage pool |
Cdaos_prop_t | Daos properties, for pool or container |
Cdaos_recx_t | |
CReadSpeed::Data | |
CRooStats::HistFactory::Data | |
CROOT::Minuit2::FunctionGradient::Data | |
CROOT::Minuit2::FunctionMinimum::Data | |
CROOT::Minuit2::MinimumError::Data | |
CROOT::Minuit2::MinimumParameters::Data | |
CROOT::Minuit2::MinimumSeed::Data | |
CROOT::Minuit2::MinimumState::Data | |
CDataKey | To use as a key type for RooFit data maps and containers |
CRooFit::Detail::DataKey | |
CDataloader | |
CROOT::Fit::DataOptions | DataOptions : simple structure holding the options on how the data are filled |
CROOT::Fit::DataRange | Class describing the range in the coordinates it supports multiple range in a coordinate |
CROOT::Math::GenVector_detail::BitReproducible::DB8 | |
CClingMemberIterInternal::DCIter | Iteration over collected DeclContexts |
Cde | |
CDebuggingSampler | DebuggingSampler is a simple implementation of the DistributionCreator interface used for debugging |
CDebuggingTestStat | DebuggingTestStat is a simple implementation of the DistributionCreator interface used for debugging |
Cbvh::v2::DefaultBuilder< Node > | This builder is only a wrapper around all the other builders, which selects the best builder depending on the desired BVH quality and whether a multi-threaded build is desired |
CROOT::Math::DefaultCoordinateSystemTag | DefaultCoordinateSystemTag Default tag for identifying any coordinate system |
CDefaultIcon_t | |
►Cllvm::orc::DefinitionGenerator | |
CAutoloadLibraryGenerator | |
CROOT::Math::Delaunay2D | Class to generate a Delaunay triangulation of a 2D set of points |
CRScanner::DelayedAnnotatedRecordDeclInfo | |
CTMVA::DeleteFunctor_t< T > | |
CROOT::Math::Derivator | Class for computing numerical derivative of a function |
CROOT::Minuit2::DerivatorElement | |
►CDerivFunType | |
►CROOT::Math::BasicFitMethodFunction< DerivFunType > | |
CROOT::Fit::BasicFCN< DerivFunType, ROOT::Math::IParamMultiFunction, BinData > | |
CROOT::Fit::BasicFCN< DerivFunType, ROOT::Math::IParamMultiFunction, UnBinData > | |
►CROOT::Fit::BasicFCN< DerivFunType, ModelFunType, DataType > | BasicFCN class: base class for the objective functions used in the fits It has a reference to the data and the model function used in the fit |
CROOT::Fit::Chi2FCN< DerivFunType, ModelFunType > | Chi2FCN class for binned fits using the least square methods |
CROOT::Fit::LogLikelihoodFCN< DerivFunType, ModelFunType > | LogLikelihoodFCN class for likelihood fits |
CROOT::Fit::PoissonLikelihoodFCN< DerivFunType, ModelFunType > | Class evaluating the log likelihood for binned Poisson likelihood fits it is template to distinguish gradient and non-gradient case |
CROOT::option::Descriptor | Describes an option, its help text (usage) and how it should be parsed |
CROOT::Internal::TThreadedObjectUtils::Detacher< T, ISHISTO > | |
CROOT::Internal::TThreadedObjectUtils::Detacher< T, true > | |
CRooStats::DetailedOutputAggregator | This class is designed to aid in the construction of RooDataSets and RooArgSets, particularly those naturally arising in fitting operations |
CROOT::Math::Determinant< n, idim > | Detrminant for a general squared matrix Function to compute the determinant from a square matrix ( ) of dimension idim and order n |
►CREveSelection::Deviator | |
CFWSelectionDeviator | |
CROOT::Experimental::REveSelection::Deviator | |
CdField | Struct used by ShowGuidelines to store the distance Field between objects in the canvas |
CROOT::TestSupport::CheckDiagsRAII::Diag_t | |
►Cclang::DiagnosticConsumer | |
CCheckModuleBuildClient | Custom diag client for clang that verifies that each implicitly build module is a system module |
►CROOT::Experimental::REveDigitSet::DigitBase_t | |
CROOT::Experimental::REveBoxSet::BFreeBox_t | |
CROOT::Experimental::REveBoxSet::InstancedScaledRotated_t | |
►CROOT::Experimental::REveBoxSet::Instanced_t | |
CROOT::Experimental::REveBoxSet::InstancedScaled_t | |
►CTEveDigitSet::DigitBase_t | |
►CTEveBoxSet::BCone_t | |
CTEveBoxSet::BEllipticCone_t | |
CTEveBoxSet::BFreeBox_t | |
CTEveBoxSet::BHex_t | |
►CTEveBoxSet::BOrigin_t | |
CTEveBoxSet::BAABoxFixedDim_t | |
CTEveBoxSet::BAABox_t | |
CTEveQuadSet::QFreeQuad_t | |
►CTEveQuadSet::QOrigin_t | |
CTEveQuadSet::QHex_t | |
CTEveQuadSet::QLineFixC_t | |
►CTEveQuadSet::QRectFixDimC_t | |
CTEveQuadSet::QRectFixC_t | |
►CTEveQuadSet::QRectFixDim_t | |
CTEveQuadSet::QRect_t | |
CR6::Dim< T, kNDim > | |
CR7::Dim< T, kNDim > | |
CTMVA::Experimental::SOFIE::Dim | |
CR6::Dim< T, 1 > | |
CR7::Dim< T, 1 > | |
CR6::Dim< T, 2 > | |
CR7::Dim< T, 2 > | |
CCPyCppyy::Dimensions | |
Cdir_scan_data | |
CROOT::Internal::TThreadedObjectUtils::DirCreator< T, ISHISTO > | |
CROOT::Internal::TThreadedObjectUtils::DirCreator< T, true > | |
CDisableCachingRAII | Disable all caches for sub-branches in an expression tree |
CDiscrDist | Free functions adapter needed by UNURAN for one-dimensional discrete distribution |
CROOT::Experimental::RPalette::Discrete_t | Tag type used to signal that the palette's colors should not be interpolated |
CCPyCppyy::DispatchPtr | |
CROOT::Math::DisplacementVector2D< CoordSystem, Tag > | Class describing a generic displacement vector in 2 dimensions |
CROOT::Math::DisplacementVector3D< CoordSystem, Tag > | Class describing a generic displacement vector in 3 dimensions |
CROOT::Math::DisplacementVector3D< Cartesian3D< double >, DefaultCoordinateSystemTag > | |
CROOT::Math::DisplacementVector3D< Cartesian3D< Scalar > > | |
CROOT::Internal::RDF::DisplayHelper< T > | |
►CROOT::Math::DistSampler | Interface class for generic sampling of a distribution, i.e |
CTFoamSampler | Class implementing the ROOT::Math::DistSampler interface using FOAM for sampling arbitrary distributions |
CTUnuranSampler | TUnuranSampler class class implementing the ROOT::Math::DistSampler interface using the UNU.RAN package for sampling distributions |
CROOT::Math::DistSamplerOptions | DistSampler options class |
CROOT::Math::DivOp< T > | Division (element-wise) Operation Class |
CRooFit::JSONIO::Detail::Domains | |
CDoWork | |
CTGLScene::DrawElement_t | |
CRooPlot::DrawOpt | |
CROOT::Internal::RootCling::DriverConfig | |
CTMVA::DTNodeTrainingInfo | |
CTMVA::DNN::DummyConvolutionBwdDataAlgo | |
CTMVA::DNN::DummyConvolutionBwdFilterAlgo | |
CTMVA::DNN::DummyConvolutionDescriptor | |
CTMVA::DNN::DummyConvolutionFwdAlgo | |
CTMVA::DNN::DummyCudaDataType | |
CTMVA::DNN::DummyDataType | |
CTMVA::DNN::DummyDescriptor | |
CTMVA::DNN::DummyDropoutDescriptor | |
CTMVA::DNN::DummyEmptyDescriptor | |
CTMVA::DNN::DummyFilterDescriptor | |
CTMVA::DNN::DummyPoolingDescriptor | |
CTMVA::Experimental::SOFIE::DynamicTensorInfo | |
CROOT::RCompressionSetting::EAlgorithm | |
CROOT::RCompressionSetting::EDefaults | |
CROOT::Experimental::REveGeoPolyShape::Edge_t | |
CTEveGeoPolyShape::Edge_t | |
CTEvePolygonSetProjectedGL::Edge_t | |
CEdgeTable | |
CR6::Dim< T, 1 >::EE | |
CR6::Dim< T, 2 >::EE | |
CR7::Dim< T, 1 >::EE | |
CR7::Dim< T, 2 >::EE | |
CEfficiencyPlotWrapper | Note: This file assumes a certain structure on the input file |
CTBranchSTL::ElementBranchHelper_t | |
CROOT::RCompressionSetting::ELevel | |
CEmptyCall | |
►Cstd::enable_shared_from_this | |
►CTObjLink | Wrapper around a TObject so it can be stored in a TList |
CTObjOptLink | |
CRooMappedCategory::Entry | |
CTTreeCache::MissCache::Entry | |
CReadSpeed::EntryRange | |
CENTupleColumnType | The available trivial, native content types of a column |
►CROOT::Detail::TCollectionProxyInfo::EnvironBase | |
CROOT::Detail::TCollectionProxyInfo::Environ< T > | Small helper to save proxy environment in the event of recursive calls |
►Czmq::error_t | |
CZMQ::ppoll_error_t | |
CROOT::Math::gv_detail::ERROR_This_Rotation_Conversion_is_NOT_Supported | |
CROOT::Math::EulerAngles | EulerAngles class describing rotation as three angles (Euler Angles) |
CRooFit::EvalContext | |
CRooAbsReal::EvalError | |
CRooAbsReal::EvalErrorContext | Context to temporarily change the error logging mode as long as the context is alive |
CROOT::Fit::FitUtil::Evaluate< T > | |
CRooFit::Evaluator | Evaluates a RooAbsReal object in other ways than recursive graph traversal |
CROOT::Math::EvaluatorOneDim< MultiFuncType > | |
CROOT::Math::EvaluatorOneDim< const ROOT::Math::IParamMultiFunction & > | |
CEvent | |
CTMVA::kNN::Event | |
CEvent_t | Event structure |
CTMVA::QuickMVAProbEstimator::EventInfo | |
CTMVA::DataSetFactory::EventStats | |
CROOT::MacOSX::X11::EventTranslator | |
►CUi::ExampleWidget | |
CExampleWidget | |
►Cstd::exception | STL class |
CCPyCppyy::PyException | |
CCachingError | |
CROOT::Experimental::RDirectoryTypeMismatch | Objects of this class are thrown to signal that the value known under the given name |
CROOT::Experimental::RDirectoryUnknownKey | Objects of this class are thrown to signal that no key with that name exists |
CROOT::Experimental::REveException | REveException Exception-type thrown by Eve classes |
CROOT::Math::GenVector_detail::BitReproducibleException | |
CRooJSONFactoryWSTool::DependencyMissingError | |
CRooStats::HistFactory::hf_exc | |
CTEveException | Exception class thrown by TEve classes and macros |
CZMQ::MoreException | |
CZMQ::TimeOutException | |
►Cstd::runtime_error | STL class |
CROOT::Math::GenVector_exception | |
CROOT::RException | Base class for all ROOT issued exceptions |
CCppyyLegacy::ExceptionContext_t | |
CExceptionContext_t | |
Cbvh::v2::Executor< Derived > | Helper object that provides iteration and reduction over one-dimensional ranges |
►CCPyCppyy::Executor | |
CCPyCppyy::RefExecutor | |
CTMVA::Executor | Base Executor class |
►Cbvh::v2::Executor< ParallelExecutor > | |
Cbvh::v2::ParallelExecutor | Executor that executes in parallel using the given thread pool |
►Cbvh::v2::Executor< SequentialExecutor > | |
Cbvh::v2::SequentialExecutor | Executor that executes serially |
CRooExpensiveObjectCache::ExpensiveObject | |
CRooFit::JSONIO::Exporter | |
CRooFit::JSONIO::ExportKeys | |
CROOT::Math::Expr< ExprType, T, D, D2, R1 > | |
CTMVA::Experimental::SOFIE::ExtractDataFromTP< T > | |
CTMVA::Experimental::SOFIE::ExtractDataFromTP< double > | |
CTMVA::Experimental::SOFIE::ExtractDataFromTP< float > | |
CTMVA::Experimental::SOFIE::ExtractDataFromTP< int32_t > | |
CTMVA::Experimental::SOFIE::ExtractDataFromTP< int64_t > | |
CRooWorkspace::CodeRepo::ExtraHeader | |
Cextrapolation_table | |
CROOT::Math::Fabs< T > | Unary abs Operation Class |
CRooProdPdf::Factorized | |
CFactory | |
CROOT::Math::Factory | Factory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager |
CTMVA::DNN::TCpuBuffer< AFloat >::FakeIteratorBegin | |
►Cstd::false_type | |
►CROOT::Experimental::HasCollectionProxyMemberType< T, typename > | Template specializations for classes with collection proxies |
CROOT::Experimental::IsCollectionProxy< T, typename > | The point here is that we can only tell at run time if a class has an associated collection proxy |
CROOT::Internal::RDF::Disjunction<... > | |
CROOT::Internal::RDF::IsVector_t< typename > | Detect whether a type is an instantiation of vector<T,A> |
CROOT::Internal::VecOps::IsRVec< typename > | |
Cis_specialization< Test, Ref > | |
CROOT::Math::FastInverter< idim, n > | Fast Matrix Inverter class Class to specialize calls to Dinv |
CROOT::Math::FastInverter< 3 > | 3x3 direct matrix inversion using Cramer Rule use only for FastInverter |
CROOT::Math::FastInverter< 4 > | 4x4 matrix inversion using Cramers rule |
CROOT::Math::FastInverter< 5 > | 5x5 Matrix inversion using Cramers rule |
CFeldmanCousinsSorter | |
CROOT::Experimental::Internal::RDaosObject::FetchUpdateArgs | Contains required information for a single fetch/update operation |
CFileStat_t | |
CRgl::Pad::FillAttribSet | |
CROOT::TestSupport::FilterDiagsRAII | Allows a user function to catch and filter/analyse ROOT and cling diagnostics, e.g |
CFindFileData_t | Struct used to pass information between OpenDirectory and GetDirEntry in a thread safe way (each thread creates a new instance of it) |
CROOT::Fit::FitConfig | Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::ParameterSettings class |
►CROOT::Fit::FitData | Base class for all the fit data types: Stores the coordinates and the DataOptions |
CROOT::Fit::BinData | Class describing the binned data sets : vectors of x coordinates, y values and optionally error on y values and error on coordinates The dimension of the coordinate is free There are 4 different options: |
CROOT::Fit::SparseData | SparseData class representing the data of a THNSparse histogram The data needs to be converted to a BinData class before fitting using the GetBinData functions |
CROOT::Fit::UnBinData | Class describing the un-binned data sets (just x coordinates values) of any dimensions |
CROOT::Experimental::RFitPanel::FitRes | |
CRooMinimizer::FitResult | |
►CROOT::Fit::FitResult | Class containing the result of the fit and all the related information (fitted parameter values, error, covariance matrix and minimizer result information) Contains a pointer also to the fitted (model) function, modified with the fit parameter values |
CTFitResult | Extends the ROOT::Fit::Result class with a TNamed inheritance providing easy possibility for I/O |
CROOT::Fit::Fitter | Fitter class, entry point for performing all type of fits |
CRooMinimizer::FitterInterface | |
CFlagConvResult< T > | |
CRooFit::Detail::FlatMap< Key_t, Val_t > | |
CTEveParamList::FloatConfig_t | |
►CFMFunc | |
CROOT::Math::FitTransformFunction< FMFunc > | Internal class used by GSLNLSMinimizer to implement the transformation of the chi2 function used by GSL Non-linear Least-square fitting The class is template on the FitMethodFunction type to support both gradient and non gradient functions |
CFontAttributes_t | |
CROOT::MacOSX::Details::FontCache | |
CROOT::MacOSX::Details::FontCache::FontList | |
CFontMetrics_t | |
CTGFontDialog::FontProp_t | |
CFontStateMap_t | |
CFoo | |
CFoption_t | |
CROOT::TestSupport::ForbidDiagnostics | Error handler for gtests that generates failures for every received diagnostic > kInfo when this file is linked to |
CFormatPdfTree | |
CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F, T > | |
CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *, T > | |
CROOT::Math::ParamFunctorHandler< ParentFunctor, Func >::FuncEvaluator< F *const, T > | |
CTFitEditor::FuncParamData_t | |
Cfuncptr_and_voidptr_t | |
CROOT::Minuit2::FunctionGradient | |
CROOT::Minuit2::FunctionMinimum | Class holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum |
CTClassEdit::FunctionSplitInfo | Result of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters) |
CRooRandomizeParamMCSModule::GausParam | |
CRooRandomizeParamMCSModule::GausParamSet | |
CGcCache_t | |
CGCValues_t | Graphics context structure |
CROOT::Minuit2::gen | |
CRooMultiVarGaussian::GenData | |
CROOT::Math::GeneralHessianCalc< T > | |
CROOT::Math::GeneralHessianCalc< double > | |
CROOT::Math::GeneralLinearFunctionDerivation< T > | Auxiliar class to bypass the (provisional) lack of vectorization in TFormula::EvalPar |
CROOT::Math::GeneralLinearFunctionDerivation< double > | |
►CROOT::Experimental::Internal::RVirtualCanvasPainter::Generator | |
CROOT::Experimental::RCanvasPainter::GeneratorImpl | |
CTStreamerInfoActions::GenericLooper::Generic< From, To > | |
►CROOT::Minuit2::GenericFunction | Class from which all the other classes, representing functions, inherit |
►CROOT::Minuit2::FCNBase | Interface (abstract class) defining the function to be minimized, which has to be implemented by the user |
CROOT::Minuit2::FCNAdapter< Function > | Template wrapped class for adapting to FCNBase signature |
CROOT::Minuit2::FCNGradAdapter< Function > | Template wrapped class for adapting to FCNBase signature a IGradFunction |
CROOT::Minuit2::FCNGradientBase | Extension of the FCNBase for providing the analytical Gradient of the function |
►CROOT::Minuit2::FumiliFCNBase | Extension of the FCNBase for the Fumili method |
►CROOT::Minuit2::FumiliChi2FCN | Extension of the FCNBase for the Fumili method |
CROOT::Minuit2::FumiliStandardChi2FCN | Class implementing the standard chi square function, which is the sum of the squares of the figures-of-merit calculated for each measurement point, the individual figures-of-merit being: (the Value predicted by the model-measured Value)/standard deviation |
CROOT::Minuit2::FumiliFCNAdapter< Function > | Template wrapped class for adapting to FumiliFCNBase signature |
►CROOT::Minuit2::FumiliMaximumLikelihoodFCN | Extension of the FCNBase for the Fumili method |
CROOT::Minuit2::FumiliStandardMaximumLikelihoodFCN | Class implementing the Elements member function for the standard maximum likelihood method |
CROOT::Minuit2::ParametricFunction | Function which has parameters |
►CGenericRooFIter | Interface for RooFIter-compatible iterators |
CRooFIterForLinkedList | Implementation of the GenericRooFIter interface for the RooLinkedList |
CTIteratorToSTLInterface< STLContainer > | TIterator and GenericRooFIter front end with STL back end |
CTMVA::GeneticAlgorithm | Base definition for genetic algorithm |
CTMVA::GeneticGenes | Cut optimisation interface class for genetic algorithm |
CROOT::Math::GeneticMinimizerParameters | |
CTMVA::GeneticPopulation | Population definition for genetic algorithm |
CTMVA::GeneticRange | Range definition for genetic algorithm |
CRooAbsPdf::GenSpec | |
CROOT::Internal::GetFunctorType< T > | Internal class used by TF1 for obtaining the type from a functor out of the set of valid operator() signatures |
CROOT::Internal::GetFunctorType< T(F::*)(const T *, const double *) const > | |
CROOT::Internal::GetFunctorType< T(F::*)(const T *, const double *)> | |
CROOT::Internal::GetFunctorType< T(F::*)(T *, double *) const > | |
CROOT::Internal::GetFunctorType< T(F::*)(T *, double *)> | |
CTFormLeafInfo::GetValueHelper< T > | |
CTLeaf::GetValueHelper< T > | |
CTFormLeafInfo::GetValueHelper< Long64_t > | |
CTLeaf::GetValueHelper< Long64_t > | |
CTFormLeafInfo::GetValueHelper< LongDouble_t > | |
CTLeaf::GetValueHelper< LongDouble_t > | |
CTFormLeafInfo::GetValueHelper< ULong64_t > | |
CTLeaf::GetValueHelper< ULong64_t > | |
CGFunc | |
CGifColorType | |
CGInverseFunc | |
CGInverseFuncNdim | |
CRgl::Pad::GLLimits | |
CROOT::Math::GlobalCoordinateSystemTag | Tag for identifying vectors based on a global coordinate system |
CRooAbsReal::GlobalSelectComponentRAII | |
CTMVA::Experimental::SOFIE::GNN_Data | |
CTMVA::Experimental::SOFIE::GNN_Init | |
CROOT::Math::GoFTest | GoFTest class implementing the 1 sample and 2 sample goodness of fit tests for uni-variate distributions and data |
►CROOT::Minuit2::GradientCalculator | Interface class for gradient calculators |
►CROOT::Minuit2::AnalyticalGradientCalculator | |
CROOT::Minuit2::ExternalInternalGradientCalculator | Similar to the AnalyticalGradientCalculator, the ExternalInternalGradientCalculator supplies Minuit with an externally calculated gradient |
CROOT::Minuit2::FumiliGradientCalculator | Fumili gradient calculator using external gradient provided by FCN Note that the computed Hessian and G2 are an approximation valid for small residuals |
CROOT::Minuit2::HessianGradientCalculator | HessianGradientCalculator: class to calculate Gradient for Hessian |
CROOT::Minuit2::InitialGradientCalculator | Class to calculate an initial estimate of the gradient |
CROOT::Minuit2::Numerical2PGradientCalculator | Class performing the numerical gradient calculation |
CGraphCreatorHelper | Helper class that provides the operation graph nodes |
CROOT::Internal::RDF::GraphDrawing::GraphCreatorHelper | |
CTMVA::Experimental::SOFIE::GraphIndependent_Init | |
CROOT::Internal::RDF::GraphDrawing::GraphNode | Class used to create the operation graph to be printed in the dot representation |
CRooMomentMorphFuncND::Grid2 | |
Cgroup | |
CROOT::Experimental::RAxisConfig::Grow_t | Tag type signalling that an axis should be able to grow; used for calling the appropriate constructor |
Cbvh::v2::GrowingStack< T > | Growing stack that can be used for BVH traversal |
CROOT::Math::GSL1DMinimizerWrapper | Wrapper class for gsl_min_fminimizer structure |
Cgsl_function_struct | |
Cgsl_integration_workspace | |
CROOT::Math::GSLChebSeries | Wrapper class for C struct gsl_cheb_series |
CROOT::Math::GSLDerivator | Class for computing numerical derivative of a function based on the GSL numerical algorithm This class is implemented using the numerical derivatives algorithms provided by GSL (see GSL Online Manual ) |
CROOT::Math::GSLError | Class to change GSL Error handler to use ROOT one |
CROOT::Math::GSLFunctionAdapter< UserFunc > | Class for adapting any C++ functor class to C function pointers used by GSL |
CROOT::Math::GSLFunctionDerivWrapper | Class to wrap a gsl_function_fdf (with derivatives) |
CROOT::Math::GSLFunctionWrapper | Wrapper class to the gsl_function C structure |
CROOT::Math::GSLIntegrationWorkspace | |
CROOT::Math::GSLInterpolator | Interpolation class based on GSL interpolation functions |
►CROOT::Math::GSLMCIntegrationWorkspace | |
CROOT::Math::GSLMiserIntegrationWorkspace | Workspace for MISER |
CROOT::Math::GSLPlainIntegrationWorkspace | |
CROOT::Math::GSLVegasIntegrationWorkspace | Workspace for VEGAS |
CROOT::Math::GSLMonteFunctionAdapter< UserFunc > | |
CROOT::Math::GSLMonteFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm |
CROOT::Math::GSLMultiFit | GSLMultiFit, internal class for implementing GSL non linear least square GSL fitting |
CROOT::Math::GSLMultiFitFunctionAdapter< FuncVector > | Class for adapting a C++ functor class to C function pointers used by GSL MultiFit Algorithm The templated C++ function class must implement: |
CROOT::Math::GSLMultiFitFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm |
CROOT::Math::GSLMultiMinDerivFunctionWrapper | Wrapper for a multi-dimensional function with derivatives used in GSL multidim minimization algorithm |
CROOT::Math::GSLMultiMinFunctionAdapter< UserFunc > | Class for adapting any multi-dimension C++ functor class to C function pointers used by GSL MultiMin algorithms |
CROOT::Math::GSLMultiMinFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm |
CROOT::Math::GSLMultiMinimizer | GSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives |
►CROOT::Math::GSLMultiRootBaseSolver | GSLMultiRootBaseSolver, internal class for implementing GSL multi-root finders This is the base class for GSLMultiRootSolver (solver not using derivatives) and GSLMUltiRootDerivSolver (solver using derivatives) |
CROOT::Math::GSLMultiRootDerivSolver | GSLMultiRootDerivSolver, internal class for implementing GSL multi-root finders using derivatives |
CROOT::Math::GSLMultiRootSolver | GSLMultiRootSolver, internal class for implementing GSL multi-root finders not using derivatives |
CROOT::Math::GSLMultiRootDerivFunctionWrapper | Wrapper to a multi-dim function with derivatives for multi roots algorithm |
CROOT::Math::GSLMultiRootFinder | Class for Multidimensional root finding algorithms bassed on GSL |
CROOT::Math::GSLMultiRootFunctionAdapter< FuncVector > | Class for adapting a C++ functor class to C function pointers used by GSL MultiRoot Algorithm The templated C++ function class must implement: |
CROOT::Math::GSLMultiRootFunctionWrapper | Wrapper to a multi-dim function without derivatives for multi roots algorithm |
CROOT::Math::GSLQRngWrapper | GSLQRngWrapper class to wrap gsl_qrng structure |
►CROOT::Math::GSLQuasiRandomEngine | GSLQuasiRandomEngine Base class for all GSL quasi random engines, normally user instantiate the derived classes which creates internally the generator and uses the class ROOT::Math::QuasiRandom |
CROOT::Math::GSLQRngNiederreiter2 | Niederreiter generator gsl_qrng_niederreiter_2 from here |
CROOT::Math::GSLQRngSobol | Sobol generator gsl_qrng_sobol from here |
►CROOT::Math::GSLRandomEngine | GSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator |
CROOT::Math::GSLRngCMRG | Combined multiple recursive generator (L'Ecuyer) see here |
CROOT::Math::GSLRngGFSR4 | Lagged Fibonacci generator by Ziff see here |
CROOT::Math::GSLRngMRG | 5-th order multiple recursive generator (L'Ecuyer, Blouin and Coutre) see here |
CROOT::Math::GSLRngMT | Mersenne-Twister generator gsl_rng_mt19937 from here |
CROOT::Math::GSLRngMinStd | MINSTD generator (Park and Miller) see here |
CROOT::Math::GSLRngMixMax | MixMax generator based on ROOT::Math::MixMaxEngine of N=240 |
CROOT::Math::GSLRngRanLux | Old Ranlux generator (James, Luscher) (default luxury level, p = 223) (This is eequivalent to TRandom1 with default luxury level) see here |
CROOT::Math::GSLRngRanLuxD1 | Double precision (48 bits) version of Second generation of Ranlux generator with luxury level of 1 (It throws away 202 value for every 12 used) see here |
CROOT::Math::GSLRngRanLuxD2 | Double precision (48 bits) version of Second generation of Ranlux generator with luxury level of 2 (It throws away 397 value for every 12 used) see here |
CROOT::Math::GSLRngRanLuxS1 | Second generation of Ranlux generator for single precision with luxury level of 1 (It throws away 202 values for every 12 used) see here |
CROOT::Math::GSLRngRanLuxS2 | Second generation of Ranlux generator for Single precision with luxury level of 2 (It throws away 397 value for every 12 used) see here |
CROOT::Math::GSLRngRanMar | RANMAR generator see here |
CROOT::Math::GSLRngRand | BSD rand() generator gsl_rmg_rand from here |
CROOT::Math::GSLRngTaus | Tausworthe generator by L'Ecuyer see here |
CROOT::Math::GSLRngROOTWrapper< Engine > | Class for wrapping ROOT Engines in gsl_rng types which can be used as extra GSL random number generators For this we need to implement functions which will be called by gsl_rng |
CROOT::Math::GSLRngWrapper | GSLRngWrapper class to wrap gsl_rng structure |
CROOT::Math::GSLRootFdFSolver | Root-Finder with derivatives implementation class using GSL |
CROOT::Math::GSLRootFSolver | Root-Finder implementation class using GSL |
CROOT::Math::GSLSimAnFunc | GSLSimAnFunc class description |
CROOT::Math::GSLSimAnnealing | GSLSimAnnealing class for performing a simulated annealing search of a multidimensional function |
CROOT::Math::GSLSimAnParams | Structure holding the simulated annealing parameters |
CRooRandom::Guard | |
CHAddArgs | |
CROOT::TypeTraits::HasBeginAndEnd< T > | |
CROOT::Experimental::Internal::RDaosContainer::ROidDkeyPair::Hash | |
CRooFit::Detail::HashAssistedFind | Helper for hash-map-assisted finding of elements by name |
CROOT::Internal::RConcurrentHashColl::HashValue | |
CROOT::Internal::RDF::HasMakeNew< T > | |
CTClingValue::HasTheSameSizeAsClingValue | |
CTFITSHDU::HDURecord | |
CRooFit::MultiProcess::HeatmapAnalyzer | Reads and processes logfiles produced by RooFit::MultiProcess::ProcessTimer |
CRooFit::MultiProcess::Detail::HeatmapAnalyzerJsonData | |
CROOT::Experimental::REveTrackPropagator::Helix_t | |
CTEveTrackPropagator::Helix_t | |
CHelperOps | |
CHEPEVT_DEF | HEPEVT common block |
CRooHelpers::HijackMessageStream | Hijacks all messages with given level and topic (and optionally object name) while alive |
CRooStats::HistFactory::HistFactoryNavigation | |
►CRooStats::HistFactory::HistogramUncertaintyBase | ////////////////////////////////////////////////////////////////////////////////////////////Base class to store the up and down variations for histogram uncertainties |
CRooStats::HistFactory::HistoFactor | Configuration for an *un*constrained, coherent shape variation of affected samples |
CRooStats::HistFactory::HistoSys | Configuration for a constrained, coherent shape variation of affected samples |
CRooStats::HistFactory::ShapeFactor | *Un*constrained bin-by-bin variation of affected histogram |
CRooStats::HistFactory::ShapeSys | Constrained bin-by-bin variation of affected histogram |
CRooStats::HistFactory::StatError | Statistical error of Monte Carlo predictions |
CRooStats::HistFactory::HistRef | Internal class wrapping an histogram and managing its content |
CHoption_t | Histograms' drawing options structure |
CHparam_t | Histogram parameters structure |
CTMVA::HyperParameterOptimisationResult | |
►CRooStats::HypoTestCalculator | HypoTestCalculator is an interface class for a tools which produce RooStats HypoTestResults |
►CRooStats::CombinedCalculator | CombinedCalculator is an interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals |
CRooStats::ProfileLikelihoodCalculator | The ProfileLikelihoodCalculator is a concrete implementation of CombinedCalculator (the interface class for tools which can produce both a RooStats HypoTestResult and ConfInterval) |
►CRooStats::HypoTestCalculatorGeneric | Common base class for the Hypothesis Test Calculators |
CRooStats::AsymptoticCalculator | Hypothesis Test Calculator based on the asymptotic formulae for the profile likelihood ratio |
CRooStats::FrequentistCalculator | Does a frequentist hypothesis test |
CRooStats::HybridCalculator | Same purpose as HybridCalculatorOriginal, but different implementation |
CHypoTestWrapper< HypoTestType > | |
►CROOT::Math::IBaseFunctionMultiDimTempl< T > | Documentation for the abstract class IBaseFunctionMultiDim |
►CROOT::Math::IParametricFunctionMultiDimTempl< double > | |
CROOT::Math::MultiDimParamFunctionAdapter | MultiDimParamFunctionAdapter class to wrap a one-dimensional parametric function in a multi dimensional parametric function interface This is used typically in fitting where internally the function is stored as multidimensional |
CROOT::Math::WrappedParamFunction< FuncPtr > | WrappedParamFunction class to wrap any multi-dimensional function object implementing the operator()(const double * x, const double * p) in an interface-like IParamFunction with a vector storing and caching internally the parameter values |
CROOT::Math::WrappedParamFunctionGen< FuncPtr > | WrappedParamGenFunction class to wrap any multi-dimensional function implementing the operator()(const double * ) in an interface-like IParamFunction, by fixing some of the variables and define them as parameters |
CROOT::Fit::FcnAdapter | |
►CROOT::Math::IGradientFunctionMultiDimTempl< T > | Interface (abstract class) for multi-dimensional functions providing a gradient calculation |
CROOT::Math::GradFunctor | GradFunctor class for Multidimensional gradient functions |
CROOT::Math::LSResidualFunc< Func > | LSResidualFunc class description |
CROOT::Math::MinimTransformFunction | MinimTransformFunction class to perform a transformations on the variables to deal with fixed or limited variables (support both double and single bounds) The class manages the passed function pointer |
CROOT::Math::MultiNumGradFunction | MultiNumGradFunction class to wrap a normal function in a gradient function using numerical gradient calculation provided by the class Derivator (based on GSL numerical derivation) |
►CROOT::Math::IParametricFunctionMultiDimTempl< T > | IParamFunction interface (abstract class) describing multi-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam |
►CROOT::Math::IParametricGradFunctionMultiDimTempl< T > | Interface (abstract class) for parametric gradient multi-dimensional functions providing in addition to function evaluation with respect to the coordinates also the gradient with respect to the parameters, via the method ParameterGradient |
CROOT::Math::MultiDimParamGradFunctionAdapter | MultiDimParamGradFunctionAdapter class to wrap a one-dimensional parametric gradient function in a multi dimensional parametric gradient function interface This is used typically in fitting where internally the function is stored as multidimensional |
CROOT::Math::WrappedMultiTF1Templ< T > | Class to Wrap a ROOT Function class (like TF1) in a IParamMultiFunction interface of multi-dimensions to be used in the ROOT::Math numerical algorithm |
CROOT::Math::WrappedMemMultiFunction< FuncObj, MemFuncPtr > | |
CROOT::Math::WrappedMultiFunction< Func > | Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-dimensional function interface |
►CROOT::Math::IBaseFunctionMultiDimTempl< double > | |
CROOT::Math::Functor | Documentation for class Functor class |
►CROOT::Math::IBaseFunctionOneDim | Interface (abstract class) for generic functions objects of one-dimension Provides a method to evaluate the function given a value (simple double) by implementing operator() (const double ) |
CROOT::Math::CDFWrapper | |
CROOT::Math::Functor1D | Functor1D class for one-dimensional functions |
►CROOT::Math::IGradientFunctionOneDim | Interface (abstract class) for one-dimensional functions providing a gradient calculation |
CROOT::Math::GradFunctor1D | GradFunctor1D class for one-dimensional gradient functions |
CROOT::Math::Polynomial | Parametric Function class describing polynomials of order n |
CROOT::Math::WrappedTF1 | Class to Wrap a ROOT Function class (like TF1) in a IParamFunction interface of one dimensions to be used in the ROOT::Math numerical algorithms The wrapper does not own bby default the TF1 pointer, so it assumes it exists during the wrapper lifetime |
►CROOT::Math::IParametricFunctionOneDim | Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam |
►CROOT::Math::IParametricGradFunctionOneDim | Interface (abstract class) for parametric one-dimensional gradient functions providing in addition to function evaluation with respect the coordinates also the gradient with respect to the parameters, via the method ParameterGradient |
►CROOT::Math::ParamFunction< IParamGradFunction > | |
CROOT::Math::Polynomial | Parametric Function class describing polynomials of order n |
CROOT::Math::WrappedTF1 | Class to Wrap a ROOT Function class (like TF1) in a IParamFunction interface of one dimensions to be used in the ROOT::Math numerical algorithms The wrapper does not own bby default the TF1 pointer, so it assumes it exists during the wrapper lifetime |
CROOT::Math::VavilovAccurateCdf | Class describing the Vavilov cdf |
CROOT::Math::VavilovAccuratePdf | Class describing the Vavilov pdf |
CROOT::Math::VavilovAccurateQuantile | Class describing the Vavilov quantile function |
CROOT::Math::IntegrandTransform | Auxiliary inner class for mapping infinite and semi-infinite integrals |
CROOT::Math::OneDimMultiFunctionAdapter< MultiFuncType > | OneDimMultiFunctionAdapter class to wrap a multidimensional function in one dimensional one |
CROOT::Math::OneDimParamFunctionAdapter< ParamFuncType > | OneDimParamFunctionAdapter class to wrap a multi-dim parametric function in one dimensional one |
CROOT::Math::PDFIntegral | |
CROOT::Math::WrappedFunction< Func > | Template class to wrap any C++ callable object which takes one argument i.e |
CROOT::Math::WrappedMemFunction< FuncObj, MemFuncPtr > | Template class to wrap any member function of a class taking a double and returning a double in a 1D function interface For example, if you have a class like: struct X { double Eval(double x); }; you can wrapped in the following way: WrappedMemFunction<X, double ( X::* ) (double) > f; |
CRooStats::PosteriorCdfFunction | |
CRooStats::PosteriorFunction | |
CRooStats::PosteriorFunctionFromToyMC | Posterior function obtaining sampling toy MC for the nuisance according to their pdf |
CTF1_EvalWrapper | |
►CROOT::Math::IBaseParam | Documentation for the abstract class IBaseParam |
CROOT::Math::IParametricFunctionMultiDimTempl< double > | |
CROOT::Math::IParametricFunctionMultiDimTempl< T > | IParamFunction interface (abstract class) describing multi-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam |
CROOT::Math::IParametricFunctionOneDim | Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam |
CROOT::Math::IParametricGradFunctionMultiDimTempl< T > | Interface (abstract class) for parametric gradient multi-dimensional functions providing in addition to function evaluation with respect to the coordinates also the gradient with respect to the parameters, via the method ParameterGradient |
►CRooFactoryWSTool::IFace | |
CRooFactoryWSTool::SpecialsIFace | |
►CTMVA::IFitterTarget | Interface for a fitter 'target' |
CROOT::Math::MultiGenFunctionFitness | |
CTMVA::MethodCuts | Multivariate optimisation of signal efficiency for given background efficiency, applying rectangular minimum and maximum requirements |
CTMVA::MethodFDA | Function discriminant analysis (FDA) |
CTMVA::MethodMLP | Multilayer Perceptron class built off of MethodANNBase |
CTMVA::MinuitFitter | /Fitter using MINUIT |
CTMVA::OptimizeConfigParameters | |
CTMVA::ResultsMulticlass | Class which takes the results of a multiclass classification |
Cbvh::v2::IgnoreArgs | Helper callable object that just ignores its arguments and returns nothing |
CROOT::Math::IGradientMultiDimTempl< T > | |
CR6::Dim< T, 1 >::II | |
CR6::Dim< T, 2 >::II | |
CR7::Dim< T, 1 >::II | |
CR7::Dim< T, 2 >::II | |
Cil_params | |
►CTMVA::IMethod | Interface for all concrete MVA method implementations |
►CTMVA::MethodBase | Virtual base Class for all MVA method |
►CTMVA::MethodANNBase | Base class for all TMVA methods using artificial neural networks |
CTMVA::MethodMLP | Multilayer Perceptron class built off of MethodANNBase |
CTMVA::MethodBDT | Analysis of Boosted Decision Trees |
CTMVA::MethodBayesClassifier | Description of bayesian classifiers |
CTMVA::MethodCFMlpANN | Interface to Clermond-Ferrand artificial neural network |
►CTMVA::MethodCompositeBase | Virtual base class for combining several TMVA method |
CTMVA::MethodBoost | Class for boosting a TMVA method |
CTMVA::MethodCategory | Class for categorizing the phase space |
CTMVA::MethodCrossValidation | |
CTMVA::MethodCuts | Multivariate optimisation of signal efficiency for given background efficiency, applying rectangular minimum and maximum requirements |
CTMVA::MethodDL | |
CTMVA::MethodDNN | Deep Neural Network Implementation |
CTMVA::MethodDT | Analysis of Boosted Decision Trees |
CTMVA::MethodFDA | Function discriminant analysis (FDA) |
CTMVA::MethodFisher | Fisher and Mahalanobis Discriminants (Linear Discriminant Analysis) |
CTMVA::MethodHMatrix | H-Matrix method, which is implemented as a simple comparison of chi-squared estimators for signal and background, taking into account the linear correlations between the input variables |
CTMVA::MethodKNN | Analysis of k-nearest neighbor |
CTMVA::MethodLD | Linear Discriminant |
CTMVA::MethodLikelihood | Likelihood analysis ("non-parametric approach") |
CTMVA::MethodPDEFoam | The PDEFoam method is an extension of the PDERS method, which divides the multi-dimensional phase space in a finite number of hyper-rectangles (cells) of constant event density |
CTMVA::MethodPDERS | This is a generalization of the above Likelihood methods to dimensions, where is the number of input variables used in the MVA |
CTMVA::MethodRuleFit | J Friedman's RuleFit method |
CTMVA::MethodSVM | SMO Platt's SVM classifier with Keerthi & Shavade improvements |
CTMVA::MethodTMlpANN | This is the TMVA TMultiLayerPerceptron interface class |
►CTMVA::PyMethodBase | |
CTMVA::MethodPyAdaBoost | |
CTMVA::MethodPyGTB | |
CTMVA::MethodPyKeras | |
CTMVA::MethodPyRandomForest | |
CTMVA::MethodPyTorch | |
►CTMVA::RMethodBase | |
CTMVA::MethodC50 | |
CTMVA::MethodRSNNS | |
CTMVA::MethodRSVM | |
CTMVA::MethodRXGB | |
►CROOT::Math::IMinimizer1D | Interface class for numerical methods for one-dimensional minimization |
CROOT::Math::BrentMinimizer1D | User class for performing function minimization |
CROOT::Math::GSLMinimizer1D | Minimizer for arbitrary one dimensional functions |
►CParentFunctor::Impl | |
CROOT::Math::ParamFunctorHandler< ParentFunctor, Func > | ParamFunctor Handler class is responsible for wrapping any other functor and pointer to free C functions |
CROOT::Math::ParamMemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn > | ParamFunctor Handler to Wrap pointers to member functions |
►CRooFit::Detail::JSONNode::child_iterator_t< Nd >::Impl | |
CTJSONTree::Node::ChildItImpl< Nd, NdType, json_it > | |
►CTJSONTree::Node::Impl | |
CTJSONTree::Node::Impl::BaseNode | |
CTJSONTree::Node::Impl::NodeRef | |
CTRYMLTree::Impl | |
CTRYMLTree::Node::Impl | |
CRooFit::JSONIO::Importer | |
CRooFit::JSONIO::ImportExpression | |
CTMVA::Increment< T > | |
Cbvh::v2::Index< Bits, PrimCountBits > | Packed index data structure |
Cbvh::v2::Index< sizeof(T) *CHAR_BIT, 4 > | |
►CCPyCppyy::indexiterobject | |
CCPyCppyy::vectoriterobject | |
CIndexSortComparator | |
CROOT::Detail::indices< Indices > | |
CROOT::Math::rowOffsetsUtils::indices<... > | |
CROOT::Detail::TStatusBitsChecker::Registry::Info | |
CTFile::InfoListRet | Simple struct of the return value of GetStreamerInfoListImpl |
CRooSimultaneous::InitializationOutput | Internal struct used for initialization |
CTMVA::Experimental::SOFIE::InitializedTensor | |
COuter::Inner | |
►Cbvh::v2::InputStream | Stream of data that can be used to deserialize data structures |
Cbvh::v2::StdInputStream | Stream adapter for standard library input streams |
CTMVA::Experimental::SOFIE::InputTensorInfo | |
CTClass::InsertTClassInRegistryRAII | |
CTEveParamList::IntConfig_t | |
►Cstd::integral_constant | |
CROOT::TypeTraits::IsSignedNumeral< T > | Checks for signed integers types that are not characters |
CROOT::TypeTraits::IsSmartOrDumbPtr< T > | |
CROOT::TypeTraits::IsUnsignedNumeral< T > | Checks for unsigned integer types that are not characters |
CTMVA::Experimental::Internal::and_types< T0, Ts... > | |
CROOT::Fit::FitUtil::IntegralEvaluator< ParamFunc > | |
CROOT::Math::IntegratorMultiDim | User class for performing multidimensional integration |
CROOT::Math::IntegratorOneDim | User Class for performing numerical integration of a function in one dimension |
CROOT::Math::Interpolator | Class for performing function interpolation of points |
►Ccling::InterpreterCallbacks | |
CTClingCallbacks | |
CTRootClingCallbacks | |
CROOT::Internal::InterpreterMutexRegistrationRAII | |
►CTMVA::Interval | The TMVA::Interval Class |
CTMVA::LogInterval | The TMVA::Interval Class |
►CRooStats::IntervalCalculator | IntervalCalculator is an interface class for a tools which produce RooStats ConfIntervals |
CRooStats::BayesianCalculator | BayesianCalculator is a concrete implementation of IntervalCalculator, providing the computation of a credible interval using a Bayesian method |
CRooStats::CombinedCalculator | CombinedCalculator is an interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals |
CRooStats::FeldmanCousins | (like the Feldman-Cousins technique) is essentially a specific configuration of the more general NeymanConstruction |
CRooStats::HypoTestInverter | A class for performing a hypothesis test inversion by scanning the hypothesis test results of a HypoTestCalculator for various values of the parameter of interest |
CRooStats::MCMCCalculator | Bayesian Calculator estimating an interval or a credible region using the Markov-Chain Monte Carlo method to integrate the likelihood function with the prior to obtain the posterior function |
CRooStats::NeymanConstruction | NeymanConstruction is a concrete implementation of the NeymanConstruction interface that, as the name suggests, performs a NeymanConstruction |
CTMVA::RuleFitAPI::IntParms | |
CROOT::TreeUtils::InvalidTupleType< class > | |
CROOT::TreeUtils::InvalidTupleType< TNtuple > | |
CROOT::TreeUtils::InvalidTupleType< TNtupleD > | |
CROOT::Math::Inverter< idim, n > | Matrix Inverter class Class to specialize calls to Dinv |
CROOT::Math::Inverter< 0 > | Inverter<0> |
CROOT::Math::Inverter< 1 > | 1x1 matrix inversion |
CROOT::Math::Inverter< 2 > | 2x2 matrix inversion using Cramers rule |
CTMVA::Config::IONames | |
CTTreeCache::IOPos | |
►CROOT::Math::IOptions | Generic interface for defining configuration options of a numerical algorithm |
CROOT::Math::GenAlgoOptions | Class implementing generic options for a numerical algorithm Just store the options in a map of string-value pairs |
►Cstd::ios_base | STL class |
►Cstd::basic_ios< Char > | STL class |
►Cstd::basic_ostream< Char > | STL class |
►Cstd::basic_ostringstream< Char > | STL class |
►Cstd::ostringstream | STL class |
CROOT::Detail::RLogBuilder | Builds a diagnostic entry, emitted by the static RLogManager upon destruction of this builder, where - by definition - the RLogEntry has been completely built |
CTMVA::MsgLogger | Ostringstream derivative to redirect and format output |
►Cstd::ostream | STL class |
CTGTextViewostream | |
►CIPFType | |
CROOT::Math::ParamFunction< IPFType > | Base template class for all Parametric Functions |
►CTMVA::IPruneTool | IPruneTool - a helper interface class to prune a decision tree |
CTMVA::CostComplexityPruneTool | A class to prune a decision tree using the Cost Complexity method |
CTMVA::ExpectedErrorPruneTool | A helper class to prune a decision tree using the expected error (C4.5) method |
CTMVA::IPythonInteractive | This class is needed by JsMVA, and it's a helper class for tracking errors during the training in Jupyter notebook |
►CROOT::Math::IRootFinderMethod | Interface for finding function roots of one-dimensional functions |
CROOT::Math::BrentRootFinder | Class for finding the root of a one dimensional function using the Brent algorithm |
►CROOT::Math::GSLRootFinder | Base class for GSL Root-Finding algorithms for one dimensional functions which do not use function derivatives |
CROOT::Math::Roots::Bisection | Roots::Bisection Bisection algorithm, simplest algorithm for bracketing the roots of a function, but slowest one |
CROOT::Math::Roots::Brent | Brent-Dekker algorithm which combines an interpolation strategy with the bisection algorithm See the GSL manual for more information |
CROOT::Math::Roots::FalsePos | False Position algorithm based on linear interpolation |
►CROOT::Math::GSLRootFinderDeriv | Base class for GSL Root-Finding algorithms for one dimensional functions which use function derivatives |
CROOT::Math::Roots::Newton | Newton algorithm, which computes the derivative at each iteration See the GSL manual for more information |
CROOT::Math::Roots::Secant | Secant algorithm, simplified version of Newton method, which does not require the derivative at every step |
CROOT::Math::Roots::Steffenson | Steffenson method, providing the fastes convergence |
CROOT::Detail::is_array_class< Array > | |
CROOT::Internal::RDF::IsDataContainer< T > | Check for container traits |
CROOT::Internal::RDF::IsDataContainer< ROOT::VecOps::RVec< bool > > | |
►CROOT::option::PrintUsageImplementation::IStringWriter | |
CROOT::option::PrintUsageImplementation::FunctionWriter< Function > | |
CROOT::option::PrintUsageImplementation::OStreamWriter< OStream > | |
CROOT::option::PrintUsageImplementation::StreamWriter< Function, Stream > | |
CROOT::option::PrintUsageImplementation::SyscallWriter< Syscall > | |
CROOT::option::PrintUsageImplementation::TemporaryWriter< Temporary > | |
CROOT::Experimental::REveChunkManager::iterator | |
CROOT::Math::KDTree< _DataPoint >::iterator | |
CROOT::TSeq< T >::iterator | |
CTEveChunkManager::iterator | |
CTMVA::Experimental::RTensor< V, C >::Iterator | |
CROOT::Experimental::TTreeReaderFast::Iterator_t | |
CTTreeReader::Iterator_t | Iterate through the entries of a TTree |
CTTreeReaderArray< T >::Iterator_t< ReaderArrayType > | Random access iterator to the elements of a TTreeReaderArray |
►Cstd::iterator_traits | |
CTIterCategory< T > | |
CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, large > | Small helper to implement the function to create,access and destroy iterators |
CROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators | |
CROOT::Detail::TCollectionProxyInfo::Iterators< Cont_t, true > | |
CROOT::Detail::TCollectionProxyInfo::IteratorValue< Cont_t, value > | Small helper to encapsulate whether to return the value pointed to by the iterator or its address |
CROOT::Detail::TCollectionProxyInfo::IteratorValue< Cont_t, value_ptr * > | |
Ciu_params | |
►CRooFit::MultiProcess::Job | Interface class for defining the actual work that must be done |
CRooFit::TestStatistics::LikelihoodGradientJob | |
CRooFit::TestStatistics::LikelihoodJob | |
CRooFit::MultiProcess::JobManager | Main point of access for all MultiProcess infrastructure |
CRooFit::MultiProcess::JobTask | Combined job_object, state and task identifier type |
►CRooFit::Detail::JSONNode | |
CTJSONTree::Node | |
CTRYMLTree::Node | |
►CRooFit::Detail::JSONTree | |
CTJSONTree | |
CTRYMLTree | |
CJupyROOTExecutorHandler | |
CROOT::Math::KahanSum< T, N > | The Kahan summation is a compensated summation algorithm, which significantly reduces numerical errors when adding a sequence of finite-precision floating point numbers |
CROOT::Math::KahanSum< double > | |
CTMVA::KDEKernel | KDE Kernel for "smoothing" the PDFs |
CROOT::Math::KDTree< _DataPoint > | |
CROOT::Meta::Selection::KeepFirstTemplateArguments< I > | Used to specify the number of arguments to be kept |
CTKDE::KernelIntegrand | |
CROOT::Experimental::Internal::ROnDiskPage::Key | On-disk pages within a page source are identified by the column and page number |
CKeySymbolMap_t | |
CkNN | KNN::Event describes point in input variable vector-space, with additional functionality like distance between points |
CROOT::Minuit2::LASquareMatrix | |
CROOT::Minuit2::LASymMatrix | Class describing a symmetric matrix of size n |
CROOT::Minuit2::LAVector | |
CTMVA::DNN::Layer | Layer defines the layout of a layer |
CTMVA::DNN::LayerData | LayerData holds the data of one layer |
CLayoutChunk_t | |
CTGFSComboBox::Lbc_t | |
CTMVA::LDA | |
CTLeaf::LeafCountValues | |
CLikeFunction1 | |
CROOT::Fit::FitUtil::LikelihoodAux< T > | |
CROOT::Fit::FitUtil::LikelihoodAux< double > | |
CRooStats::LikelihoodFunction | |
►CRooFit::TestStatistics::LikelihoodGradientWrapper | Virtual base class for implementation of likelihood gradient calculation strategies |
CRooFit::TestStatistics::LikelihoodGradientJob | |
CRooFit::MultiProcess::Config::LikelihoodJob | |
►CRooFit::TestStatistics::LikelihoodWrapper | Virtual base class for implementation of likelihood calculation strategies |
CRooFit::TestStatistics::LikelihoodJob | |
CRooFit::TestStatistics::LikelihoodSerial | Serial likelihood calculation strategy implementation |
CTMath::Limits< T > | |
CROOT::Experimental::REveStraightLineSet::Line_t | |
CTEveStraightLineSet::Line_t | |
CRgl::Pad::LineAttribSet | |
CROOT::option::PrintUsageImplementation::LinePartIterator | |
CROOT::option::PrintUsageImplementation::LineWrapper | |
CLinkdefReader | |
Cbvh::v2::MiniTreeBuilder< Node, MortonCode >::LocalBins | |
CRooHelpers::LocalChangeMsgLevel | Switches the message service to a different level while the instance is alive |
CROOT::Math::LocalCoordinateSystemTag | Tag for identifying vectors based on a local coordinate system |
CROOT::Internal::UniqueLockRecurseCount::LocalCounts | |
CTAtomicCount::LockGuard | |
CROOT::Experimental::REveManager::Logger | |
CTString::LongStr_t | |
CRooFit::Experimental::CodegenContext::LoopScope | A class to manage loop scopes using the RAII technique |
CROOT::Math::LorentzRotation | Lorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix |
CROOT::Math::LorentzVector< CoordSystem > | Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part |
►CTMVA::LossFunction | |
►CTMVA::AbsoluteDeviationLossFunction | Absolute Deviation Loss Function |
CTMVA::AbsoluteDeviationLossFunctionBDT | Absolute Deviation BDT Loss Function |
►CTMVA::HuberLossFunction | Huber Loss Function |
CTMVA::HuberLossFunctionBDT | Huber BDT Loss Function |
►CTMVA::LeastSquaresLossFunction | Least Squares Loss Function |
CTMVA::LeastSquaresLossFunctionBDT | Least Squares BDT Loss Function |
►CTMVA::LossFunctionBDT | |
CTMVA::AbsoluteDeviationLossFunctionBDT | Absolute Deviation BDT Loss Function |
CTMVA::HuberLossFunctionBDT | Huber BDT Loss Function |
CTMVA::LeastSquaresLossFunctionBDT | Least Squares BDT Loss Function |
CTMVA::LossFunctionEventInfo | |
CCPyCppyy::LowLevelView | |
CLsTreeEntry_t | |
CROOT::MacOSX::Details::MacOSXSystem | |
►CROOT::Detail::make_indices_impl< First, Step, N, class > | |
CROOT::Detail::make_indices_< First, Last, Step > | |
CROOT::Math::rowOffsetsUtils::make_indices_impl< I, IndexTuple, N > | |
►CROOT::Math::rowOffsetsUtils::make_indices_impl< 0, indices<>, N > | |
CROOT::Math::rowOffsetsUtils::make_indices< N > | |
CROOT::Detail::make_indices_impl< First, 1,((Last - First)+(1 - 1))/1 > | |
CROOT::Math::rowOffsetsUtils::make_indices_impl< I, indices< Indices... >, N > | |
CROOT::Math::rowOffsetsUtils::make_indices_impl< N, indices< Indices... >, N > | |
CROOT::Detail::make_indices_next< IndicesType, Next > | |
CROOT::Detail::make_indices_next2< IndicesType, Next, Tail > | |
CROOT::Detail::make_indices_next2< indices< Indices... >, Next, Tail > | |
CROOT::Detail::make_indices_next2< ROOT::Detail::make_indices_impl< First, Step, N/2 >::type, First+N/2 *Step, First+(N - 1) *Step > | |
CROOT::Detail::make_indices_next< indices< Indices... >, Next > | |
CROOT::Detail::make_indices_next< ROOT::Detail::make_indices_impl< First, Step, N/2 >::type, First+N/2 *Step > | |
CROOT::Math::detail::manipulator< char_t > | |
►Cstd::map< std::string, const void * > | |
►CTGDMLBaseTGDMMapHelper | |
CTGDMMapHelper< TGeoTranslation > | |
CTGDMMapHelper< TGeoRotation > | |
CTGDMMapHelper< TGeoScale > | |
CTGDMMapHelper< TGeoIsotope > | |
CTGDMMapHelper< TGeoElement > | |
CTGDMMapHelper< TGeoMaterial > | |
CTGDMMapHelper< TGeoMedium > | |
CTGDMMapHelper< TGeoMixture > | |
CTGDMMapHelper< TGeoShape > | |
CTGDMMapHelper< TGeoVolume > | |
CTGDMMapHelper< TGeoNode > | |
CTGDMMapHelper< TGDMLRefl > | |
CTGDMMapHelper< const char > | |
CTGDMMapHelper< TGDMLMatrix > | |
CTGDMMapHelper< T > | |
CROOT::Internal::TExecutor::MapRetType< F, CONTAINER > | Helper class to get the correct return type from the Map function, necessary to infer the ResolveExecutorAndMap function type |
CROOT::Internal::TExecutor::MapRetType< F, unsigned > | |
CROOT::Experimental::REveStraightLineSet::Marker_t | |
CTEveStraightLineSet::Marker_t | |
CMarkerDescription_t | |
CRgl::Pad::MarkerPainter | |
CROOT::RWebWindow::MasterConn | |
►Cmathtext::math_text_renderer_t | |
CTMathTextRenderer | |
CROOT::Math::MathMoreLib | |
CROOT::Math::MatRepStd< T, D1, D2 > | Expression wrapper class for Matrix objects |
CROOT::Math::MatRepStd< T, D1, D1 > | |
CROOT::Math::MatRepSym< T, D > | MatRepSym Matrix storage representation for a symmetric matrix of dimension NxN This class is a template on the contained type and on the symmetric matrix size, N |
CROOT::Minuit2::MatrixInverse< mtype, M, T > | |
CROOT::Minuit2::MatrixInverse< vec, M, T > | |
CROOT::Math::MatrixMulOp< MatrixA, MatrixB, T, D > | Class for Matrix-Matrix multiplication |
Cmd5_state_s | |
CTProof::MD5Mod_t | |
CTMVA::DNN::MeanVariance | |
CROOT::Meta::Selection::MemberAttributes< memberAttributes > | Used to specify attributes of data members in the "DictSelection" syntax |
CROOT::Math::ParamMemFunHandler< ParentFunctor, PointerToObj, PointerToMemFn >::MemFuncEvaluator< PObj, F, T > | |
CMemInfo_t | |
►CMemory_t | |
CRooBatchCompute::CudaInterface::Array< Data_t, Memory_t > | A templated class for managing an array of data using a specified memory type |
CCPyCppyy::MemoryRegulator | |
CRgl::Pad::MeshPatch_t | |
CRooFit::MultiProcess::Messenger | Manages ZeroMQ sockets and wraps send and receive calls |
CROOT::Math::meta_col_dot< I > | |
CROOT::Math::meta_col_dot< 0 > | |
CROOT::Math::meta_dot< I > | |
CROOT::Math::meta_dot< 0 > | |
CROOT::Math::meta_mag< I > | |
CROOT::Math::meta_mag< 0 > | |
CROOT::Math::meta_matrix_dot< I > | |
CROOT::Math::meta_matrix_dot< 0 > | |
CROOT::Math::meta_row_dot< I > | |
CROOT::Math::meta_row_dot< 0 > | |
CTGenCollectionProxy::Method | Small helper to execute (compiler) generated function for the access to STL or other containers |
CTGenCollectionProxy::Method0 | |
►CTMVA::MethodCFMlpANN_Utils | Implementation of Clermond-Ferrand artificial neural network |
CTMVA::MethodCFMlpANN | Interface to Clermond-Ferrand artificial neural network |
CCPyCppyy::CPPOverload::MethodInfo_t | |
Cmg_callbacks | |
Cmg_client_cert | |
Cmg_client_options | |
Cmg_connection | |
Cmg_context | |
Cmg_domain_context | |
Cmg_error_data | |
Cmg_file | |
Cmg_file_access | |
Cmg_file_stat | |
Cmg_form_data_handler | |
Cmg_handler_info | |
Cmg_header | |
Cmg_http_method_info | |
Cmg_init_data | |
Cmg_option | |
Cmg_request_info | |
Cmg_response_info | |
Cmg_server_port | |
Cmg_websocket_subprotocols | |
Cmg_workerTLS | |
►CROOT::Math::Minimizer | Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2, Minuit, GSL, etc..) in ROOT |
►CROOT::Math::BasicMinimizer | Base Minimizer class, which defines the basic functionality of various minimizer implementations (apart from Minuit and Minuit2) It provides support for storing parameter values, step size, parameter transformation etc |
CROOT::Math::GSLMinimizer | GSLMinimizer class |
CROOT::Math::GSLNLSMinimizer | GSLNLSMinimizer class for Non Linear Least Square fitting It Uses the Levemberg-Marquardt algorithm from GSL Non Linear Least Square fitting |
CROOT::Math::GSLSimAnMinimizer | GSLSimAnMinimizer class for minimization using simulated annealing using the algorithm from GSL |
CROOT::Math::RMinimizer | RMinimizer class |
CROOT::Math::GeneticMinimizer | GeneticMinimizer |
CROOT::Minuit2::Minuit2Minimizer | Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for Minuit2 minimization algorithm |
CTFumiliMinimizer | TFumiliMinimizer class: minimizer implementation based on TFumili |
CTLinearMinimizer | TLinearMinimizer class: minimizer implementation based on TMinuit |
CTMinuitMinimizer | TMinuitMinimizer class: ROOT::Math::Minimizer implementation based on TMinuit |
CROOT::Math::MinimizerOptions | Minimizer options |
►CROOT::Math::MinimizerVariableTransformation | Base class for MinimizerVariable transformations defining the functions to deal with bounded parameters |
CROOT::Math::SinVariableTransformation | Sin Transformation class for dealing with double bounded variables |
CROOT::Math::SqrtLowVariableTransformation | Sqrt Transformation class for dealing with lower bounded variables |
CROOT::Math::SqrtUpVariableTransformation | Sqrt Transformation class for dealing with upper bounded variables |
CROOT::Math::MinimTransformVariable | MinimTransformVariable class Contains meta information of the variables such as bounds, fix flags and deals with transformation of the variable The class does not contain the values and the step size (error) of the variable This is an internal class used by the MinimTransformFunction class |
►CROOT::Minuit2::MinimumBuilder | |
CROOT::Minuit2::CombinedMinimumBuilder | |
CROOT::Minuit2::FumiliBuilder | Builds the FunctionMinimum using the Fumili method |
CROOT::Minuit2::ScanBuilder | Performs a minimization using the simplex method of Nelder and Mead (ref |
CROOT::Minuit2::SimplexBuilder | Performs a minimization using the simplex method of Nelder and Mead (ref |
CROOT::Minuit2::VariableMetricBuilder | Build (find) function minimum using the Variable Metric method (MIGRAD) Two possible error updators can be chosen |
CROOT::Minuit2::MinimumError | MinimumError keeps the inv |
►CROOT::Minuit2::MinimumErrorUpdator | |
CROOT::Minuit2::BFGSErrorUpdator | Update of the covariance matrix for the Variable Metric minimizer (MIGRAD) |
CROOT::Minuit2::DavidonErrorUpdator | Update of the covariance matrix for the Variable Metric minimizer (MIGRAD) |
CROOT::Minuit2::FumiliErrorUpdator | In the case of the Fumili algorithm the Error matrix (or the Hessian matrix containing the (approximate) second derivatives) is calculated using a linearization of the model function negleting second derivatives |
CROOT::Minuit2::MinimumParameters | |
CROOT::Minuit2::MinimumSeed | |
►CROOT::Minuit2::MinimumSeedGenerator | Base class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization; |
CROOT::Minuit2::MnSeedGenerator | Concrete implementation of the MinimumSeedGenerator interface; used within ModularFunctionMinimizer; |
CROOT::Minuit2::SimplexSeedGenerator | Generate Simplex starting point (state) |
CROOT::Minuit2::MinimumState | MinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder) |
Cbvh::v2::MiniTreeBuilder< Node, MortonCode > | Multi-threaded top-down builder that partitions primitives using a grid |
CROOT::Math::MinOp< T > | Subtraction Operation Class |
CROOT::Minuit2::MinosError | Class holding the result of Minos (lower and upper values) for a specific parameter |
CROOT::Minuit2::MinuitParameter | Class for the individual Minuit Parameter with Name and number; contains the input numbers for the minimization or the output result from minimization; possible interactions: Fix/release, set/remove limits, set Value/error; |
CROOT::Math::Minus< T > | Unary Minus Operation Class |
CROOT::Math::MinusEquals< T, D1, D2, A, R1, R2 > | Evaluate the expression performing a -= operation Need to check whether creating a temporary object with the expression result (like in op: A -= A * B ) |
CROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > > | Specialization for symmetrix -= general : NOT Allowed operation |
CROOT::Math::MinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > > | Specialization for symmetric matrices |
CROOT::Experimental::REveManager::MIR | |
CMIR_TL_Data_t | |
CROOT::Math::MiserParameters | Structure collecting parameters for MISER multidimensional integration |
CTTreeCache::MissCache | |
CROOT::Math::MixMaxEngineImpl< N > | |
CROOT::Math::MixMaxEngineImpl< ROOT_MM_N > | |
►CROOT::Minuit2::MnApplication | Application interface class for minimizers (migrad, simplex, Minimize, Scan) User normally instantiates the derived class like ROOT::Minuit2::MnMigrad for using Migrad for minimization |
CROOT::Minuit2::MnFumiliMinimize | API class for minimization using Fumili technology; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc.; also used by MnMinos and MnContours; |
CROOT::Minuit2::MnMigrad | API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc.; also used by MnMinos and MnContours; |
CROOT::Minuit2::MnMinimize | API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc.; also used by MnMinos and MnContours; |
CROOT::Minuit2::MnScan | API class for minimization using a scan method to find the minimum; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc.; |
CROOT::Minuit2::MnSimplex | API class for minimization using the Simplex method, which does not need and use the derivatives of the function, but only function values |
CROOT::Minuit2::MnContours | API class for Contours Error analysis (2-dim errors); minimization has to be done before and Minimum must be valid; possibility to ask only for the points or the points and associated Minos errors; |
CROOT::Minuit2::MnCovarianceSqueeze | Class to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index |
CROOT::Minuit2::MnCross | |
CROOT::Minuit2::MnEigen | API class for calculating the eigenvalues of symmetric matrix |
►CROOT::Minuit2::MnFcn | Wrapper class to FCNBase interface used internally by Minuit |
CROOT::Minuit2::MnUserFcn | Wrapper used by Minuit of FCN interface containing a reference to the transformation object |
CROOT::Minuit2::MnFunctionCross | MnFunctionCross |
CROOT::Minuit2::MnGlobalCorrelationCoeff | Class for global correlation coefficient |
CROOT::Minuit2::MnHesse | API class for calculating the numerical covariance matrix (== 2x Inverse Hessian == 2x Inverse 2nd derivative); can be used by the user or Minuit itself |
CROOT::Minuit2::MnLineSearch | Implements a 1-dimensional minimization along a given direction (i.e |
CROOT::Minuit2::MnMachinePrecision | Sets the relative floating point (double) arithmetic precision |
CROOT::Minuit2::MnMinos | API class for Minos Error analysis (asymmetric errors); minimization has to be done before and Minimum must be valid; possibility to ask only for one side of the Minos Error; |
CROOT::Minuit2::MnParabola | This class defines a parabola of the form a*x*x + b*x + c |
CROOT::Minuit2::MnParabolaFactory | |
CROOT::Minuit2::MnParabolaPoint | A point of a parabola |
CROOT::Minuit2::MnParameterScan | Scans the values of FCN as a function of one Parameter and retains the best function and Parameter values found |
CROOT::Minuit2::MnParStr | |
CROOT::Minuit2::MnPlot | MnPlot produces a text-screen graphical output of (x,y) points, e.g |
CROOT::Minuit2::MnPosDef | Force the covariance matrix to be positive defined by adding extra terms in the diagonal |
CROOT::Minuit2::MnPrint | |
CROOT::Minuit2::MnRefCountedPointer< T > | |
CROOT::Minuit2::MnReferenceCounter | |
CROOT::Minuit2::MnStrategy | API class for defining four levels of strategies: low (0), medium (1), high (2), very high (>=3); acts on: Migrad (behavioural), Minos (lowers strategy by 1 for Minos-own minimization), Hesse (iterations), Numerical2PDerivative (iterations) |
CROOT::Minuit2::MnTiny | |
►CROOT::Minuit2::MnTraceObject | |
CTMinuit2TraceObject | |
CROOT::Minuit2::MnUserCovariance | Class containing the covariance matrix data represented as a vector of size n*(n+1)/2 Used to hide internal matrix representation to user |
CROOT::Minuit2::MnUserParameters | API class for the user interaction with the parameters; serves as input to the minimizer as well as output from it; users can interact: Fix/release parameters, set values and errors, etc.; parameters can be accessed via their Parameter number (determined internally by Minuit and followed the order how the parameters are created) or via their user-specified Name (10 character string) |
CROOT::Minuit2::MnUserParameterState | Class which holds the external user and/or internal Minuit representation of the parameters and errors; transformation internal <-> external on demand; |
CROOT::Minuit2::MnUserTransformation | Class dealing with the transformation between user specified parameters (external) and internal parameters used for minimization |
CROOT::Minuit2::MnVectorTransform | |
►CROOT::Minuit2::ModularFunctionMinimizer | Base common class providing the API for all the minimizer Various Minimize methods are provided varying on the type of FCN function passesd and on the objects used for the parameters |
CROOT::Minuit2::CombinedMinimizer | Combined minimizer: combination of Migrad and Simplex |
CROOT::Minuit2::FumiliMinimizer | Instantiates the seed generator and Minimum builder for the Fumili minimization method |
CROOT::Minuit2::ScanMinimizer | Class implementing the required methods for a minimization using SCAN API is provided in the upper ROOT::Minuit2::ModularFunctionMinimizer class |
CROOT::Minuit2::SimplexMinimizer | Class implementing the required methods for a minimization using Simplex |
CROOT::Minuit2::VariableMetricMinimizer | Instantiates the SeedGenerator and MinimumBuilder for Variable Metric Minimization method |
►Csnt.Module | |
CTMVA_SOFIE_GNN.EncodeProcessDecode | |
CTMVA_SOFIE_GNN.MLPGraphIndependent | |
CTMVA_SOFIE_GNN.MLPGraphNetwork | |
CTMVA_SOFIE_GNN_Parser.EncodeProcessDecode | |
CTMVA_SOFIE_GNN_Parser.MLPGraphIndependent | |
CTMVA_SOFIE_GNN_Parser.MLPGraphNetwork | |
►Ctorch.nn.Module | |
CPyTorch_Generate_CNN_Model.Reshape | |
Cmodule_state | |
►Cclang::ModuleFileExtension | |
CTClingRdictModuleFileExtension | A module file extension used for testing purposes |
►Cclang::ModuleFileExtensionReader | |
CTClingRdictModuleFileExtension::Reader | |
►Cclang::ModuleFileExtensionWriter | |
CTClingRdictModuleFileExtension::Writer | |
CTMVA::kNN::ModulekNN | |
CTMVA::Monitoring | |
CROOT::Minuit2::MPIProcess | |
CROOT::Minuit2::MPITerminate | |
CROOT::Math::MulOp< T > | Multiplication (element-wise) Operation Class |
CMultiDist | Free functions adapter needed by UNURAN for multidimensional cont distribution |
CROOT::Math::MultPolicy< T, R1, R2 > | Matrix-matrix multiplication policy |
CTCling::MutexStateAndRecurseCount | |
CTCling::MutexStateAndRecurseCountDelta | |
CMWMHintsProperty_t | |
CmyDetectorData | |
CMyFunctor | |
CMYSQL_BIND | |
CMYSQL_STMT | |
CNameCleanerForIO | An helper class to dismount the name and remount it changed whenever necessary |
CTGDMLWrite::NameLst | |
CROOT::Experimental::RNTupleModel::NameWithDescription_t | A wrapper over a field name and an optional description; used in AddField() and RUpdater::AddField() |
Cnan_value_t< Element > | |
CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, Op > | |
CTMVA::Experimental::SOFIE::NaryOperatorTraits< float, EBasicNaryOperator::Mean > | |
CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, EBasicNaryOperator::Max > | |
CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, EBasicNaryOperator::Mean > | |
CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, EBasicNaryOperator::Min > | |
CTMVA::Experimental::SOFIE::NaryOperatorTraits< T, EBasicNaryOperator::Sum > | |
CROOT::Minuit2::NegativeG2LineSearch | In case that one of the components of the second derivative g2 calculated by the numerical Gradient calculator is negative, a 1dim line search in the direction of that component is done in order to find a better position where g2 is again positive |
CTMVA::DNN::Net | Neural net |
CNewColorMapType | |
CRooFit::TestStatistics::NLLFactory | |
Cbvh::v2::Node< T, Dim, IndexBits, PrimCountBits > | Binary BVH node, containing its bounds and an index into its children or the primitives it contains |
CTMVA::kNN::Node< T > | This file contains binary tree and global function template that searches tree for k-nearest neigbors |
►CTMVA::Node | Node for the BinarySearch or Decision Trees |
CTMVA::BinarySearchTreeNode | Node for the BinarySearch or Decision Trees |
CTMVA::CCTreeWrapper::CCTreeNode | |
CTMVA::DecisionTreeNode | |
CTMVA::kNN::Node< TMVA::kNN::Event > | |
CRooFit::NodeInfo | A struct used by the Evaluator to store information on the RooAbsArgs in the computation graph |
CTStreamerInfoActions::NoFactorMarker< From > | |
CROOT::Detail::RDF::ExtraArgsForDefine::None | |
CTClassTable::NormalizeThenLock | |
CRooStats::HistFactory::NormFactor | Configuration for an un- constrained overall systematic to scale sample normalisations |
►C<NSApplicationDelegate> | |
CROOTApplicationDelegate | |
►CNSEvent | |
CFakeCrossingEvent | |
►CNSObject | |
CPassiveKeyGrab | |
CQuartzImage | |
CQuartzPixmap | |
CQuartzWindowProperty | |
CROOTApplicationDelegate | |
CRunStopper | |
CROOT::MacOSX::Util::NSScopeGuard< DerivedType > | |
CROOT::MacOSX::Util::NSScopeGuard< ROOTApplicationDelegate > | |
CROOT::MacOSX::Util::NSStrongReference< DerivedType > | |
CROOT::MacOSX::Util::NSStrongReference< QuartzWindow > | |
►CNSView | |
►CQuartzView | |
CROOTOpenGLView | |
CXorDrawingView | |
►CNSWindow | |
CQuartzWindow | |
CXorDrawingWindow | |
►C<NSWindowDelegate> | |
CQuartzWindow | |
CRooStats::NuisanceParametersSampler | Helper class for ToyMCSampler |
CTMVA::null_t< F > | |
CROOT::Math::NullTypeFunc1D | |
CRooStats::NumberCountingPdfFactory | A factory for building PDFs and data for a number counting combination |
CParamHistFunc::NumBins | |
CTStreamerInfoActions::GenericLooper::Numeric< From, To > | |
CNumericalDerivator | Original version created on: Aug 14, 2013 Authors: L |
CROOT::Minuit2::NumericalDerivator | |
CRooSimWSTool::ObjBuildConfig | |
CROOT::Experimental::Internal::RDaosObject::ObjClassId | Wrap around a daos_oclass_id_t |
►Cobject | |
CROOTwriter.ROOTwriter | |
Cwriter.writer | |
CTClass::ObjectPtr | |
CROOT::Fit::ObjFuncTrait< Func > | |
CROOT::Fit::ObjFuncTrait< ROOT::Math::FitMethodFunction > | |
CROOT::Fit::ObjFuncTrait< ROOT::Math::FitMethodGradFunction > | |
CRooSimWSTool::ObjSplitRule | |
CRooFit::Experimental::RooFuncWrapper::ObsInfo | |
Cbvh::v2::Octant | |
CTODBCStatement::ODBCBufferRec_t | |
CRgl::Pad::OffScreenDevice | |
CROOT::Minuit2::MnPrint::Oneline | |
CTMVA::Experimental::SOFIE::RModelParser_ONNX::OperatorsMapImpl | |
CROOT::option::Option | A parsed option from the command line together with its argument if it has one |
CTMVA::OptionMap | Class to storage options for the differents methods |
CLinkdefReader::Options | |
CROOT::Experimental::RFile::Options_t | Options for RFile construction |
CROOT::Math::IntegOptionsUtil::OptionTrait< OptionType > | |
CROOT::Math::IntegOptionsUtil::OptionTrait< IntegratorMultiDimOptions > | |
CROOT::Math::IntegOptionsUtil::OptionTrait< IntegratorOneDimOptions > | |
CRooFit::MultiProcess::OrderedJobTask | |
CROOT::Experimental::RPalette::OrdinalAndColor | An ordinal value and its associated color |
►Cbvh::v2::OutputStream | Stream of data that can be used to serialize data structures |
Cbvh::v2::StdOutputStream | Stream adapter for standard library output streams |
CRooStats::HistFactory::OverallSys | Configuration for a constrained overall systematic to scale sample normalisations |
COverloadedCall | |
CROOT::Math::CholeskyDecompHelpers::PackedArrayAdapter< G > | Adapter for packed arrays (to SMatrix indexing conventions) |
CPadRefresher | |
CTWebCanvas::PadStatus | |
►Cstd::pair< double, double > | |
CROOT::Experimental::XRooFit::xRooNLLVar::xValueWithError | |
CROOT::Detail::TCollectionProxyInfo::PairHolder< T, Q > | |
CPaltFunction | |
CROOT::Fit::FitUtil::ParamDerivFunc< GradFunc > | |
CCPyCppyy::Parameter | |
CROOT::Fit::ParameterSettings | Class, describing value, limits and step size of the parameters Provides functionality also to set/retrieve values, step sizes, limits and fix the parameters |
CROOT::Math::ParamFunctionBase< T > | Class defining the signature for multi-dim parametric functions |
CROOT::Math::ParamFunctorTempl< T > | Param Functor class for Multidimensional functions |
CROOT::option::Parser | Checks argument vectors for validity and parses them into data structures that are easier to work with |
CROOT::Internal::ParsingStateRAII | RAII used to store Parser, Sema, Preprocessor state for recursive parsing |
CROOT::Internal::RDF::PassAsVecHelper< I, T, F > | |
Cpasswd | |
CPattern | |
CPCREPriv_t | |
CPgSQL_Stmt_t | |
CPictureAttributes_t | |
CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, R1, R2 > | |
CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > > | |
CROOT::Math::PlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepSym< T, D3 > > | |
CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, R1, R2 > | Structure to deal when a submatrix is placed in a matrix |
CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > > | |
CROOT::Math::PlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > > | |
CROOT::Math::PlainParameters | |
CROOT::Math::Impl::Plane3D< T > | Class describing a geometrical plane in 3 dimensions |
CRooAbsData::PlotOpt | |
CRooAbsReal::PlotOpt | |
CTGLHistPainter::PlotOption_t | |
CRgl::PlotTranslation | |
CRooNumIntFactory::PluginInfo | |
CROOT::Math::PlusEquals< T, D1, D2, A, R1, R2 > | Evaluate the expression performing a += operation Need to check whether creating a temporary object with the expression result (like in op: A += A * B ) |
CROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > > | Specialization for symmetrix += general : NOT Allowed operation |
CROOT::Math::PlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > > | Specialization for symmetric matrices Evaluate the expression performing a += operation for symmetric matrices Need to have a separate functions to avoid to modify two times the off-diagonal elements (i.e applying two times the expression) Need to check whether creating a temporary object with the expression result (like in op: A += A * B ) |
CROOT::MacOSX::X11::Point | |
CTColorGradient::Point | |
CTProofDrawListOfGraphs::Point3D_t | |
CTProofDrawListOfPolyMarkers3D::Point4D_t | |
CPoint_t | Point structure (maps to the X11 XPoint structure) |
CROOT::Math::Polar2D< T > | Class describing a polar 2D coordinate system based on r and phi Phi is restricted to be in the range [-PI,PI) |
CROOT::Math::Polar3D< T > | Class describing a polar coordinate system based on r, theta and phi Phi is restricted to be in the range [-PI,PI) |
CROOT::Experimental::REvePolygonSetProjected::Polygon_t | |
CTEvePolygonSetProjected::Polygon_t | |
CRgl::Pad::PolygonStippleSet | |
CROOT::Experimental::RFieldBase::RSchemaIteratorTemplate< IsConstT >::Position | |
CROOT::Math::PositionVector2D< CoordSystem, Tag > | Class describing a generic position vector (point) in 2 dimensions |
CROOT::Math::PositionVector3D< CoordSystem, Tag > | Class describing a generic position vector (point) in 3 dimensions |
►Cclang::PragmaHandler | |
►CLinkdefReaderPragmaHandler | |
CPragmaCreateCollector | |
CPragmaExtraInclude | |
CPragmaIoReadInclude | |
CPragmaLinkCollector | |
CROOT::Minuit2::PrefixStack< T > | |
CRooStats::HistFactory::PreprocessFunction | |
CROOT::Experimental::REveProjection::PreScaleEntry_t | |
CTEveProjection::PreScaleEntry_t | |
CROOT::option::PrintUsageImplementation | |
CRooFit::Experimental::Prio< P > | |
Cprocess_control_data | |
CRooFit::MultiProcess::ProcessManager | Fork processes for queue and workers |
CRooProdPdf::ProcessProductTermOutput | |
CRooFit::MultiProcess::ProcessTimer | Can be used to generate timings of multiple processes simultaneously and output logs |
CProcInfo_t | |
CROOT::Experimental::REveDataProxyBuilderBase::Product | |
CRooFit::JSONIO::Detail::Domains::ProductDomain | |
CRooFit::JSONIO::Detail::Domains::ProductDomain::ProductDomainElement | |
CRooStats::ProfileInspector | Utility class to plot conditional MLE of nuisance parameters vs |
CROOT::Browsable::RProvider::ProgressHandle | |
CROOT::RDF::Experimental::ProgressHelper | RDF progress helper |
CTGLSurfacePainter::Projection_t | |
CROOT::Fit::ProxyListBox | |
CRooAbsArg::ProxyListCache | |
CCPyCppyy::proxyobject | |
CTMVA::PruningInfo | |
CROOT::Math::PtEtaPhiE4D< ScalarType > | Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and E (or rho, phi, eta , T) The metric used is (-,-,-,+) |
CROOT::Math::PtEtaPhiM4D< ScalarType > | Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+) |
Cpthread_cond_t | |
CROOT::Detail::TCollectionProxyInfo::Type< Internal::TStdBitsetHelper< Bitset_t > >::Iterators::PtrSize_t | |
CROOT::Math::PxPyPzE4D< ScalarType > | Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors stored as (Px, Py, Pz, E) |
CROOT::Math::PxPyPzM4D< ScalarType > | Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M) |
►CCPyCppyy::PyCallable | |
►CCPyCppyy::CPPMethod | |
CCPyCppyy::CPPClassMethod | |
►CCPyCppyy::CPPConstructor | |
CCPyCppyy::CPPAbstractClassConstructor | |
CCPyCppyy::CPPAllPrivateClassConstructor | |
CCPyCppyy::CPPIncompleteClassConstructor | |
CCPyCppyy::CPPMultiConstructor | |
CCPyCppyy::CPPNamespaceConstructor | |
►CCPyCppyy::CPPFunction | |
CCPyCppyy::CPPReverseBinary | |
CCPyCppyy::CPPGetItem | |
CCPyCppyy::CPPOperator | |
CCPyCppyy::CPPSetItem | |
CCPyCppyy::PyCallArgs | |
CCPyCppyy::Utility::PyError_t | |
CTMVA::Internal::PyGILRAII | |
CPyROOT::PyObjRefCounter | A PyObject wrapper to track reference counting of external objects |
CCPyCppyy::Utility::PyOperators | |
CCPyCppyy::PyResult | |
CQuad | |
CQuantizedColorType | |
CROOT::Math::QuasiRandom< Engine > | User class for MathMore random numbers template on the Engine type |
CROOT::Math::Quaternion | Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k) |
CRooFit::MultiProcess::Config::Queue | |
►CRooFit::MultiProcess::Queue | Keeps a queue of tasks for workers and manages the queue process through its event loop |
CRooFit::MultiProcess::FIFOQueue | A Queue with simple FIFO behavior |
CRooFit::MultiProcess::PriorityQueue | Queue that orders tasks according to specified task priorities |
CROOT::RWebWindow::QueueEntry | |
CROOT::RWebWindow::QueueItem | |
CTMVA::QuickMVAProbEstimator | |
►CQWidget | |
CExampleWidget | |
CRCanvasWidget | |
CRGeomViewerWidget | |
CTCanvasWidget | |
►CROOT::Internal::RDF::RActionBase | |
CROOT::Internal::RDF::RAction< Helper, PrevNode, ColumnTypes_t > | A RDataFrame node that produces a result |
CROOT::Internal::RDF::RJittedAction | |
CROOT::Internal::RDF::RVariedAction< Helper, PrevNode, ColumnTypes_t > | Just like an RAction, but it has N action helpers and N previous nodes (N is the number of variations) |
CROOT::Detail::RDF::RActionImpl< Helper > | Base class for action helpers, see RInterface::Book() for more information |
►CROOT::Detail::RDF::RActionImpl< ProgressBarAction > | |
CROOT::RDF::Experimental::ProgressBarAction | |
►CROOT::Detail::RDF::RActionImpl< RooAbsDataHelper< DataSet_t > > | |
CRooAbsDataHelper< DataSet_t > | This is a helper for an RDataFrame action, which fills RooFit data classes |
CROOT::Experimental::Internal::RPageSource::RActivePhysicalColumns | Keeps track of the requested physical column IDs and their in-memory target type via a column element identifier |
CROOT::Experimental::Internal::RDaosObject::RAkeyRequest | Contains an attribute key and the associated IOVs for a single scatter-gather I/O request |
CROOT::Math::Random< Engine > | Documentation for the Random class |
CROOT::Math::RandomFunctions< Engine, EngineBaseType > | |
►CROOT::Math::RandomFunctions< EngineType, DefaultEngineType > | |
CROOT::Math::RandomFunctions< EngineType, ROOT::Math::GSLRandomEngine > | Specialized implementation of the Random functions based on the GSL library |
CROOT::Math::RandomFunctionsImpl< EngineBaseType > | Definition of the generic implementation class for the RandomFunctions |
CROOT::Math::RandomFunctionsImpl< DefaultEngineType > | |
CROOT::Math::RandomFunctionsImpl< TRandomEngine > | Implementation class for the RandomFunction for all the engined that derives from TRandomEngine class, which defines an interface which has TRandomEngine::Rndm() In this way we can have a common implementation for the RandomFunctions |
CTMVA::RandomGenerator< TRandomLike, UIntType, max_val > | |
CTMVA::Rank | |
CTMVA::Ranking | Ranking for variables in method (implementation) |
CROOT::Math::RanluxppCompatEngineLuescherImpl< w, p > | |
CROOT::Math::RanluxppEngineImpl< w, p, u > | |
CROOT::Math::RanluxppEngineImpl< w, p > | |
►CROOT::Experimental::RAttrBase | Base class for all attributes, used with RDrawable |
CROOT::Experimental::RAttrValue< double > | |
CROOT::Experimental::RAttrValue< bool > | |
CROOT::Experimental::RAttrValue< ROOT::Experimental::RPadLength > | |
CROOT::Experimental::RAttrValue< ROOT::Experimental::RColor > | |
CROOT::Experimental::RAttrValue< int > | |
CROOT::Experimental::RAttrValue< EStyle > | |
CROOT::Experimental::RAttrValue< EAlign > | |
CROOT::Experimental::RAttrValue< ECorner > | |
►CROOT::Experimental::RAttrAggregation | Base class for attributes aggregations like lines or fill attributes |
CROOT::Experimental::RAttrAxis | All supported axes attributes for: line, ticks, labels, title, min/max, log, reverse, .. |
CROOT::Experimental::RAttrAxisTicks | Axis ticks attributes |
CROOT::Experimental::RAttrFill | Drawing fill attributes for different objects |
CROOT::Experimental::RAttrFont | A font attributes, used together with text attributes |
►CROOT::Experimental::RAttrLine | Drawing line attributes for different objects |
CROOT::Experimental::RAttrBorder | Drawing line attributes for different objects |
CROOT::Experimental::RAttrLineEnding | Attributes for line ending |
CROOT::Experimental::RAttrMargins | A margins attributes. Only relative and pixel coordinates are allowed |
CROOT::Experimental::RAttrMarker | A marker attributes |
►CROOT::Experimental::RAttrText | A text attributes |
CROOT::Experimental::RAttrAxisLabels | Axis labels drawing attributes |
CROOT::Experimental::RAttrAxisTitle | Axis title and its drawing attributes |
CROOT::Experimental::RAttrValue< T > | Template class to access single value from drawable or other attributes |
CTMVA::Experimental::SOFIE::RAttributes_Pool | |
CROOT::Experimental::RAttrMap | |
CTString::RawStr_t | |
►CROOT::Experimental::RAxisBase | Histogram axis base class |
►CROOT::Experimental::RAxisEquidistant | Axis with equidistant bin borders |
►CROOT::Experimental::RAxisGrow | An axis that can extend its range, keeping the number of its bins unchanged |
CROOT::Experimental::RAxisLabels | A RAxisGrow that has a label assigned to each bin and a bin width of 1 |
CROOT::Experimental::RAxisIrregular | An axis with non-equidistant bins (also known as "variable binning") |
CROOT::Experimental::RAxisConfig | Objects used to configure the different axis types |
Cbvh::v2::Ray< T, N > | |
CROOT::Internal::RBaseType< T > | |
CTMVA::Experimental::Internal::RBatchGenerator< Args > | |
CTMVA::Experimental::Internal::RBatchLoader | |
CRbcClass | This file contains the code for cuda computations using the RooBatchCompute library |
CTMVA::Experimental::RBDT | |
CROOT::Experimental::RHistDataMomentUncert< DIMENSIONS, PRECISION >::RBinStat | No-op; this class does not provide per-bin statistics |
CROOT::Experimental::RHistStatContent< DIMENSIONS, PRECISION >::RBinStat | Modifying view on a RHistStatContent for a given bin |
CROOT::Experimental::RHistStatRuntime< DIMENSIONS, PRECISION >::RBinStat | No-op; this class does not provide per-bin statistics |
CROOT::Experimental::RHistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION >::RBinStat | No-op; this class does not provide per-bin statistics |
CROOT::Experimental::RHistStatTotalSumOfWeights< DIMENSIONS, PRECISION >::RBinStat | No-op; this class does not provide per-bin statistics |
CROOT::Experimental::RHistStatUncertainty< DIMENSIONS, PRECISION >::RBinStat | Modifying view on a RHistStatUncertainty for a given bin |
CROOT::Internal::RRawFile::RBlockBuffer | |
CROOT::RTreeViewer::RBranchInfo | |
CROOT::RBrowser | Web-based ROOT files and objects browser |
CROOT::RBrowserData | Way to browse (hopefully) everything in ROOT |
CROOT::RBrowserReply | Reply on browser request |
CROOT::RBrowserRequest | Request send from client to get content of path element |
►CROOT::RBrowserWidget | Abstract Web-based widget, which can be used in the RBrowser Used to embed canvas, geometry viewer and potentially any other widgets |
CRBrowserGeomWidget | |
CRBrowserRCanvasWidget | |
CRBrowserTCanvasWidget | |
CRBrowserTreeWidget | |
CROOT::RBrowserCatchedWidget | |
CROOT::RBrowserEditorWidget | |
CROOT::RBrowserInfoWidget | |
►CROOT::RBrowserWidgetProvider | |
CRBrowserGeomProvider | |
CRBrowserRCanvasProvider | |
CRBrowserTCanvasProvider | |
CRBrowserTreeProvider | |
CROOT::Experimental::RFieldBase::RBulk | Similar to RValue but manages an array of consecutive values |
CROOT::Experimental::RFieldBase::RBulkSpec | |
CRByteSwap< N > | Helper templated class for swapping bytes; specializations for N={2,4,8} are provided below |
CRByteSwap< 2 > | |
CRByteSwap< 4 > | |
CRByteSwap< 8 > | |
CROOT::Internal::RDF::RCallback | |
CROOT::Detail::RDF::RCallCleanUpTask | A RAII object that calls RLoopManager::CleanUpTask at destruction |
CROOT::Experimental::RFieldBase::RCheckResult | Used in the return value of the Check() method |
CTMVA::Experimental::Internal::RChunkLoader< Args > | |
CTMVA::Experimental::Internal::RChunkLoaderFilters< Args > | |
CTMVA::Experimental::Internal::RChunkLoaderFunctor< ColTypes > | |
CTMVA::Experimental::Internal::RChunkLoaderFunctorFilters< ColTypes > | |
CROOT::Experimental::Internal::RCluster | An in-memory subset of the packed and compressed pages of a cluster |
CROOT::Experimental::RClusterDescriptor | Meta-data for a set of ntuple clusters |
CROOT::Experimental::Internal::RClusterDescriptorBuilder | A helper class for piece-wise construction of an RClusterDescriptor |
CROOT::Experimental::RNTupleDescriptor::RClusterDescriptorIterable | Used to loop over all the clusters of an ntuple (in unspecified order) |
CROOT::Experimental::Internal::RNTupleSerializer::RClusterGroup | |
CROOT::Experimental::RClusterGroupDescriptor | Clusters are bundled in cluster groups |
CROOT::Experimental::Internal::RClusterGroupDescriptorBuilder | A helper class for piece-wise construction of an RClusterGroupDescriptor |
CROOT::Experimental::RNTupleDescriptor::RClusterGroupDescriptorIterable | Used to loop over all the cluster groups of an ntuple (in unspecified order) |
CROOT::Experimental::Internal::RPage::RClusterInfo | Stores information about the cluster in which this page resides |
CROOT::Experimental::Internal::RPageSource::RClusterInfo | Summarizes cluster-level information that are necessary to load a certain page |
CROOT::Experimental::Internal::RClusterPool | Managed a set of clusters containing compressed and packed pages |
CROOT::Experimental::Internal::RNTupleSerializer::RClusterSummary | |
CROOT::Experimental::RProxiedCollectionField::RCollectionIterableOnce | Allows for iterating over the elements of a proxied collection |
CROOT::Experimental::RColor | The color class |
CROOT::Experimental::Internal::RColumn | A column is a storage-backed array of a simple, fixed-size type, from which pages can be mapped into memory |
CROOT::Experimental::Internal::RPageSinkBuf::RColumnBuf | A buffered column |
CROOT::Experimental::RColumnDescriptor | Meta-data stored for every column of an ntuple |
CROOT::Experimental::Internal::RColumnDescriptorBuilder | A helper class for piece-wise construction of an RColumnDescriptor |
CROOT::Experimental::RNTupleDescriptor::RColumnDescriptorIterable | Used to loop over a field's associated columns |
CROOT::Experimental::Internal::RColumnElementBase | A column element encapsulates the translation between basic C++ types and their column representation |
CROOT::Experimental::Internal::RPageStorage::RColumnHandle | |
CROOT::Experimental::Internal::RColumnIndex | The in-memory representation of a 32bit or 64bit on-disk index column |
CROOT::Experimental::Internal::RPageSink::RStagedCluster::RColumnInfo | |
CROOT::Experimental::Internal::RPageSource::RActivePhysicalColumns::RColumnInfo | |
CROOT::Experimental::Internal::RWritePageMemoryManager::RColumnInfo | |
CROOT::Experimental::RNTupleInspector::RColumnInspector | Provides column-level storage information |
CROOT::Experimental::Internal::RColumnMergeInfo | |
CROOT::Experimental::RClusterDescriptor::RColumnRange | The window of element indexes of a particular column in a particular cluster |
CROOT::Experimental::RClusterDescriptor::RColumnRangeIterable | |
►CROOT::Detail::RDF::RColumnReaderBase | |
CROOT::Experimental::Internal::RNTupleColumnReader | Every RDF column is represented by exactly one RNTuple field |
CROOT::Internal::RDF::RDSColumnReader< T > | Column reader type that deals with values read from RDataSources |
CROOT::Internal::RDF::RDefineReader | Column reader for defined columns |
CROOT::Internal::RDF::RTreeColumnReader< T > | RTreeColumnReader specialization for TTree values read via TTreeReaderValues |
CROOT::Internal::RDF::RTreeColumnReader< RVec< T > > | RTreeColumnReader specialization for TTree values read via TTreeReaderArrays |
CROOT::Internal::RDF::RTreeColumnReader< RVec< bool > > | RTreeColumnReader specialization for arrays of boolean values read via TTreeReaderArrays |
CROOT::Internal::RDF::RTreeOpaqueColumnReader | |
CROOT::Internal::RDF::RVariationReader | Column reader that reads the value for a specific column, variation and slot |
CRColumnReaderBase | Pure virtual base class for all column reader types |
CROOT::Internal::RDF::RColumnReadersInfo | This type aggregates some of the arguments passed to GetColumnReaders |
CROOT::Internal::RDF::RColumnRegister | A binder for user-defined columns, variations and aliases |
CROOT::Experimental::RFieldBase::RColumnRepresentations | Some fields have multiple possible column representations, e.g |
CROOT::Experimental::Internal::RColumnSwitch | Holds the index and the tag of a kSwitch column |
CROOT::Experimental::Internal::RNTupleJoinTable::RCombinedJoinFieldValue | Container for the hashes of the join fields |
CROOT::Experimental::Internal::RNTupleJoinTable::RCombinedJoinFieldValueHash | Hash combining the individual join field value hashes from RCombinedJoinFieldValue |
CROOT::Experimental::RFitPanelModel::RComboBoxItem | Generic item for ui5 ComboBox |
CROOT::RCompressionSetting | The global settings depend on a global variable named R__ZipMode which can be modified by a global function named R__SetZipMode |
CROOT::Experimental::Internal::RComputeGlobalBin< I, NDIMS, BINS, AXES > | Recursively gets the total number of regular bins before the current dimension, when computing a global bin that is in under- or overflow in at least one dimension |
CROOT::Experimental::Internal::RComputeGlobalBin<-1, NDIMS, BINS, AXES > | |
CROOT::Experimental::Internal::RComputeGlobalBinRaw< I, NDIMS, BINS, AXES, BINTYPE > | Recursively computes a zero-based global bin index, given.. |
CROOT::Experimental::Internal::RComputeGlobalBinRaw<-1, NDIMS, BINS, AXES, BINTYPE > | |
CROOT::Experimental::Internal::RComputeLocalBins< I, NDIMS, AXES > | Recursively computes the number of regular bins before the current dimension, as well as the number of under- and overflow bins left to account for, after the current dimension |
CROOT::Experimental::Internal::RComputeLocalBins< 0, NDIMS, AXES > | |
CROOT::Experimental::Internal::RComputeLocalBinsInitialisation< I, NDIMS, AXES > | Recursively compute some quantities needed for ComputeLocalBins , namely the total number of bins per hyperplane (overflow and regular) and the number of regular bins per hyperplane on the hyperplanes that have them |
CROOT::Experimental::Internal::RComputeLocalBinsInitialisation< 0, NDIMS, AXES > | |
CROOT::Experimental::Internal::RComputeLocalBinsRaw< I, NDIMS, BINS, AXES, BINTYPE > | Recursively computes zero-based local bin indices, given.. |
CROOT::Experimental::Internal::RComputeLocalBinsRaw<-1, NDIMS, BINS, AXES, BINTYPE > | |
CROOT::Internal::RConcurrentHashColl | This class is a thread-safe associative collection connecting a 256 bits digest/hash to a collection of uid (integer) This is used in the handling of the StreamerInfo record in TFile |
CROOT::RTreeViewer::RConfig | |
CROOT::Experimental::RHistStatContent< DIMENSIONS, PRECISION >::RConstBinStat | Const view on a RHistStatContent for a given bin |
CROOT::Experimental::RHistStatUncertainty< DIMENSIONS, PRECISION >::RConstBinStat | Const view on a RHistStatUncertainty for a given bin |
CROOT::TMetaUtils::RConstructorType | |
CROOT::Experimental::Internal::RNTupleSerializer::RContext | The serialization context is used for the piecewise serialization of a descriptor |
CROOT::Experimental::Internal::RPagePersistentSink::RCounters | Default I/O performance counters that get registered in fMetrics |
CROOT::Experimental::Internal::RPageSinkBuf::RCounters | I/O performance counters that get registered in fMetrics |
CROOT::Experimental::Internal::RPageSource::RCounters | Default I/O performance counters that get registered in fMetrics |
CROOT::Experimental::RCreateFieldOptions | |
CROOT::Experimental::RNTupleDescriptor::RCreateModelOptions | Modifiers passed to CreateModel |
CROOT::Experimental::RFieldBase::RCreateObjectDeleter< T > | |
CROOT::Experimental::RFieldBase::RCreateObjectDeleter< void > | |
CROOT::RDF::RCutFlowReport | |
CROOT::Experimental::Internal::RDaosContainer | A RDaosContainer provides read/write access to objects in a given container |
CROOT::Experimental::Internal::RDaosEventQueue | |
CROOT::Experimental::Internal::RDaosNTupleAnchor | Entry point for an RNTuple in a DAOS container |
CROOT::Experimental::Internal::RDaosObject | Provides low-level access to DAOS objects in a container |
CROOT::Experimental::Internal::RDaosPool | A RDaosPool provides access to containers in a specific DAOS pool |
CROOT::RDF::Experimental::RDatasetSpec | The dataset specification for RDataFrame |
►CROOT::RDF::RDataSource | RDataSource defines an API that RDataFrame can use to read arbitrary data formats |
CROOT::Experimental::RNTupleDS | The RDataSource implementation for RNTuple |
CROOT::Internal::RDF::RRootDS | This class is unused and it has only been implemented as a proof of concept |
CROOT::Internal::RDF::RVecDS< ColumnTypes > | A RDataSource implementation which takes a collection of RVecs, which are able to adopt data from Numpy arrays |
CROOT::RDF::RArrowDS | RDataFrame data source class to interface with Apache Arrow |
CROOT::RDF::RCsvDS | RDataFrame data source class for reading CSV files |
CROOT::RDF::RLazyDS< ColumnTypes > | A RDataSource implementation which is built on top of result proxies |
CROOT::RDF::RSqliteDS | RSqliteDS is an RDF data source implementation for SQL result sets from sqlite3 files |
CROOT::RDF::RTrivialDS | A simple data-source implementation, for demo purposes |
CROOT::Internal::RDavixFileDes | |
►CROOT::Detail::RDF::RDefineBase | |
CROOT::Detail::RDF::RDefaultValueFor< T > | The implementation of the DefaultValueFor transformation |
CROOT::Detail::RDF::RDefine< F, ExtraArgsTag > | |
CROOT::Detail::RDF::RDefinePerSample< F > | |
CROOT::Detail::RDF::RJittedDefine | A wrapper around a concrete RDefine, which forwards all calls to it RJittedDefine is a placeholder that is put in the collection of custom columns in place of a RDefine that will be just-in-time compiled |
CROOT::Internal::RDF::RDefinesWithReaders | A helper type that keeps track of RDefine objects and their corresponding RDefineReaders |
►CROOT::Experimental::RFieldBase::RDeleter | A functor to release the memory acquired by CreateValue (memory and constructor) |
CROOT::Experimental::RArrayField::RArrayDeleter | |
CROOT::Experimental::RClassField::RClassDeleter | |
CROOT::Experimental::RFieldBase::RTypedDeleter< T > | A deleter for templated RFieldBase descendents where the value type is known |
CROOT::Experimental::ROptionalField::ROptionalDeleter | |
CROOT::Experimental::RProxiedCollectionField::RProxiedCollectionDeleter | |
CROOT::Experimental::RRVecField::RRVecDeleter | RRVecDeleter is also used by RArrayAsRVecField and therefore declared public |
CROOT::Experimental::RRecordField::RRecordDeleter | |
CROOT::Experimental::RStreamerField::RStreamerFieldDeleter | |
CROOT::Experimental::RUniquePtrField::RUniquePtrDeleter | |
CROOT::Experimental::RVariantField::RVariantDeleter | |
CROOT::Experimental::RVectorField::RVectorDeleter | |
CROOT::RDF::RDFDescription | A DFDescription contains useful information about a given RDataFrame computation graph |
►CROOT::Experimental::RDirectory | Key/value store of objects |
►CROOT::Experimental::RFile | A ROOT file |
CROOT::Experimental::Internal::RFileSharedPtrCtor | |
CROOT::Experimental::Internal::RDirectoryEntry | |
CROOT::RDF::RDisplay | This class is the textual representation of the content of a columnar dataset |
CROOT::Experimental::RDrawable::RDisplayContext | |
CROOT::Internal::RDF::RDisplayElement | Helper class to let Display print compact tabular representations of the events |
►CROOT::Experimental::RDisplayItem | Base class for painting data for JS |
CROOT::Experimental::RDrawableDisplayItem | Generic display item for RDrawable, just reference drawable itself |
►CROOT::Experimental::RIndirectDisplayItem | Extract (reference) only basic attributes from drawable, but not drawable itself |
CROOT::Experimental::RDisplayHistStat | Object send to client for display of RHistStat, required to avoid sending histogram to the client |
CROOT::Experimental::RHistDisplayItem | |
CROOT::Experimental::TObjectDisplayItem | Display item for TObject with drawing options |
►CROOT::Experimental::RPadBaseDisplayItem | Class RPadBaseDisplayItem |
CROOT::Experimental::RCanvasDisplayItem | Class RCanvasDisplayItem |
CROOT::Experimental::RPadDisplayItem | Class RPadDisplayItem |
►CROOT::Experimental::RDrawable | Base class for drawable entities: objects that can be painted on a RPad |
CROOT::Experimental::RAxisDrawable | Axis drawing |
CROOT::Experimental::RFrame | Holds an area where drawing on user coordinate-system can be performed |
►CROOT::Experimental::RHistDrawableBase | |
►CROOT::Experimental::RHistDrawable< 1 > | |
CROOT::Experimental::RHist1Drawable | |
►CROOT::Experimental::RHistDrawable< 2 > | |
CROOT::Experimental::RHist2Drawable | |
►CROOT::Experimental::RHistDrawable< 3 > | |
CROOT::Experimental::RHist3Drawable | |
CROOT::Experimental::RHistDrawable< DIMENSIONS > | |
CROOT::Experimental::ROnFrameDrawable | Base class for drawable which can be drawn on frame or on pad |
►CROOT::Experimental::RPadBase | Base class for graphic containers for RDrawable -s |
CROOT::Experimental::RCanvas | A window's topmost RPad |
CROOT::Experimental::RPad | Graphic container for RDrawable -s |
CROOT::Experimental::RPaletteDrawable | A color palette draw near the frame |
►CROOT::Experimental::RPave | Base class for paves with text, statistic, legends, placed relative to RFrame position and adjustable height |
►CROOT::Experimental::RHistStatBoxBase | Base class for histogram statistic box, provides graphics attributes and virtual method for fill statistic |
►CROOT::Experimental::RHistStatBox< 1 > | |
CROOT::Experimental::RHist1StatBox | |
►CROOT::Experimental::RHistStatBox< 2 > | |
CROOT::Experimental::RHist2StatBox | |
►CROOT::Experimental::RHistStatBox< 3 > | |
CROOT::Experimental::RHist3StatBox | |
CROOT::Experimental::RHistStatBox< DIMENSIONS > | Template class for statistic box for RHist class |
CROOT::Experimental::TObjectDrawable | Provides v7 drawing facilities for TObject types (TGraph, TH1, TH2, etc) |
►CROOT::Experimental::RDrawableReply | Base class for replies on RDrawableRequest |
CROOT::Experimental::RHistDrawableBase::RReply | |
CROOT::Experimental::RHistStatBoxBase::RReply | |
CROOT::Experimental::RMenuItems | List of items for object context menu |
►CROOT::Experimental::RDrawableRequest | Base class for requests which can be submitted from the clients |
CROOT::Experimental::RChangeAttrRequest | |
CROOT::Experimental::RDrawableExecRequest | Request execution of method of referenced drawable, no reply |
CROOT::Experimental::RDrawableMenuRequest | Request menu items for the drawable object |
CROOT::Experimental::RFrame::RZoomRequest | |
CROOT::Experimental::RHistDrawableBase::RRequest | |
CROOT::Experimental::RHistStatBoxBase::RRequest | |
Cread_auth_file_struct | |
CReadSpeed::ReadSpeedRegex | |
CTStreamerInfoActions::CollectionLooper< Looper >::ReadStreamerLoop< kIsTextT, Ts > | |
CTFormLeafInfo::ReadValueHelper< T > | |
CTFormLeafInfo::ReadValueHelper< Long64_t > | |
CTFormLeafInfo::ReadValueHelper< LongDouble_t > | |
CTFormLeafInfo::ReadValueHelper< ULong64_t > | |
CRealInfo_t | |
CTTreeFormula::RealInstanceCache | |
CTMVA::RuleFitAPI::RealParms | |
►CRooVectorDataStore::RealVector | |
CRooVectorDataStore::RealFullVector | |
CROOT::Experimental::REveCaloData::RebinData_t | |
CTEveCaloData::RebinData_t | |
CROOT::Experimental::RAttrBase::Rec_t | |
CROOT::Experimental::REveSelection::Record | |
CROOT::MacOSX::X11::Rectangle | |
CRectangle_t | Rectangle structure (maps to the X11 XRectangle structure) |
CROOT::Internal::RecurseCounts | |
►Cclang::RecursiveASTVisitor | |
CROOT::Internal::DictSelectionReader | |
CRScanner | |
CR6::Redirect< ndim, T > | |
CR6::Redirect< 1, double > | |
CR6::Redirect< 1, float > | |
CR6::Redirect< 2, double > | |
CR6::Redirect< 2, float > | |
CRedirectHandle_t | |
CRooBatchCompute::ReduceNLLOutput | |
CROOT::ExecutorUtils::ReduceObjects< T > | Merge collection of TObjects |
CRooAbsReal::Ref | A RooAbsReal::Ref can be constructed from a RooAbsReal& or a double that will be implicitly converted to a RooConstVar& |
CROOT::Detail::TStatusBitsChecker::Registry | |
CTMVA::RegressionVariance | Calculate the "SeparationGain" for Regression analysis separation criteria used in various training algorithms |
Cbvh::v2::ReinsertionOptimizer< Node >::Reinsertion | |
Cbvh::v2::ReinsertionOptimizer< Node > | |
►CROOT::Browsable::RElement | Basic element of browsable hierarchy |
CRFieldElement | Browsing element representing of RField |
CRNTupleElement | Browsing element representing of RNTuple |
CROOT::Browsable::RGroup | Group of browsable elements - combines several different elements together |
CROOT::Browsable::RSysFile | |
CROOT::Browsable::RWrapper | Wrapper for other element - to provide different name |
►CROOT::Browsable::TObjectElement | Access to TObject basic properties for RBrowsable |
CROOT::Browsable::TGeoManagerElement | Representing TGeoManager in browsables |
CROOT::Browsable::TGeoNodeElement | Representing TGeoNode in browsables |
CROOT::Browsable::TGeoVolumeElement | Representing TGeoVolume in browsables |
CTCollectionElement | Browsable element for TCollection |
CTColorElement | Element representing TColor |
►CTDirectoryElement | Element representing TDirectory |
CTKeyElement | Element representing TKey from TDirectory |
CTFolderElement | Browsable element for TFolder |
►CTTreeBrowsingElement | |
CTBrBrowsableElement | Representing TVirtualBranchBrowsable in browsables |
CTBrElement | Representing TBranch in browsables |
CTBrLeafElement | Representing TLeaf in browsables |
CTTreeElement | Representing TTree in browsables |
CROOT::TypeTraits::RemoveFirst< T, Rest > | |
CROOT::TypeTraits::RemoveFirstParameter< typename > | Remove first of possibly many template parameters |
CROOT::TypeTraits::RemoveFirstParameter< U< T, Rest... > > | |
CROOT::Internal::RDF::RemoveFirstParameterIf< MustRemove, TypeList > | type is TypeList if MustRemove is false, otherwise it is a TypeList with the first type removed |
CROOT::Internal::RDF::RemoveFirstParameterIf< true, TypeList > | |
CROOT::Internal::RDF::RemoveFirstTwoParametersIf< MustRemove, TypeList > | |
CROOT::Internal::RDF::RemoveFirstTwoParametersIf< true, TypeList > | |
CROOT::Experimental::Internal::RPagePool::REntry | Every page in the page pool is annotated with a search key and a reference counter |
CROOT::Experimental::REntry | The REntry is a collection of values in an ntuple corresponding to a complete row in the data set |
CROOT::Experimental::Internal::RPageSource::REntryRange | Used in SetEntryRange / GetEntryRange |
CROOT::RDF::Experimental::RDatasetSpec::REntryRange | |
CROOT::Experimental::RNTupleDS::REntryRangeDS | The PrepareNextRanges() method populates the fNextRanges list with REntryRangeDS records |
CROOT::Experimental::Internal::RNTupleSerializer::REnvelopeLink | |
CTString::Rep_t | |
CROOT::RError | Captures diagnostics related to a ROOT runtime error |
►CXrdCl::ResponseHandler | |
CTAsyncOpenHandler | |
CTAsyncReadvHandler | |
CReadSpeed::Result | |
CROOT::Internal::ExecutorUtils::ResultCaster< O, F > | |
CROOT::Internal::ExecutorUtils::ResultCaster< TObject *, F > | |
CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, R1, R2 > | Structure for getting sub matrices We have different cases according to the matrix representations |
CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > > | |
CROOT::Math::RetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > > | |
CREve3DProjection | 3D scaling projection |
►CROOT::Experimental::REveAunt | |
►CROOT::Experimental::REveAuntAsList | |
►CROOT::Experimental::REveCaloData | |
CROOT::Experimental::REveCaloDataHist | |
CROOT::Experimental::REveCaloDataVec | |
CROOT::Experimental::REveGeoTopNodeData | |
CROOT::Experimental::REveProjectionManager | REveProjectionManager Manager class for steering of projections and managing projected objects |
CROOT::Experimental::REveRGBAPalette | |
CROOT::Experimental::REveSelection | REveSelection Container for selected and highlighted elements |
CREveBox | 3D box with arbitrary vertices (cuboid) |
CREveBoxProjected | Projection of REveBox |
CREveBoxSet | Collection of 3D primitives (fixed-size boxes, boxes of different sizes, or arbitrary sexto-epipeds, cones) |
CREveCalo2D | Visualization of a calorimeter event data in 2D |
CREveCalo3D | Visualization of a calorimeter event data in 3D |
CREveCaloData | A central manager for calorimeter event data |
CREveCaloDataHist | A central manager for calorimeter data of an event written in TH2F |
CROOT::Experimental::REveCaloDataSelector | |
►CROOT::Experimental::REveCaloDataSliceSelector | |
CREveCaloTowerSliceSelector | |
CREveCaloDataVec | Calo data for universal cell geometry |
CREveCaloLego | Visualization of calorimeter data as eta/phi histogram |
CREveCaloViz | Base class for calorimeter data visualization |
CREveChunkManager | Vector-like container with chunked memory allocation |
►CROOT::Experimental::REveChunkManager | |
CROOT::Experimental::REveChunkVector< T > | |
CROOT::Experimental::REveClient | |
CROOT::Experimental::REveCluster | REveCluster Reconstructed cluster (also used in VSD) |
CREveCompound | Description of REveCompound |
CREveCompoundProjected | Description of REveCompoundProjected |
CROOT::Experimental::REveDataItem | |
►CROOT::Experimental::REveDataProxyBuilderBase | |
CCaloTowerProxyBuilder | |
►CROOT::Experimental::REveDataSimpleProxyBuilder | |
►CROOT::Experimental::REveDataSimpleProxyBuilderTemplate< Jet > | |
CJetProxyBuilder | |
►CROOT::Experimental::REveDataSimpleProxyBuilderTemplate< TParticle > | |
CTParticleProxyBuilder | |
CROOT::Experimental::REveDataSimpleProxyBuilderTemplate< T > | |
CROOT::Experimental::REveTableProxyBuilder | |
CRecHitProxyBuilder | |
CREveDigitSet | Base-class for storage of digit collections; provides transformation matrix (REveTrans), signal to color mapping (REveRGBAPalette) and visual grouping (REveFrameBox) |
►CREveElement | Base class for REveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management |
CEventManager | |
►CROOT::Experimental::REveElement | |
CEventManager | |
CROOT::Experimental::REveCaloData | |
►CROOT::Experimental::REveCaloViz | |
CROOT::Experimental::REveCalo2D | |
CROOT::Experimental::REveCalo3D | |
CROOT::Experimental::REveCaloLego | |
►CROOT::Experimental::REveCompound | |
CROOT::Experimental::REveCollectionCompound | |
CROOT::Experimental::REveCompoundProjected | |
CROOT::Experimental::REveDataCollection | |
CROOT::Experimental::REveDataColumn | |
CROOT::Experimental::REveDataItemList | |
CROOT::Experimental::REveDataTable | |
►CROOT::Experimental::REveDigitSet | |
►CROOT::Experimental::REveBoxSet | |
CRecHitProxyBuilder::FWBoxSet | |
CROOT::Experimental::REveGeoTopNodeData | |
CROOT::Experimental::REveGeoTopNodeViz | |
►CROOT::Experimental::REvePointSet | |
►CROOT::Experimental::REveLine | REveLine An arbitrary polyline with fixed line and marker attributes |
CROOT::Experimental::REveLineProjected | |
►CROOT::Experimental::REveTrack | REveTrack Track with given vertex, momentum and optional referece-points (path-marks) along its path |
CROOT::Experimental::REveTrackProjected | REveTrackProjected Projected copy of a REveTrack |
CROOT::Experimental::REvePointSetProjected | |
CROOT::Experimental::REvePointSetArray | |
CROOT::Experimental::REveProjectionManager | REveProjectionManager Manager class for steering of projections and managing projected objects |
CROOT::Experimental::REveRGBAPalette | |
CROOT::Experimental::REveScene | |
CROOT::Experimental::REveSceneInfo | REveSceneInfo Scene in a viewer |
CROOT::Experimental::REveSceneList | |
CROOT::Experimental::REveSelection | REveSelection Container for selected and highlighted elements |
►CROOT::Experimental::REveShape | |
CROOT::Experimental::REveBox | |
CROOT::Experimental::REveBoxProjected | |
CROOT::Experimental::REveGeoShape | |
CROOT::Experimental::REveGeoShapeProjected | |
CROOT::Experimental::REveJetCone | |
CROOT::Experimental::REveJetConeProjected | |
CROOT::Experimental::REvePolygonSetProjected | |
CROOT::Experimental::REveText | |
►CROOT::Experimental::REveStraightLineSet | REveStraightLineSet Set of straight lines with optional markers along the lines |
CROOT::Experimental::REveEllipsoid | |
CROOT::Experimental::REveScalableStraightLineSet | |
►CROOT::Experimental::REveStraightLineSetProjected | REveStraightLineSetProjected Projected copy of a REveStraightLineSet |
CROOT::Experimental::REveEllipsoidProjected | |
CROOT::Experimental::REveTableViewInfo | REveTableViewInfo |
►CROOT::Experimental::REveTrackList | REveTrackList A list of tracks supporting change of common attributes and selection based on track parameters |
CROOT::Experimental::REveTrackListProjected | REveTrackListProjected Specialization of REveTrackList for holding REveTrackProjected objects |
CROOT::Experimental::REveTrackPropagator | REveTrackPropagator Calculates path of a particle taking into account special path-marks and imposed boundaries |
CROOT::Experimental::REveViewer | REveViewer Reve representation of TGLViewer |
CROOT::Experimental::REveViewerList | REveViewerList List of Viewers providing common operations on REveViewer collections |
CREveException | Exception class thrown by Eve classes and macros |
CREveFrameBox | Description of a 2D or 3D frame that can be used to visually group a set of objects |
CREveGeoManagerHolder | Exception safe wrapper for setting gGeoManager |
CROOT::Experimental::REveGeoManagerHolder | REveGeoManagerHolder Exception-safe global variable holders |
CREveGeoPolyShape | Description of REveGeoPolyShape |
CREveGeoShape | 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) |
CREveGeoShapeExtract | Globally positioned TGeoShape with rendering attributes and an optional list of daughter shape-extracts |
CREveGeoShapeProjected | A 3D projected REveGeoShape |
CROOT::Experimental::REveHit | REveHit Monte Carlo hit (also used in VSD) |
CREveJetCone | Draws a jet cone with leading particle is specified in (eta,phi) and cone radius is given |
CREveJetConeProjected | Projection of REveJetCone |
CREveLine | An arbitrary polyline with fixed line and marker attributes |
CREveLineProjected | Projected copy of a REveLine |
CREveMagField | Abstract base-class for interfacing to magnetic field needed by the REveTrackPropagator |
►CROOT::Experimental::REveMagField | REveMagField Abstract interface to magnetic field |
CROOT::Experimental::REveMagFieldConst | REveMagFieldConst Interface to constant magnetic field |
CROOT::Experimental::REveMagFieldDuo | REveMagFieldDuo Interface to magnetic field with two different values depending on radius |
CREveMagFieldConst | Implements constant magnetic field, given by a vector fB |
CREveMagFieldDuo | Implements constant magnetic filed that switches on given axial radius fR2 from vector fBIn to fBOut |
CREveManager | Central application manager for web-based REve |
CROOT::Experimental::REveManager | |
CROOT::Experimental::REveMCRecCrossRef | REveMCRecCrossRef Cross-reference of sim/rec data per particle (also used in VSD) |
CROOT::Experimental::REvePathMarkT< TT > | Special-point on track: |
CREvePointSelector | REvePointSelector is a sub-class of TSelectorDraw for direct extraction of point-like data from a Tree |
CREvePointSelectorConsumer | REvePointSelectorConsumer is a virtual base for classes that can be filled from TTree data via the REvePointSelector class |
CROOT::Experimental::REvePointSelectorConsumer | |
CREvePointSet | REvePointSet 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) |
CREvePointSetArray | An array of point-sets with each point-set playing a role of a bin in a histogram |
CREvePointSetProjected | Projected copy of a REvePointSet |
CREvePolygonSetProjected | A set of projected polygons |
CREveProjectable | Abstract base-class for non-linear projectable objects |
►CROOT::Experimental::REveProjectable | |
CROOT::Experimental::REveBox | |
CROOT::Experimental::REveCaloViz | |
CROOT::Experimental::REveCompound | |
CROOT::Experimental::REveGeoShape | |
CROOT::Experimental::REveJetCone | |
CROOT::Experimental::REvePointSet | |
CROOT::Experimental::REvePointSetArray | |
CROOT::Experimental::REveStraightLineSet | REveStraightLineSet Set of straight lines with optional markers along the lines |
CROOT::Experimental::REveTrackList | REveTrackList A list of tracks supporting change of common attributes and selection based on track parameters |
CREveProjected | Abstract base class for classes that hold results of a non-linear projection transformation |
►CROOT::Experimental::REveProjected | |
CROOT::Experimental::REveBoxProjected | |
CROOT::Experimental::REveCalo2D | |
CROOT::Experimental::REveCompoundProjected | |
CROOT::Experimental::REveGeoShapeProjected | |
CROOT::Experimental::REveJetConeProjected | |
CROOT::Experimental::REveLineProjected | |
CROOT::Experimental::REvePointSetProjected | |
CROOT::Experimental::REvePolygonSetProjected | |
CROOT::Experimental::REveStraightLineSetProjected | REveStraightLineSetProjected Projected copy of a REveStraightLineSet |
CROOT::Experimental::REveTrackListProjected | REveTrackListProjected Specialization of REveTrackList for holding REveTrackProjected objects |
CROOT::Experimental::REveTrackProjected | REveTrackProjected Projected copy of a REveTrack |
CREveProjection | Base-class for non-linear projections |
►CROOT::Experimental::REveProjection | REveProjection Base for specific classes that implement non-linear projections |
CROOT::Experimental::REve3DProjection | |
CROOT::Experimental::REveRPhiProjection | |
CROOT::Experimental::REveRhoZProjection | |
CROOT::Experimental::REveXZProjection | |
CROOT::Experimental::REveYZProjection | |
CROOT::Experimental::REveZXProjection | |
CROOT::Experimental::REveZYProjection | |
CREveProjectionManager | Manager class for steering of projections and managing projected objects |
CROOT::Experimental::REveRecCascade | REveRecCascade |
CROOT::Experimental::REveRecKink | REveRecKink Reconstructed kink (also used in VSD) |
CROOT::Experimental::REveRecTrackT< TT > | REveRecTrack Template for reconstructed track (also used in VSD) |
CROOT::Experimental::REveRecTrackT< Float_t > | |
CROOT::Experimental::REveRecV0 | REveRecV0 |
CREveRefBackPtr | Base-class for reference-counted objects with reverse references to REveElement objects |
CREveRefCnt | Base-class for reference-counted objects |
►CROOT::Experimental::REveRefCnt | REveRefCnt REveRefCnt base-class (interface) |
CROOT::Experimental::REveRGBAPalette | |
►CROOT::Experimental::REveRefBackPtr | REveRefBackPtr reference-count with back pointers |
CROOT::Experimental::REveFrameBox | |
CROOT::Experimental::REveTrackPropagator | REveTrackPropagator Calculates path of a particle taking into account special path-marks and imposed boundaries |
CROOT::Experimental::REveRenderData | |
CREveRGBAPalette | A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes |
CREveRhoZProjection | Transformation from 3D to 2D |
CREveRPhiProjection | XY projection with distortion around given center |
CREveScalableStraightLineSet | Straight-line-set with extra scaling, useful for projectables that need to be scaled in accordance with an external object |
CREveScene | Eve representation of TGLScene |
CREveSceneInfo | Representation of a REveScene in a REveViewer |
CREveSceneList | List of Scenes providing common operations on REveScene collections |
CREveSecondarySelectable | Semi-abstract interface for classes supporting secondary-selection |
►CROOT::Experimental::REveSecondarySelectable | |
CROOT::Experimental::REveCaloData | |
CROOT::Experimental::REveDataItemList | |
CROOT::Experimental::REveDigitSet | |
CROOT::Experimental::REvePointSet | |
CROOT::Experimental::REveStraightLineSet | REveStraightLineSet Set of straight lines with optional markers along the lines |
CREveSelection | Make sure there is a SINGLE running REveSelection for each selection type (select/highlight) |
CREveSelectorToEventList | TSelector that stores entry numbers of matching TTree entries into an event-list |
CROOT::Experimental::REveServerStatus | |
CREveShape | Abstract base-class for 2D/3D shapes |
CREveStraightLineSetProjected | Projected replica of a REveStraightLineSet |
CROOT::Experimental::REveTableEntry | REveTableEntry |
CROOT::Experimental::REveTableHandle | REveTableHandle |
CREveTrack | Visual representation of a track |
CREveTrackList | A list of tracks supporting change of common attributes and selection based on track parameters |
CREveTrackListProjected | Specialization of REveTrackList for holding REveTrackProjected objects |
CREveTrackProjected | Projected copy of a REveTrack |
CREveTrackPropagator | Holding structure for a number of track rendering parameters |
CREveTrans | REveTrans is a 4x4 transformation matrix for homogeneous coordinates stored internally in a column-major order to allow direct usage by GL |
CREveUtil | Standard utility functions for Eve |
CROOT::Experimental::REveUtil | REveUtil Standard utility functions for Reve |
CROOT::Experimental::REveVector2T< TT > | REveVector2T A two-vector template without TObject inheritance and virtual functions |
►CROOT::Experimental::REveVectorT< TT > | REveVectorT A three-vector template without TObject inheritance and virtual functions |
CROOT::Experimental::REveVector4T< TT > | REveVector4T A four-vector template without TObject inheritance and virtual functions |
CROOT::Experimental::REveVectorT< Double_t > | |
CROOT::Experimental::REveVectorT< Float_t > | |
CROOT::Experimental::REveViewContext | |
CREveViewer | Eve representation of a GL view |
CREveViewerList | List of Viewers providing common operations on REveViewer collections |
CREveVSD | Visualization Summary Data - a collection of trees holding standard event data in experiment independent format |
CREveXZProjection | XZ projection with distortion around given center |
CREveYZProjection | YZ projection with distortion around given center |
CREveZXProjection | ZX projection with distortion around given center |
CREveZYProjection | ZY projection with distortion around given center |
CRExceptionHandler | Exception handler for Eve exceptions |
CROOT::Experimental::Internal::RPageSource::RExclDescriptorGuard | An RAII wrapper used for the writable access to RPageSource::fDescriptor . See GetSharedDescriptorGuard() |
CROOT::Experimental::RExtraTypeInfoDescriptor | Field specific extra type information from the header / extenstion header |
CROOT::Experimental::Internal::RExtraTypeInfoDescriptorBuilder | A helper class for piece-wise construction of an RExtraTypeInfoDescriptor |
CROOT::Experimental::RNTupleDescriptor::RExtraTypeInfoDescriptorIterable | Used to loop over all the extra type info record of an ntuple (in unspecified order) |
CROOT::Experimental::Internal::RPagePersistentSink::RFeatures | Set of optional features supported by the persistent sink |
►CROOT::Experimental::RFieldBase | A field translates read and write calls from/to underlying columns to/from tree values |
►CROOT::Experimental::RSimpleField< bool > | |
CROOT::Experimental::RField< bool > | |
►CROOT::Experimental::RSimpleField< char > | |
CROOT::Experimental::RField< char > | |
CROOT::Experimental::RSimpleField< double > | |
CROOT::Experimental::RSimpleField< float > | |
CROOT::Experimental::Internal::RArraySizeField | An artificial field that provides the size of a fixed-size array |
CROOT::Experimental::Internal::RRDFCardinalityField | An artificial field that transforms an RNTuple column that contains the offset of collections into collection sizes |
CROOT::Experimental::RArrayAsRVecField | Additional classes related to sequence containers |
►CROOT::Experimental::RArrayField | Template specializations for C++ std::array and C-style arrays |
►CROOT::Experimental::RField< std::array< ItemT, N > > | |
CROOT::Experimental::RField< ItemT[N]> | |
CROOT::Experimental::RAtomicField | Template specializations for C++ std::atomic |
CROOT::Experimental::RBitsetField | Template specializations for C++ std::bitset |
►CROOT::Experimental::RCardinalityField | An artificial field that transforms an RNTuple column that contains the offset of collections into collection sizes |
CROOT::Experimental::RField< RNTupleCardinality< SizeT > > | |
►CROOT::Experimental::RClassField | The field for a class with dictionary |
CROOT::Experimental::RField< T, typename > | Classes with dictionaries that can be inspected by TClass |
CROOT::Experimental::REnumField | The field for an unscoped or scoped enum with dictionary |
CROOT::Experimental::RField< TObject > | TObject requires special handling of the fBits and fUniqueID members |
CROOT::Experimental::RField< void > | Template specializations for concrete C++ fundamental types |
CROOT::Experimental::RFieldZero | The container field for an ntuple model, which itself has no physical representation |
CROOT::Experimental::RInvalidField | Used in RFieldBase::Check() to record field creation failures |
►CROOT::Experimental::RNullableField | Template specializations for C++ std::optional and std::unique_ptr |
CROOT::Experimental::ROptionalField | |
CROOT::Experimental::RUniquePtrField | |
►CROOT::Experimental::RProxiedCollectionField | The field for a class representing a collection of elements via TVirtualCollectionProxy |
CROOT::Experimental::RMapField | Template specializations for C++ std::[unordered_][multi]map |
CROOT::Experimental::RSetField | Template specializations for C++ std::[unordered_][multi]set |
►CROOT::Experimental::RRVecField | Template specializations for ROOT's RVec |
CROOT::Experimental::RField< ROOT::VecOps::RVec< ItemT > > | |
►CROOT::Experimental::RRecordField | The field for an untyped record |
CROOT::Experimental::RPairField | Template specializations for C++ std::pair |
CROOT::Experimental::RTupleField | Template specializations for C++ std::tuple |
►CROOT::Experimental::RSimpleField< T > | |
►CROOT::Experimental::RRealField< double > | |
CROOT::Experimental::RField< double > | |
►CROOT::Experimental::RRealField< float > | |
CROOT::Experimental::RField< float > | |
CROOT::Experimental::RRealField< T > | |
CROOT::Experimental::RStreamerField | The field for a class using ROOT standard streaming |
CROOT::Experimental::RVariantField | Template specializations for C++ std::variant |
CROOT::Experimental::RVectorField | Template specializations for C++ std::vector |
CROOT::Experimental::RNTupleProcessor::RFieldContext | Manager for a field as part of the RNTupleProcessor |
CROOT::Experimental::RFieldDescriptor | Meta-data stored for every field of an ntuple |
CROOT::Experimental::Internal::RFieldDescriptorBuilder | A helper class for piece-wise construction of an RFieldDescriptor |
CROOT::Experimental::RNTupleDescriptor::RFieldDescriptorIterable | Used to loop over a field's child fields |
CROOT::Experimental::RNTupleDS::RFieldInfo | Holds useful information about fields added to the RNTupleDS |
CROOT::Experimental::Internal::RFieldRepresentationModifier | |
CROOT::Experimental::REntry::RFieldToken | The field token identifies a (sub)field in this entry |
CROOT::Experimental::RNTupleInspector::RFieldTreeInspector | Provides field-level storage information |
►CROOT::Experimental::Detail::RFieldVisitor | Abstract base class for classes implementing the visitor design pattern |
CRFieldProvider::RDrawVisitor | |
CROOT::Experimental::RPrepareVisitor | Visitor used for a pre-processing run to collect information needed by another visitor class |
CROOT::Experimental::RPrintSchemaVisitor | Contains settings for printing and prints a summary of an RField instance |
CROOT::Experimental::RPrintValueVisitor | Renders a JSON value corresponding to the field |
CROOT::RFileDialog | Web-based FileDialog |
CROOT::Experimental::Internal::RNTupleFileWriter::RFileProper | |
CROOT::Experimental::RFilePtr | Points to an object that stores or reads objects in ROOT's binary format |
CROOT::Experimental::Internal::RNTupleFileWriter::RFileSimple | |
CROOT::Experimental::Internal::RFileStorageInterface | Base class for RFile storage backends |
CROOT::Experimental::Internal::RFillIterRange< I, AXES > | Recursively fills the ranges of all axes, excluding under- and overflow |
CROOT::Experimental::Internal::RFillIterRange<-1, AXES > | |
CROOT::Experimental::Internal::RNTupleExporter::RFilter< T > | |
CROOT::Experimental::Internal::RNTupleExporter::RFilter< ROOT::ENTupleColumnType > | |
CROOT::Experimental::Internal::RFindLocalBins< I, NDIMS, BINS, COORD, AXES > | Find the per-axis local bin indices associated with a certain set of coordinates |
CROOT::Experimental::Internal::RFindLocalBins<-1, NDIMS, BINS, COORD, AXES > | |
CRFitPanel | Web-based FitPanel prototype |
CROOT::Experimental::RFitPanel | |
CROOT::Experimental::RFitPanelModel | Data structure for the fit panel |
CROOT::Experimental::RFitResult | |
CROOT::TreeUtils::RFriendInfo | Information about friend trees of a certain TTree or TChain object |
CROOT::Experimental::RFitPanelModel::RFuncPar | Function parameter info, used in edit parameters dialog |
CROOT::Experimental::RFitPanelModel::RFuncParsList | Class used to transfer functions parameters list from/to client |
CROOT::Experimental::RFunction< DIMENSION > | |
►CTMVA::Experimental::SOFIE::RFunction | |
►CTMVA::Experimental::SOFIE::RFunction_Aggregate | |
CTMVA::Experimental::SOFIE::RFunction_Mean | |
CTMVA::Experimental::SOFIE::RFunction_Sum | |
►CTMVA::Experimental::SOFIE::RFunction_Update | |
CTMVA::Experimental::SOFIE::RFunction_MLP | |
CROOT::MacOSX::X11::ColorParser::RGB_t | |
CROOT::RGeomBrowserIter | Iterator of hierarchical geometry structures |
CROOT::RGeomConfig | Configuration parameters which can be configured on the client Send as is to-from client |
CROOT::RGeomDescription | |
CROOT::RGeomDrawing | Object with full description for drawing geometry It includes list of visible items and list of nodes required to build them |
CROOT::RGeomHierarchy | Web-based ROOT geometry hierarchy viewer |
►CROOT::RGeomNodeBase | Base description of geometry node, required only to build hierarchy |
CROOT::RGeomNode | Full node description including matrices and other attributes |
CROOT::RGeomNodeInfo | Node information including rendering data |
CROOT::RGeomNodeVisibility | Custom settings for physical Node visibility |
►CROOT::RGeomRenderInfo | Base class for render info block |
CROOT::RGeomRawRenderInfo | Render info with raw data |
CROOT::RGeomShapeRenderInfo | Render info with shape itself - client can produce shape better |
CROOT::RGeomViewer | Web-based ROOT geometry viewer |
CROOT::RGeomVisible | RGeomVisible contains description of visible node It is path to the node plus reference to shape rendering data |
CROOT::Experimental::Internal::RGetNBinsCount< I, AXES > | Recursively gets the total number of bins in whole hist, including under- and overflow |
CROOT::Experimental::Internal::RGetNBinsCount< 0, AXES > | |
CROOT::Experimental::Internal::RGetNBinsNoOverCount< I, AXES > | Recursively gets the total number of bins in whole hist, excluding under- and overflow |
CROOT::Experimental::Internal::RGetNBinsNoOverCount< 0, AXES > | |
CROOT::Experimental::Internal::RGetNRegularBinsBefore< I, NDIMS, BINS, AXES > | Recursively gets the number of regular bins just before the current dimension |
CROOT::Experimental::Internal::RGetNRegularBinsBefore<-1, NDIMS, BINS, AXES > | |
CROOT::Internal::RHashMap | |
CROOT::Experimental::RNTupleDescriptor::RHeaderExtension | Summarizes information about fields and the corresponding columns that were added after the header has been serialized |
CROOT::Experimental::RHist< DIMENSIONS, PRECISION, STAT > | Histogram class for histograms with DIMENSIONS dimensions, where each bin count is stored by a value of type PRECISION |
►CROOT::Experimental::RHist< DIMENSIONS, PRECISION, RHistStatContent > | |
CROOT::Experimental::RHist< DIMENSIONS, PRECISION > | RHist with no STAT parameter uses RHistStatContent by default |
CROOT::Experimental::Detail::RHistBinPtr< HISTIMPL > | Points to a histogram bin (or actually a RHistBinRef ) |
CROOT::Experimental::Detail::RHistBinRef< HISTIMPL > | Represents a bin reference |
►CROOT::Experimental::Internal::RHistBufferedFillBase< DERIVED, HIST, SIZE > | |
CROOT::Experimental::RHistBufferedFill< HIST, SIZE > | Buffers calls to Fill() |
CROOT::Experimental::Internal::RHistBufferedFillBase< RHistBufferedFill< HIST, 1024 >, HIST, 1024 > | |
►CROOT::Experimental::Internal::RHistBufferedFillBase< RHistConcurrentFiller< HIST, SIZE >, HIST, SIZE > | |
CROOT::Experimental::RHistConcurrentFiller< HIST, SIZE > | Buffers a thread's Fill calls and submits them to the RHistConcurrentFillManager |
CROOT::Experimental::RHistConcurrentFillManager< HIST, SIZE > | Manages the synchronization of calls to FillN() |
CROOT::Experimental::RHistConcurrentFillManager< HIST, SIZE > | |
CROOT::Experimental::RHistDataMomentUncert< DIMENSIONS, PRECISION > | For now do as RH1 : calculate first (xw) and second (x^2w) moment |
CROOT::Experimental::Internal::RHistImplGen< NDIM, IDIM, DATA, PROCESSEDAXISCONFIG > | Generate RHist::fImpl from RHist constructor arguments |
CROOT::Experimental::Internal::RHistImplGen< NDIM, NDIM, DATA, PROCESSEDAXISCONFIG... > | Generate RHist::fImpl from constructor arguments; recursion end |
CROOT::Experimental::Detail::RHistImplPrecisionAgnosticBase< DIMENSIONS > | Base class for RHistImplBase that abstracts out the histogram's PRECISION |
►CROOT::Experimental::Detail::RHistImplPrecisionAgnosticBase< DATA::GetNDim()> | |
►CROOT::Experimental::Detail::RHistImplBase< DATA > | Interface class for RHistImpl |
CROOT::Experimental::Detail::RHistImpl< DATA, AXISCONFIG > | |
CROOT::Experimental::RHistStatContent< DIMENSIONS, PRECISION > | Basic histogram statistics, keeping track of the bin content and the total number of calls to Fill() |
CROOT::Experimental::RHistStatRuntime< DIMENSIONS, PRECISION > | Interface implementing a pure virtual functions DoFill() , DoFillN() |
CROOT::Experimental::RHistStatTotalSumOfSquaredWeights< DIMENSIONS, PRECISION > | Keeps track of the histogram's total sum of squared weights |
CROOT::Experimental::RHistStatTotalSumOfWeights< DIMENSIONS, PRECISION > | Keeps track of the histogram's total sum of weights |
CROOT::Experimental::RHistStatUncertainty< DIMENSIONS, PRECISION > | Histogram statistics to keep track of the Poisson uncertainty per bin |
CROOT::Experimental::RHistView< DIMENSIONS, PRECISION, STAT > | A view on a histogram, selecting a range on a subset of dimensions |
CROOT::Experimental::RHistViewOutOfRange< HISTVIEW > | |
►CROOT::Browsable::RHolder | Basic class for object holder of any kind |
CRFieldHolder | |
CROOT::Browsable::RAnyObjectHolder | Holder of any object instance |
CROOT::Browsable::RShared< T > | |
CROOT::Browsable::RUnique< T > | |
CROOT::Browsable::TObjectHolder | Holder of TObject instance |
CROOT::Math::RichardsonDerivator | User class for calculating the derivatives of a function |
CROOT::Experimental::Internal::RColumnElementBase::RIdentifier | Every concrete RColumnElement type is identified by its on-disk type (column type) and the in-memory C++ type, given by a type index |
CROOT::Experimental::RNTupleImporter::RImportBranch | |
CROOT::Experimental::RNTupleImporter::RImportField | |
CROOT::Experimental::RNTupleImporter::RImportGuard | When the schema is set up and the import started, it needs to be reset before the next Import() call can start |
CROOT::Experimental::RNTupleImporter::RImportLeafCountCollection | Leaf count arrays require special treatment |
►CROOT::Experimental::RNTupleImporter::RImportTransformation | Base class to perform data transformations from TTree branches to RNTuple fields if necessary |
CROOT::Experimental::RNTupleImporter::RCStringTransformation | Transform a NULL terminated C string branch into an std::string field |
CROOT::Experimental::Internal::RIndexIter< REFERENCE, POINTER > | Iterates over an index; the REFERENCE is defined by the REFERENCE template parameter |
►CROOT::Experimental::Internal::RIndexIter< RHistBinRef< HISTIMPL >, RHistBinPtr< HISTIMPL > > | |
CROOT::Experimental::Detail::RHistBinIter< HISTIMPL > | Iterates over the bins of a RHist or RHistImpl |
CROOT::Detail::RDF::RInferredType | |
CROOT::Experimental::Internal::RClusterPool::RInFlightCluster | Clusters that are currently being processed by the pipeline |
CROOT::Experimental::RIntegralField< T > | |
CROOT::Experimental::RIntegralField< Internal::RIntegralTypeMap< T >::type > | |
CROOT::Experimental::Internal::RIntegralTypeMap< T > | |
CROOT::Experimental::Internal::RIntegralTypeMap< int > | |
CROOT::Experimental::Internal::RIntegralTypeMap< long > | |
CROOT::Experimental::Internal::RIntegralTypeMap< long long > | |
CROOT::Experimental::Internal::RIntegralTypeMap< short > | |
CROOT::Experimental::Internal::RIntegralTypeMap< signed char > | |
CROOT::Experimental::Internal::RIntegralTypeMap< unsigned char > | |
CROOT::Experimental::Internal::RIntegralTypeMap< unsigned int > | |
CROOT::Experimental::Internal::RIntegralTypeMap< unsigned long > | |
CROOT::Experimental::Internal::RIntegralTypeMap< unsigned long long > | |
CROOT::Experimental::Internal::RIntegralTypeMap< unsigned short > | |
CRInterfaceBase | The public interface to the RDataFrame federation of classes |
►CROOT::RDF::RInterfaceBase | |
►CROOT::RDF::RInterface< RDFDetail::RLoopManager > | |
CROOT::RDataFrame | ROOT's RDataFrame offers a modern, high-level interface for analysis of data stored in TTree , CSV and other data formats, in C++ or Python |
CROOT::RDF::RInterface< Proxied, DataSource > | The public interface to the RDataFrame federation of classes |
►CROOT::Experimental::Internal::RIOSharedBase | |
CROOT::Experimental::Internal::RIOShared< ROOT::Experimental::Detail::RHistImplPrecisionAgnosticBase > | |
CROOT::Experimental::Internal::RIOShared< TObject > | |
CROOT::Experimental::Internal::RIOShared< T > | |
CROOT::Internal::RIoUring | |
CROOT::Internal::RRawFile::RIOVec | Used for vector reads from multiple offsets into multiple buffers |
CROOT::Internal::RRawFile::RIOVecLimits | Implementations may enforce limits on the use of vector reads |
►CROOT::Browsable::RItem | Representation of single item in the browser |
CROOT::Browsable::RSysFileItem | Representation of single item in the file browser |
CROOT::Browsable::TKeyItem | Representation of single item in the file browser for object from TKey |
CROOT::Browsable::TObjectItem | Representation of single item in the file browser for generic TObject object |
CROOT::RGeoItem | Representation of single item in the geometry browser |
CROOT::Experimental::RFitPanelModel::RItemInfo | Basic function info, used in combo boxes |
CROOT::Experimental::RClusterDescriptor::RColumnRangeIterable::RIterator | |
CROOT::Experimental::RNTupleClusterRange::RIterator | |
CROOT::Experimental::RNTupleDescriptor::RClusterDescriptorIterable::RIterator | |
CROOT::Experimental::RNTupleDescriptor::RClusterGroupDescriptorIterable::RIterator | |
CROOT::Experimental::RNTupleDescriptor::RColumnDescriptorIterable::RIterator | |
CROOT::Experimental::RNTupleDescriptor::RExtraTypeInfoDescriptorIterable::RIterator | |
CROOT::Experimental::RNTupleDescriptor::RFieldDescriptorIterable::RIterator | |
CROOT::Experimental::RNTupleGlobalRange::RIterator | |
CROOT::Experimental::RNTupleProcessor::RIterator | Iterator over the entries of an RNTuple, or vertical concatenation thereof |
CROOT::Experimental::RNTupleReader::RIterator | |
CROOT::Experimental::RProxiedCollectionField::RCollectionIterableOnce::RIterator | |
CROOT::Experimental::RProxiedCollectionField::RCollectionIterableOnce::RIteratorFuncs | |
CROOT::Experimental::Internal::RCluster::RKey | The identifiers that specifies the content of a (partial) cluster |
CROOT::Experimental::Internal::RPagePool::RKey | |
CROOT::Experimental::Internal::RPagePool::RKeyHasher | Hash function to be used in the unordered map fLookupByKey |
►CROOT::Browsable::RLevelIter | Iterator over single level hierarchy like any array, keys list, .. |
CRFieldsIterator | Iterator over RNTuple fields |
CRGroupIter | |
CROOT::Browsable::RSysDirLevelIter | Iterator over files in in sub-directory |
CROOT::Browsable::TGeoVolumeIter | Iterating over nodes in the volume |
CTCollectionIter | Iterator over elements in TCollection |
CTDirectoryLevelIter | Iterator over keys in TDirectory |
CTObjectLevelIter | Iterator over list of elements, designed for support TBrowser usage |
CROOT::Experimental::Internal::RLocalBinsToCoords< I, NDIMS, BINS, COORD, AXES > | Recursively converts local axis bins from the standard kUnderflowBin /kOverflowBin for under/overflow bin indexing convention, to the corresponding bin coordinates |
CROOT::Experimental::Internal::RLocalBinsToCoords<-1, NDIMS, BINS, COORD, AXES > | |
CROOT::Experimental::Internal::RLocalBinsToVirtualBins< I, NDIMS, BINS, AXES > | Recursively converts local axis bins from the standard kUnderflowBin /kOverflowBin for under/overflow bin indexing convention, to a "virtual bin" convention where the underflow bin has index 0 and the overflow bin has index N+1 where N is the axis' number of regular bins |
CROOT::Experimental::Internal::RLocalBinsToVirtualBins<-1, NDIMS, BINS, AXES > | |
CROOT::RError::RLocation | |
►CROOT::RLogDiagCount | Keep track of emitted errors and warnings |
►CROOT::RLogChannel | A log configuration for a channel, e.g |
CROOT::RLogManager | A RLogHandler that multiplexes diagnostics to different client RLogHandler s and keeps track of the sum of RLogDiagCount s for all channels |
CROOT::RLogEntry | A diagnostic that can be emitted by the RLogManager |
►CROOT::RLogHandler | Abstract RLogHandler base class |
CROOT::Experimental::REveManager::Logger::Handler | |
CROOT::RLogManager | A RLogHandler that multiplexes diagnostics to different client RLogHandler s and keeps track of the sum of RLogDiagCount s for all channels |
CROOT::RLogLocation | A diagnostic location, part of an RLogEntry |
CROOT::RLogScopedDiagCount | Object to count the number of warnings and errors emitted by a section of code, after construction of this type |
CROOT::RLogScopedVerbosity | Change the verbosity level (global or specific to the RLogChannel passed to the constructor) for the lifetime of this object |
CROOT::Experimental::Detail::RMenuArgument | Argument description for menu item which should invoke class method |
►CROOT::Experimental::Detail::RMenuItem | Base class for menu items, shown on JS side |
CROOT::Experimental::Detail::RArgsMenuItem | Menu item which requires extra arguments for invoked class method |
CROOT::Experimental::Detail::RCheckedMenuItem | Menu item with check box |
►CROOT::Detail::RDF::RMergeableValueBase | Base class of RMergeableValue |
►CROOT::Detail::RDF::RMergeableValue< ULong64_t > | |
CROOT::Detail::RDF::RMergeableCount | Specialization of RMergeableValue for the Count action |
►CROOT::Detail::RDF::RMergeableValue< Double_t > | |
CROOT::Detail::RDF::RMergeableMean | Specialization of RMergeableValue for the Mean action |
CROOT::Detail::RDF::RMergeableStdDev | Specialization of RMergeableValue for the StdDev action |
►CROOT::Detail::RDF::RMergeableValue< T > | A result of an RDataFrame execution, that knows how to merge with other results of the same type |
CROOT::Detail::RDF::RMergeableFill< T > | Specialization of RMergeableValue for histograms and statistics |
CROOT::Detail::RDF::RMergeableMax< T > | |
CROOT::Detail::RDF::RMergeableMin< T > | |
CROOT::Detail::RDF::RMergeableSum< T > | |
►CROOT::Detail::RDF::RMergeableVariationsBase | A container for variation names and variation results |
CROOT::Detail::RDF::RMergeableVariations< T > | A container for variation names and variation results that knows how to merge with others of the same type |
CROOT::RDF::Experimental::RMetaData | Class behaving as a heterogenuous dictionary to store the metadata of a dataset |
CROOT::Internal::RDF::RMetaDataJson | |
CROOT::Experimental::RFitPanelModel::RMethodInfo | |
CROOT::Experimental::Internal::RMiniFileReader | Read RNTuple data blocks from a TFile container, provided by a RRawFile |
CROOT::Experimental::RFitPanelModel::RMinimezerAlgorithm | Entry in minimizer algorithm combo |
►CTMVA::Experimental::SOFIE::RModel_Base | |
CTMVA::Experimental::SOFIE::RModel | |
►CTMVA::Experimental::SOFIE::RModel_GNNBase | |
CTMVA::Experimental::SOFIE::RModel_GNN | |
CTMVA::Experimental::SOFIE::RModel_GraphIndependent | |
CTMVA::Experimental::SOFIE::RModelParser_ONNX | |
CROOT::Internal::RDF::RNewSampleFlag | |
CROOT::Internal::RDF::RNewSampleNotifier | |
Crng_state_st | |
CROOT::Internal::TreeUtils::RNoCleanupNotifierHelper | |
►CROOT::Detail::RDF::RNodeBase | Base class for non-leaf nodes of the computational graph |
►CROOT::Detail::RDF::RFilterBase | |
CROOT::Detail::RDF::RFilter< FilterF, PrevNodeRaw > | |
CROOT::Detail::RDF::RFilterWithMissingValues< PrevNodeRaw > | Implementation of FilterAvailable and FilterMissing operations |
CROOT::Detail::RDF::RJittedFilter | A wrapper around a concrete RFilter, which forwards all calls to it RJittedFilter is the type of the node returned by jitted Filter calls: the concrete filter can be created and set at a later time, from jitted code |
CROOT::Detail::RDF::RLoopManager | The head node of a RDF computation graph |
►CROOT::Detail::RDF::RRangeBase | |
CROOT::Detail::RDF::RRange< PrevNodeRaw > | |
CROOT::RNTuple | Representation of an RNTuple data set in a ROOT file |
CROOT::RNTupleCardinality< SizeT > | Helper types to present an offset column as array of collection sizes |
CROOT::Experimental::RNTupleClusterRange | Used to loop over entries of collections in a single cluster |
CROOT::Experimental::RNTupleCollectionView | A view for a collection, that can itself generate new ntuple views for its nested fields |
CROOT::Experimental::Internal::RNTupleCompressor | Helper class to compress data blocks in the ROOT compression frame format |
CROOT::Experimental::Internal::RNTupleDecompressor | Helper class to uncompress data blocks in the ROOT compression frame format |
CROOT::Experimental::RNTupleDescriptor | The on-storage meta-data of an ntuple |
CROOT::Experimental::Internal::RNTupleDescriptorBuilder | A helper class for piece-wise construction of an RNTupleDescriptor |
CROOT::Experimental::RNTupleDirectAccessView< T > | A view variant that provides direct access to the I/O buffers |
CROOT::Experimental::Internal::RNTupleExporter | |
CROOT::Experimental::Internal::RNTupleFileWriter | Write RNTuple data blocks in a TFile or a bare file container |
CROOT::Experimental::RNTupleFillContext | A context for filling entries (data) into clusters of an RNTuple |
CROOT::Experimental::RNTupleFillStatus | A status object after filling an entry |
CROOT::Experimental::RNTupleFormatter | Contains helper functions for RNTupleReader::PrintInfo() and RPrintSchemaVisitor::VisitField() |
CROOT::Experimental::RNTupleGlobalRange | Used to loop over indexes (entries or collections) between start and end |
CROOT::Experimental::RNTupleImporter | Converts a TTree into an RNTuple |
CROOT::Experimental::RNTupleInspector | Inspect on-disk and storage-related information of an RNTuple |
CROOT::Experimental::Internal::RNTupleJoinTable | Builds a join table on one or several fields of an RNTuple so it can be joined onto other RNTuples |
CROOT::RNTupleLocalIndex | Addresses a column element or field item relative to a particular cluster, instead of a global NTupleSize_t index |
CROOT::RNTupleLocator | Generic information about the physical location of data |
CROOT::RNTupleLocatorObject64 | RNTupleLocator payload that is common for object stores using 64bit location information |
CROOT::Experimental::Internal::RNTupleMergeData | |
CROOT::Experimental::Internal::RNTupleMergeOptions | Set of merging options to pass to RNTupleMerger |
CROOT::Experimental::Internal::RNTupleMerger | Given a set of RPageSources merge them into an RPagePersistentSink, optionally changing their compression |
CROOT::Experimental::Detail::RNTupleMetrics | A collection of Counter objects with a name, a unit, and a description |
CROOT::Experimental::RNTupleModel | The RNTupleModel encapulates the schema of an ntuple |
CROOT::Experimental::Internal::RNTupleModelChangeset | The incremental changes to a RNTupleModel |
CROOT::Experimental::RNTupleOpenSpec | Used to specify the underlying RNTuples in RNTupleProcessor |
CROOT::Experimental::RNTupleParallelWriter | A writer to fill an RNTuple from multiple contexts |
►CROOT::Experimental::Detail::RNTuplePerfCounter | A performance counter with a name and a unit, which can be activated on demand |
►CROOT::Experimental::Detail::RNTupleAtomicCounter | A thread-safe integral performance counter |
CROOT::Experimental::Detail::RNTupleTickCounter< ROOT::Experimental::Detail::RNTupleAtomicCounter > | |
CROOT::Experimental::Detail::RNTupleCalcPerf | A metric element that computes its floating point value from other counters |
►CROOT::Experimental::Detail::RNTuplePlainCounter | A non thread-safe integral performance counter |
CROOT::Experimental::Detail::RNTupleTickCounter< ROOT::Experimental::Detail::RNTuplePlainCounter > | |
►CROOT::Experimental::RNTupleProcessor | Interface for iterating over entries of RNTuples and vertically concatenated RNTuples (chains) |
CROOT::Experimental::RNTupleChainProcessor | Processor specializiation for vertically concatenated RNTuples (chains) |
CROOT::Experimental::RNTupleJoinProcessor | Processor specializiation for horizontally concatenated RNTuples (joins) |
CROOT::Experimental::RNTupleSingleProcessor | Processor specializiation for processing a single RNTuple |
CROOT::Experimental::RNTupleReader | An RNTuple that is used to read data from storage |
CROOT::Experimental::RNTupleReadOptions | Common user-tunable settings for reading ntuples |
CROOT::Experimental::Internal::RNTupleReadOptionsManip | |
CROOT::Experimental::Internal::RNTupleSerializer | A helper class for serializing and deserialization of the RNTuple binary format |
CROOT::Experimental::Detail::RNTupleTimer< WallTimeT, CpuTimeT > | Record wall time and CPU time between construction and destruction |
►CROOT::Experimental::RNTupleViewBase< T > | An RNTupleView provides read-only access to a single field of the ntuple |
CROOT::Experimental::RNTupleView< T > | An RNTupleView for a known type |
►CROOT::Experimental::RNTupleViewBase< void > | |
CROOT::Experimental::RNTupleView< void > | |
►CROOT::Experimental::RNTupleWriteOptions | Common user-tunable settings for storing ntuples |
CROOT::Experimental::RNTupleWriteOptionsDaos | DAOS-specific user-tunable settings for storing ntuples |
CROOT::Experimental::Internal::RNTupleWriteOptionsManip | |
CROOT::Experimental::RNTupleWriter | An RNTuple that gets filled with entries (data) and writes them to storage |
CTMVA::ROCCalc | |
CTMVA::ROCCurve | |
CROOT::Experimental::Internal::RDaosContainer::ROidDkeyPair | A pair of <object ID, distribution key> that can be used to issue a fetch/update request for multiple attribute keys |
CROOT::Experimental::Internal::ROnDiskPage | A page as being stored on disk, that is packed and compressed |
►CROOT::Experimental::Internal::ROnDiskPageMap | A memory region that contains packed and compressed pages |
CROOT::Experimental::Internal::ROnDiskPageMapHeap | An ROnDiskPageMap that is used for an fMemory allocated as an array of unsigned char |
CROOT::Internal::RDF::ROneTimeCallback | |
CRooAbsCollection::RooAbsArgPtrOrDouble | |
►CRooAbsCache | Abstract base class for data members of RooAbsArgs that cache other (composite) RooAbsArg expressions |
►CRooCacheManager< RooAbsCacheElement > | |
CRooObjCacheManager | Implementation of a RooCacheManager<RooAbsCacheElement> that specializes in the storage of cache elements that contain RooAbsArg objects |
CRooCacheManager< T > | Manages the storage of any type of data indexed on the choice of normalization and optionally the set of integrated observables |
CRooMappedCategoryCache | |
►CRooAbsCacheElement | Abstract base class for objects to be stored in RooAbsCache cache manager objects |
CAddCacheElem | |
CParamHistFunc::CacheElem | |
CPiecewiseInterpolation::CacheElem | |
CRooAbsAnaConvPdf::CacheElem | |
►CRooAbsCachedPdf::PdfCacheElem | |
CRooFFTConvPdf::FFTCacheElem | |
CRooIntegralMorph::MorphCacheElem | |
►CRooAbsCachedReal::FuncCacheElem | |
CRooNumRunningInt::RICacheElem | |
CRooAbsPdf::CacheElem | Normalization set with for above integral |
CRooAddModel::IntCacheElem | |
CRooAddition::CacheElem | |
CRooJeffreysPrior::CacheElem | |
CRooLagrangianMorphFunc::CacheElem | |
CRooMomentMorph::CacheElem | |
CRooMomentMorphFunc::CacheElem | |
CRooMomentMorphFuncND::CacheElem | |
CRooProdPdf::CacheElem | |
CRooProduct::CacheElem | |
CRooProjectedPdf::CacheElem | |
CRooRealSumPdf::CacheElem | |
CRooSimultaneous::CacheElem | |
►CRooFit::Detail::RooAbsDataFiller | |
CRooAbsDataHelper< DataSet_t > | This is a helper for an RDataFrame action, which fills RooFit data classes |
►CRooAbsFunc | Abstract interface for evaluating a real-valued function of one real variable and performing numerical algorithms on it |
CRooConvIntegrandBinding | Implementation of RooAbsFunc that represent the integrand of a generic (numeric) convolution A (x) B so that it can be passed to a numeric integrator |
CRooHistError::BinomialSumAsym | |
CRooHistError::BinomialSumEff | |
CRooHistError::PoissonSum | |
CRooInvTransform | Lightweight function binding that returns the inverse of an input function binding |
►CRooRealBinding | Lightweight interface adaptor that binds a RooAbsReal object to a subset of its servers and present it as a simple array oriented interface |
CRooDataProjBinding | Adaptor that projects a real function via summation of states provided in a dataset |
►CRooAbsIntegrator | Abstract interface for integrators of real-valued functions that implement the RooAbsFunc interface |
CRooAdaptiveGaussKronrodIntegrator1D | Implements the Gauss-Kronrod integration algorithm |
CRooAdaptiveIntegratorND | Adaptive one-dimensional numerical integration algorithm |
CRooBinIntegrator | Computes the integral over a binned distribution by summing the bin contents of all bins |
CRooGaussKronrodIntegrator1D | Implements the Gauss-Kronrod integration algorithm |
CRooImproperIntegrator1D | Special numeric integrator that can handle integrals over open domains |
CRooMCIntegrator | Implements an adaptive multi-dimensional Monte Carlo numerical integration, following the VEGAS algorithm originally described in G |
CRooRombergIntegrator | Adaptive numerical integration algorithm |
►CRooFit::TestStatistics::RooAbsL | |
CRooFit::TestStatistics::RooBinnedL | |
CRooFit::TestStatistics::RooSubsidiaryL | |
CRooFit::TestStatistics::RooSumL | Likelihood class that sums over multiple -log components |
CRooFit::TestStatistics::RooUnbinnedL | |
►CRooAbsLValue | Abstract base class for objects that are lvalues, i.e |
►CRooAbsCategoryLValue | Abstract base class for objects that represent a discrete value that can be set from the outside, i.e |
CRooCategory | Object to represent discrete states |
CRooSuperCategory | Joins several RooAbsCategoryLValue objects into a single category |
►CRooAbsRealLValue | Abstract base class for objects that represent a real value that may appear on the left hand side of an equation ('lvalue') |
CRooErrorVar | Auxiliary class that represents the error of a RooRealVar as a separate object |
CRooLinearVar | RooLinearVar is the most general form of a derived real-valued object that can be used by RooRealIntegral to integrate over |
CRooRealVar | Variable that can be changed from the outside |
►CRooAbsMinimizerFcn | |
CRooFit::TestStatistics::MinuitFcnGrad | Minuit-RooMinimizer interface which synchronizes parameter data and coordinates evaluation of likelihood (gradient) values |
CRooMinimizerFcn | RooMinimizerFcn is an interface to the ROOT::Math::IBaseFunctionMultiDim, a function that ROOT's minimisers use to carry out minimisations |
►CRooAbsNumGenerator | Abstract base class for MC event generator implementations like RooAcceptReject and RooFoam |
CRooAcceptReject | Generic Monte Carlo toy generator implement the accept/reject sampling technique on any positively valued function |
CRooFoamGenerator | Generic Monte Carlo toy generator that implement the TFOAM sampling technique on any positively valued function |
►CRooAbsProxy | Abstract interface for proxy classes |
CRooCollectionProxy< RooArgList > | |
CRooCollectionProxy< RooArgSet > | |
►CRooArgProxy | Abstract interface for RooAbsArg proxy classes |
CRooTemplateProxy< RooAbsReal > | |
CRooTemplateProxy< RooAbsCategory > | |
CRooTemplateProxy< RooAbsRealLValue > | |
CRooTemplateProxy< RooAbsPdf > | |
CRooTemplateProxy< const RooHistFunc > | |
CRooTemplateProxy< RooRealVar > | |
CRooTemplateProxy< RooMultiCategory > | |
CRooTemplateProxy< T > | |
CRooCollectionProxy< RooCollection_t > | Concrete proxy for RooArgSet or RooArgList objects |
CRooAddHelpers | |
CRooAICRegistry | Utility class for operator p.d.f classes that keeps track of analytical integration codes and associated normalization and integration sets |
►CRooBatchCompute::RooBatchComputeInterface | The interface which should be implemented to provide optimised computation functions for implementations of RooAbsReal::doEval() |
CRooBatchCompute::CUDA::RooBatchComputeClass | This class overrides some RooBatchComputeInterface functions, for the purpose of providing a cuda specific implementation of the library |
CRooBatchCompute::CUDA::RooBatchComputeClass | This class overrides some RooBatchComputeInterface functions, for the purpose of providing a cuda specific implementation of the library |
CRooBinnedL | Implements a -log(likelihood) calculation from a dataset (assumed to be binned) and a PDF |
CRooBlindTools | |
CRooBrentRootFinder | Implement the abstract 1-dimensional root finding interface using the Brent-Decker method |
CRooCFunction1Map< VO, VI > | |
CRooCFunction2Map< VO, VI1, VI2 > | |
CRooCFunction3Map< VO, VI1, VI2, VI3 > | |
CRooCFunction4Map< VO, VI1, VI2, VI3, VI4 > | |
CRooClassFactory | Similar to TTree::MakeClass(), generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names |
►CRooCollection_t | |
CRooCollectionProxy< RooCollection_t > | Concrete proxy for RooArgSet or RooArgList objects |
CRooCustomizer | RooCustomizer is a factory class to produce clones of a prototype composite PDF object with the same structure but different leaf servers (parameters or dependents) |
►CRooDirItem | Utility base class for RooFit objects that are to be attached to ROOT directories |
CRooDataHist | Container class to hold N-dimensional binned data |
CRooDataSet | Container class to hold unbinned data |
CRooFitResult | RooFitResult is a container class to hold the input and output of a PDF fit to a dataset |
CRooErrorHandler | |
CRooFIter | A one-time forward iterator working on RooLinkedList or RooAbsCollection |
CRooFitMoreLib | |
CRooFunctor | Lightweight interface adaptor that exports a RooAbsPdf as a functor |
CRooGlobalFunc | |
CRooHistError | Singleton class used to calculate the error bars for each bin of a RooHist object |
CRooJSONFactoryWSTool | When using RooFit, statistical models can be conveniently handled and stored as a RooWorkspace |
CRooLinkedListElem | Link element for the RooLinkedList class |
CRooMath | |
CRooMathCoreReg | |
CRooMathMoreReg | |
CRooMPSentinel | |
CRooNaNPacker | Little struct that can pack a float into the unused bits of the mantissa of a NaN double |
CRooNormalizedPdf | A RooNormalizedPdf wraps a pdf divided by its integral for a given normalization set into a new self-normalized pdf |
CRooNormSetCache | Class RooNormSet cache manage the bookkeeping of multiple instances of sets of integration and normalization observables that effectively have the same definition |
CRooNumber | Provides numeric constants used in RooFit |
►CRooPrintable | A 'mix-in' base class that define the standard RooFit plotting and printing methods |
►CRooAbsArg | Common abstract base class for objects that represent a value and a "shape" in RooFit |
►CRooAbsCategory | A space to attach TBranches |
CRooAbsCategoryLValue | Abstract base class for objects that represent a discrete value that can be set from the outside, i.e |
CRooBinningCategory | Provides a real-to-category mapping defined by a series of thresholds |
CRooMappedCategory | RooMappedCategory provides a category-to-category mapping defined by pattern matching on their state labels |
CRooMultiCategory | Connects several RooAbsCategory objects into a single category |
CRooThresholdCategory | A real-to-category mapping defined by a series of thresholds |
►CRooAbsReal | Abstract base class for objects that represent a real value and implements functionality common to all real-valued objects such as the ability to plot them, to construct integrals of them, the ability to advertise (partial) analytical integrals etc |
CParamHistFunc | A class which maps the current values of a RooRealVar (or a set of RooRealVars) to one of a number of RooAbsReal (nominally RooRealVar): |
CPiecewiseInterpolation | The PiecewiseInterpolation is a class that can morph distributions into each other, which is useful to estimate systematic uncertainties |
CProgressMonitor | |
►CRooAbsCachedReal | Abstract base class for functions that need or want to cache their evaluate() output in a RooHistFunc defined in terms of the used observables |
CRooCachedReal | Implementation of RooAbsCachedReal that can cache any external RooAbsReal input function provided in the constructor |
►CRooNumRunningInt | Implementation of RooAbsCachedReal that represents a running integral |
CRooNumCdf | Implementation of RooNumRunningInt that calculates cumulative distribution functions from p.d.f.s |
►CRooAbsHiddenReal | Base class for objects that want to hide their return value from interactive use, e.g |
CRooUnblindCPAsymVar | Implementation of BlindTools' CP asymmetry blinding method A RooUnblindCPAsymVar object is a real valued function object, constructed from a blind value holder and a set of unblinding parameters |
CRooUnblindOffset | Implementation of BlindTools' offset blinding method A RooUnblindOffset object is a real valued function object, constructed from a blind value holder and a set of unblinding parameters |
CRooUnblindPrecision | Implementation of BlindTools' precision blinding method A RooUnblindPrecision object is a real valued function object, constructed from a blind value holder and a set of unblinding parameters |
CRooUnblindUniform | Implementation of BlindTools' offset blinding method |
►CRooAbsMoment | |
CRooFirstMoment | |
CRooMoment | |
CRooSecondMoment | |
►CRooAbsPdf | Abstract interface for all probability density functions |
CPdfWrapper | |
CRoo2DKeysPdf | Two-dimensional kernel estimation PDF |
►CRooAbsAnaConvPdf | Base class for PDFs that represent a physics model that can be analytically convolved with a resolution model |
CRooBCPEffDecay | PDF describing decay time distribution of B meson including effects of standard model CP violation |
CRooBCPGenDecay | Implement standard CP physics model with S and C (no mention of lambda) Suitably stolen and modified from RooBCPEffDecay |
CRooBDecay | Most general description of B decay time distribution with effects of CP violation, mixing and life time differences |
CRooBMixDecay | Class RooBMixDecay is a RooAbsAnaConvPdf implementation that describes the decay of B mesons with the effects of B0/B0bar mixing |
CRooDecay | Single or double sided decay function that can be analytically convolved with any RooResolutionModel implementation |
CRooNonCPEigenDecay | Time-dependent RooAbsAnaConvPdf for CP violating decays to Non-CP eigenstates (eg, ) |
►CRooAbsCachedPdf | 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 |
CRooCachedPdf | Implementation of RooAbsCachedPdf that can cache any external RooAbsPdf input function provided in the constructor |
CRooFFTConvPdf | PDF for the numerical (FFT) convolution of two PDFs |
CRooIntegralMorph | Class RooIntegralMorph is an implementation of the histogram interpolation technique described by Alex Read in 'NIM A 425 (1999) 357-369 'Linear interpolation of histograms' for continuous functions rather than histograms |
CRooAddPdf | Efficient implementation of a sum of PDFs of the form |
CRooArgusBG | RooArgusBG is a RooAbsPdf implementation describing the ARGUS background shape |
CRooBernstein | Bernstein basis polynomials are positive-definite in the range [0,1] |
CRooBifurGauss | Bifurcated Gaussian p.d.f with different widths on left and right side of maximum value |
CRooBinSamplingPdf | The RooBinSamplingPdf is supposed to be used as an adapter between a continuous PDF and a binned distribution |
CRooBreitWigner | Class RooBreitWigner is a RooAbsPdf implementation that models a non-relativistic Breit-Wigner shape |
CRooBukinPdf | The RooBukinPdf implements the NovosibirskA function |
CRooCBShape | PDF implementing the Crystal Ball line shape |
CRooCFunction1PdfBinding< VO, VI > | |
CRooCFunction2PdfBinding< VO, VI1, VI2 > | |
CRooCFunction3PdfBinding< VO, VI1, VI2, VI3 > | |
CRooCFunction4PdfBinding< VO, VI1, VI2, VI3, VI4 > | |
CRooChebychev | Chebychev polynomial p.d.f |
CRooChiSquarePdf | The PDF of the Chi Square distribution for n degrees of freedom |
CRooCrystalBall | PDF implementing the generalized Asymmetrical Double-Sided Crystall Ball line shape |
CRooDstD0BG | Special p.d.f shape that can be used to model the background of D*-D0 mass difference distributions |
CRooEffProd | The class RooEffProd implements the product of a PDF with an efficiency function |
CRooEfficiency | A PDF helper class to fit efficiencies parameterized by a supplied function F |
CRooExponential | Exponential PDF |
CRooExtendPdf | RooExtendPdf is a wrapper around an existing PDF that adds a parameteric extended likelihood term to the PDF, optionally divided by a fractional term from a partial normalization of the PDF: |
CRooExtendedTerm | 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 |
CRooFit::Detail::RooFixedProdPdf | A RooProdPdf with a fixed normalization set can be replaced by this class |
CRooFit::Detail::RooNormalizedPdf | |
CRooFunctor1DPdfBinding | |
CRooFunctorPdfBinding | RooFunctorPdfBinding makes math functions from ROOT usable as PDFs in RooFit |
CRooGamma | Implementation of the Gamma PDF for RooFit/RooStats |
CRooGaussian | Plain Gaussian p.d.f |
CRooGenericPdf | Implementation of a probability density function that takes a RooArgList of servers and a C++ expression string defining how its value should be calculated from the given list of servers |
CRooHistConstraint | The RooHistConstraint implements constraint terms for a binned PDF with statistical uncertainties |
CRooHistPdf | A propability density function sampled from a multidimensional histogram |
CRooHypatia2 | RooHypatia2 is the two-sided version of the Hypatia distribution described in https://arxiv.org/abs/1312.5000 |
CRooJeffreysPrior | Implementation of Jeffrey's prior |
CRooJohnson | Johnson's distribution |
CRooKeysPdf | Class RooKeysPdf implements a one-dimensional kernel estimation p.d.f which model the distribution of an arbitrary input dataset as a superposition of Gaussian kernels, one for each data point, each contributing 1/N to the total integral of the pdf |
CRooLandau | Landau distribution p.d.f |
CRooLegacyExpPoly | RooLegacyExpPoly implements a polynomial PDF of the form |
CRooLognormal | RooFit Lognormal PDF |
CRooMomentMorph | |
CRooMultiVarGaussian | Multivariate Gaussian p.d.f |
CRooNDKeysPdf | Generic N-dimensional implementation of a kernel estimation p.d.f |
CRooNonCentralChiSquare | The PDF of the Non-Central Chi Square distribution for n degrees of freedom |
CRooNovosibirsk | RooNovosibirsk implements the Novosibirsk function |
CRooNumConvPdf | Numeric 1-dimensional convolution operator PDF |
CRooParametricStepFunction | The Parametric Step Function PDF is a binned distribution whose parameters are the heights of each bin |
CRooPoisson | Poisson pdf |
CRooPolynomial | RooPolynomial implements a polynomial p.d.f of the form |
CRooPowerSum | RooPowerSum implements a power law PDF of the form |
CRooProdPdf | Efficient implementation of a product of PDFs of the form |
►CRooProjectedPdf | A RooAbsPdf implementation that represent a projection of a given input p.d.f and the object returned by RooAbsPdf::createProjection |
CxRooProjectedPdf | |
CRooRealSumPdf | Implements a PDF constructed from a sum of functions: |
►CRooResolutionModel | RooResolutionModel is the base class for PDFs that represent a resolution model that can be convoluted with a physics model of the form |
CRooAddModel | RooAddModel is an efficient implementation of a sum of PDFs of the form |
CRooGExpModel | The RooGExpModel is a RooResolutionModel implementation that models a resolution function that is the convolution of a Gaussian with a one-sided exponential |
CRooGaussModel | Class RooGaussModel implements a RooResolutionModel that models a Gaussian distribution |
CRooTruthModel | Implements a RooResolution model that corresponds to a delta function |
CRooSimultaneous | Facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset |
CRooTFnPdfBinding | |
CRooUniform | Flat p.d.f |
CRooVoigtian | RooVoigtian is an efficient implementation of the convolution of a Breit-Wigner with a Gaussian, making use of the complex error function |
CRooWrapperPdf | The RooWrapperPdf is a class that can be used to convert a function into a PDF |
CRooAbsRealLValue | Abstract base class for objects that represent a real value that may appear on the left hand side of an equation ('lvalue') |
►CRooAbsTestStatistic | Abstract base class for all test statistics |
►CRooAbsOptTestStatistic | Abstract base class for test statistics objects that evaluate a function or PDF at each point of a given dataset |
CRooChi2Var | Simple calculation from a binned dataset and a PDF |
CRooNLLVar | Implements a -log(likelihood) calculation from a dataset and a PDF |
CRooXYChi2Var | RooXYChi2Var implements a simple chi^2 calculation from an unbinned dataset with values x,y with errors on y (and optionally on x) and a function |
CRooAddition | 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 |
CRooBinWidthFunction | Returns the bin width (or volume) given a RooHistFunc |
CRooCFunction1Binding< VO, VI > | RooCFunction1Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions |
CRooCFunction2Binding< VO, VI1, VI2 > | RooCFunction2Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions |
CRooCFunction3Binding< VO, VI1, VI2, VI3 > | RooCFunction3Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions |
CRooCFunction4Binding< VO, VI1, VI2, VI3, VI4 > | RooCFunction4Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions |
CRooChangeTracker | Meta object that tracks value changes in a given set of RooAbsArgs by registering itself as value client of these objects |
CRooConstVar | Represents a constant real-valued object |
CRooConstraintSum | Calculates the sum of the -(log) likelihoods of a set of RooAbsPfs that represent constraint functions |
CRooConvCoefVar | Auxiliary class that represents the coefficient of a RooAbsAnaConvPdf implementation as a separate RooAbsReal object to be able to interface these coefficient terms with the generic RooRealIntegral integration mechanism |
CRooDerivative | Represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class |
CRooExtendedBinding | |
CRooFit::Experimental::RooFuncWrapper | A wrapper class to store a C++ function of type 'double (*)(double*, double*)' |
CRooFit::TestStatistics::RooRealL | RooAbsReal that wraps RooAbsL likelihoods for use in RooFit outside of the RooMinimizer context |
CRooFormulaVar | A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of servers and a C++ expression string defining how its value should be calculated from the given list of servers |
CRooFracRemainder | Calculates the remainder fraction of a sum of RooAbsReal fraction, i.e (1 - sum_i a_i) |
CRooFunctor1DBinding | RooCFunction1Binding is a templated implementation of class RooAbsReal that binds generic C(++) functions to a RooAbsReal argument thus allowing generic C++ functions to be used as RooFit functions |
CRooFunctorBinding | RooFunctorBinding makes math functions from ROOT usable in RooFit |
CRooGenProdProj | General form of projected integral of product of PDFs, utility class for RooProdPdf |
CRooHistFunc | A real-valued function sampled from a multidimensional histogram |
CRooLagrangianMorphFunc | Class RooLagrangianMorphing is a implementation of the method of Effective Lagrangian Morphing, described in ATL-PHYS-PUB-2015-047 |
►CLegendre polynomials using ROOT::Math::assoc_legendre() |
CRooSpHarmonic | Implementation of the so-called real spherical harmonics, using the orthonormal normalization, which are related to spherical harmonics as: |
CRooLinearCombination | RooLinearCombination is a class that helps perform linear combination of floating point numbers and permits handling them as multiprecision |
CRooMomentMorphFunc | |
CRooMomentMorphFuncND | |
CRooMultiBinomial | RooMultiBinomial is an efficiency function which makes all combinations of efficiencies given as input different efficiency functions for different categories |
CRooNumConvolution | Numeric 1-dimensional convolution operator PDF |
CRooParamHistFunc | A histogram function that assigns scale parameters to every bin |
CRooPolyFunc | RooPolyFunc implements a polynomial function in multi-variables |
CRooPolyVar | A RooAbsReal implementing a polynomial in terms of a list of RooAbsReal coefficients |
CRooProduct | Represents the product of a given set of RooAbsReal objects |
CRooProfileLL | Implements the profile likelihood estimator for a given likelihood and set of parameters of interest |
CRooPullVar | Represents the pull of a measurement w.r.t |
CRooRangeBoolean | Returns 1.0 if variable is within given a range and 0.0 otherwise |
CRooRatio | Represents the ratio of two RooAbsReal objects |
CRooRealIntegral | Performs hybrid numerical/analytical integrals of RooAbsReal objects |
CRooRealMPFE | Multi-processor front-end for parallel calculation of RooAbsReal objects |
CRooRealSumFunc | |
CRooRecursiveFraction | 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 , it returns |
CRooSpline | A RooFit class for creating spline functions |
CRooStats::Heaviside | Represents the Heaviside function |
CRooStats::HistFactory::FlexibleInterpVar | |
CRooStats::HistFactory::LinInterpVar | RooAbsReal that does piecewise-linear interpolations |
CRooStats::HistFactory::RooBarlowBeestonLL | Class RooBarlowBeestonLL implements the profile likelihood estimator for a given likelihood and set of parameters of interest |
CRooStepFunction | The Step Function is a binned function whose parameters are the heights of each bin |
CRooTFnBinding | Use TF1, TF2, TF3 functions as RooFit objects |
CRooStringVar | A RooAbsArg implementing string values |
►CRooAbsBinning | Abstract base class for RooRealVar binning definitions |
CRooBinning | Implements a RooAbsBinning in terms of an array of boundary values, posing no constraints on the choice of binning, thus allowing variable bin sizes |
CRooLinTransBinning | Special binning implementation for RooLinearVar that transforms the binning of the RooLinearVar input variable in the same way that RooLinearVar does |
CRooParamBinning | Implementation of RooAbsBinning that constructs a binning with a range definition that depends on external RooAbsReal objects |
CRooRangeBinning | Binning/range definition that only defines a range but no binning |
CRooUniformBinning | Implementation of RooAbsBinning that provides a uniform binning in 'n' bins between the range end points |
►CRooAbsCollection | Abstract container object that can hold multiple RooAbsArg objects |
►CRooArgList | RooArgList is a container object that can hold multiple RooAbsArg objects |
CRooCollectionProxy< RooArgList > | |
►CRooArgSet | RooArgSet is a container object that can hold multiple RooAbsArg objects |
CRooCollectionProxy< RooArgSet > | |
►CRooAbsData | Abstract base class for binned and unbinned datasets |
CRooDataHist | Container class to hold N-dimensional binned data |
CRooDataSet | Container class to hold unbinned data |
CRooTreeData | |
►CRooAbsDataStore | Abstract base class for a data collection |
CRooCompositeDataStore | Combines several disjunct datasets into one |
CRooTreeDataStore | TTree-backed data storage |
CRooVectorDataStore | Uses std::vector to store data columns |
►CRooAbsGenContext | Abstract base class for generator contexts of RooAbsPdf objects |
CRooAddGenContext | Efficient implementation of the generator context specific for RooAddPdf PDFs |
CRooBinnedGenContext | Efficient implementation of the generator context specific for binned pdfs |
CRooConvGenContext | Efficient implementation of the generator context specific for RooAbsAnaConvPdf objects |
CRooEffGenContext | Specialized generator context for p.d.fs represented by class RooEffProd, which are p.d.fs multiplied with an efficiency function |
CRooGenContext | Implements a universal generator context for all RooAbsPdf classes that do not have or need a specialized generator context |
CRooProdGenContext | Efficient implementation of the generator context specific for RooProdPdf PDFs |
CRooSimGenContext | Efficient implementation of the generator context specific for RooSimultaneous PDFs when generating more than one of the component pdfs |
CRooSimSplitGenContext | Efficient implementation of the generator context specific for RooSimultaneous PDFs when generating more than one of the component pdfs |
CRooCatType | RooCatType is an auxiliary class for RooAbsCategory and defines a a single category state |
CRooFactoryWSTool | Implementation detail of the RooWorkspace |
CRooFitResult | RooFitResult is a container class to hold the input and output of a PDF fit to a dataset |
CRooFormula | Internally uses ROOT's TFormula to compute user-defined expressions of RooAbsArgs |
CRooNumGenConfig | Holds the configuration parameters of the various numeric integrators used by RooRealIntegral |
CRooNumIntConfig | Holds the configuration parameters of the various numeric integrators used by RooRealIntegral |
CRooPlot | Plot frame and a container for graphics objects within that frame |
►CRooPlotable | Class RooPotable is a base class for objects that can be inserted into RooPlots and take advantage of its internal normalization and axis range adjustment features |
CRooCurve | One-dimensional graphical representation of a real-valued function |
CRooEllipse | Two-dimensional ellipse that can be used to represent an error contour |
CRooHist | Graphical representation of binned data based on the TGraphAsymmErrors class |
CRooStats::LikelihoodIntervalPlot | This class provides simple and straightforward utilities to plot a LikelihoodInterval object |
CRooStats::MCMCIntervalPlot | This class provides simple and straightforward utilities to plot a MCMCInterval object |
►CRooStats::SamplingDistPlot | This class provides simple and straightforward utilities to plot SamplingDistribution objects |
CRooStats::HypoTestPlot | This class provides the plots for the result of a study performed with any of the HypoTestCalculatorGeneric (e.g |
►CRooTable | Abstract interface for table objects |
CRoo1DTable | One-dimensional table |
CRooPyBind | A RooFit class for wrapping python functions |
CRooQuasiRandomGenerator | This class generates the quasi-random (aka "low discrepancy") sequence for dimensions up to 12 using the Niederreiter base 2 algorithm described in Bratley, Fox, Niederreiter, ACM Trans |
CRooRandom | This class provides a static interface for generating random numbers |
CRooRealConstant | Provides static functions to create and keep track of RooRealVar constants |
CRooSimWSTool | The RooSimWSTool is a tool operating on RooWorkspace objects that can clone PDFs into a series of variations that are joined together into a RooSimultaneous PDF |
CRooStats::RooStatsConfig | |
CRooSTLRefCountList< T > | |
CRooSTLRefCountList< RooAbsArg > | |
CRooStreamParser | |
CRooStringView | The RooStringView is a wrapper around a C-style string that can also be constructed from a std::string or a TString |
CRooSubsidiaryL | Calculates the sum of the -(log) likelihoods of a set of RooAbsPdf objects that represent subsidiary or constraint functions |
CROOT::Internal::RDF::RootConversionTraits< T > | |
CROOT::Internal::RDF::RootConversionTraits< bool > | |
CROOT::Internal::RDF::RootConversionTraits< double > | |
CROOT::Internal::RDF::RootConversionTraits< float > | |
CROOT::Internal::RDF::RootConversionTraits< int16_t > | |
CROOT::Internal::RDF::RootConversionTraits< int32_t > | |
CROOT::Internal::RDF::RootConversionTraits< int8_t > | |
CROOT::Internal::RDF::RootConversionTraits< Long64_t > | |
CROOT::Internal::RDF::RootConversionTraits< uint16_t > | |
CROOT::Internal::RDF::RootConversionTraits< uint32_t > | |
CROOT::Internal::RDF::RootConversionTraits< uint8_t > | |
CROOT::Internal::RDF::RootConversionTraits< ULong64_t > | |
CROOT::Math::RootFinder | User Class to find the Root of one dimensional functions |
CRooTMathReg | |
CRooTrace | Controls the memory tracing hooks in all RooFit objects |
CRooUnbinnedL | A -log(likelihood) calculation from a dataset (assumed to be unbinned) and a PDF |
►CRooWorkspaceHandle | An interface to set and retrieve a workspace |
CRooStats::ModelConfig | ModelConfig is a simple class that holds configuration information specifying how a model should be used in the context of various RooStats tools |
►CTMVA::Experimental::SOFIE::ROperator | |
CTMVA::Experimental::SOFIE::ROperator_BasicBinary< T, Op > | |
CTMVA::Experimental::SOFIE::ROperator_BasicNary< T, Op > | |
CTMVA::Experimental::SOFIE::ROperator_BasicUnary< T, Op > | |
CTMVA::Experimental::SOFIE::ROperator_BatchNormalization< T > | |
CTMVA::Experimental::SOFIE::ROperator_Cast | |
CTMVA::Experimental::SOFIE::ROperator_Comparision< T, Op > | |
CTMVA::Experimental::SOFIE::ROperator_Concat | |
CTMVA::Experimental::SOFIE::ROperator_Constant< T > | |
CTMVA::Experimental::SOFIE::ROperator_Conv< T > | |
CTMVA::Experimental::SOFIE::ROperator_ConvTranspose< T > | Transposed Convolution operator |
CTMVA::Experimental::SOFIE::ROperator_Custom< T > | |
CTMVA::Experimental::SOFIE::ROperator_Einsum< T > | |
CTMVA::Experimental::SOFIE::ROperator_Elu< T > | |
CTMVA::Experimental::SOFIE::ROperator_Erf< T > | |
CTMVA::Experimental::SOFIE::ROperator_Expand< T > | |
CTMVA::Experimental::SOFIE::ROperator_EyeLike | |
CTMVA::Experimental::SOFIE::ROperator_GRU< T > | Gated Recurrent Unit operator |
CTMVA::Experimental::SOFIE::ROperator_Gather | |
CTMVA::Experimental::SOFIE::ROperator_Gemm< T > | |
CTMVA::Experimental::SOFIE::ROperator_Identity< T > | |
CTMVA::Experimental::SOFIE::ROperator_If | |
CTMVA::Experimental::SOFIE::ROperator_LSTM< T > | Long Short-Term Memory operator |
CTMVA::Experimental::SOFIE::ROperator_LayerNormalization< T > | |
CTMVA::Experimental::SOFIE::ROperator_LeakyRelu< T > | |
CTMVA::Experimental::SOFIE::ROperator_Pad< T > | |
CTMVA::Experimental::SOFIE::ROperator_Pool< T > | |
CTMVA::Experimental::SOFIE::ROperator_RNN< T > | Recurrent Neural Network operator |
CTMVA::Experimental::SOFIE::ROperator_Random | |
CTMVA::Experimental::SOFIE::ROperator_Range< T > | |
CTMVA::Experimental::SOFIE::ROperator_Reduce< T, Op > | |
CTMVA::Experimental::SOFIE::ROperator_Relu< T > | |
CTMVA::Experimental::SOFIE::ROperator_Reshape | |
CTMVA::Experimental::SOFIE::ROperator_Selu< T > | |
CTMVA::Experimental::SOFIE::ROperator_Shape | |
CTMVA::Experimental::SOFIE::ROperator_Sigmoid< T > | |
CTMVA::Experimental::SOFIE::ROperator_Slice< IType > | |
CTMVA::Experimental::SOFIE::ROperator_Softmax< T > | |
CTMVA::Experimental::SOFIE::ROperator_Split | |
CTMVA::Experimental::SOFIE::ROperator_Swish< T > | |
CTMVA::Experimental::SOFIE::ROperator_Tanh< T > | |
CTMVA::Experimental::SOFIE::ROperator_Tile< T > | |
CTMVA::Experimental::SOFIE::ROperator_TopK< T > | |
CTMVA::Experimental::SOFIE::ROperator_Transpose< T > | |
CTMVA::Experimental::SOFIE::ROperator_Where< T > | |
CROOT::Internal::RRawFile::ROptions | On construction, an ROptions parameter can customize the RRawFile behavior |
CROOT::RDF::RCsvDS::ROptions | Options that control how the CSV file is parsed |
CRotatedTextItemTemplate_t | |
CROOT::Math::Rotation3D | Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix |
CROOT::Math::RotationX | Rotation class representing a 3D rotation about the X axis by the angle of rotation |
CROOT::Math::RotationY | Rotation class representing a 3D rotation about the Y axis by the angle of rotation |
CROOT::Math::RotationZ | Rotation class representing a 3D rotation about the Z axis by the angle of rotation |
CROOT::Math::RotationZYX | Rotation class with the (3D) rotation represented by angles describing first a rotation of an angle phi (yaw) about the Z axis, followed by a rotation of an angle theta (pitch) about the Y axis, followed by a third rotation of an angle psi (roll) about the X axis |
CROOT::Math::RowOffsets< D > | Static structure to keep the conversion from (i,j) to offsets in the storage data for a symmetric matrix |
CROOT::Experimental::RPadExtent | An extent / size (horizontal and vertical) in a RPad |
CROOT::Experimental::RPadLength | A length in RPad |
CROOT::Experimental::RPadPos | A position (horizontal and vertical) in a RPad |
CROOT::Experimental::Internal::RPage | A page is a slice of a column that is mapped into memory |
►CROOT::Experimental::Internal::RPageAllocator | Abstract interface to allocate and release pages |
CROOT::Experimental::Internal::RPageAllocatorHeap | Uses standard C++ memory allocation for the column data pages |
►CROOT::Experimental::RClusterDescriptor::RPageRange::RPageInfo | We do not need to store the element size / uncompressed page size because we know to which column the page belongs |
CROOT::Experimental::RClusterDescriptor::RPageRange::RPageInfoExtended | |
CROOT::Experimental::Internal::RPagePool | A thread-safe cache of pages loaded from the page source |
CROOT::Experimental::Internal::RPagePool::RPagePosition | Used in fLookupByKey to store both the absolute and the cluster-local page index of the referenced page |
CROOT::Experimental::RClusterDescriptor::RPageRange | Records the partition of data into pages for a particular column in a particular cluster |
CROOT::Experimental::Internal::RPageRef | Reference to a page stored in the page pool |
CROOT::Experimental::Internal::RNTupleExporter::RPagesOptions | |
CROOT::Experimental::Internal::RNTupleExporter::RPagesResult | |
►CROOT::Experimental::Internal::RPageStorage | Common functionality of an ntuple storage for both reading and writing |
►CROOT::Experimental::Internal::RPageSink | Abstract interface to write data into an ntuple |
CROOT::Experimental::Internal::RPageNullSink | Dummy sink that discards all pages |
►CROOT::Experimental::Internal::RPagePersistentSink | Base class for a sink with a physical storage backend |
CROOT::Experimental::Internal::RPageSinkDaos | Storage provider that writes ntuple pages to into a DAOS container |
CROOT::Experimental::Internal::RPageSinkFile | Storage provider that write ntuple pages into a file |
CROOT::Experimental::Internal::RPageSinkBuf | Wrapper sink that coalesces cluster column page writes |
►CROOT::Experimental::Internal::RPageSource | Abstract interface to read data from an ntuple |
CROOT::Experimental::Internal::RPageSourceDaos | Storage provider that reads ntuple pages from a DAOS container |
CROOT::Experimental::Internal::RPageSourceFile | Storage provider that reads ntuple pages from a file |
CROOT::Experimental::Internal::RPageSinkBuf::RColumnBuf::RPageZipItem | |
CROOT::Experimental::RPalette | A set of colors |
CROOT::Experimental::RPrintValueVisitor::RPrintOptions | |
CROOT::RDF::RDisplay::RPrintOptions | |
CROOT::Experimental::RNTupleImporter::RProgressCallback | Used to report every ~100 MB (compressed), and at the end about the status of the import |
CROOT::Experimental::Internal::RProjectedFields | The projected fields of a RNTupleModel |
►CROOT::Browsable::RProvider | Provider of different browsing methods for supported classes |
CRDefaultProvider | |
►CRFieldProvider | Base class for provider of RNTuple drawing |
CRNTupleDraw6Provider | Provider for RNTuple drawing on TCanvas |
CRNTupleDraw7Provider | Provider for RNTuple drawing on RCanvas |
CRNTupleBrowseProvider | Provider for browsing RNTuple classes |
CROOT::Browsable::TGeoBrowseProvider | Provider for TGeo browsing |
CRTFileProvider | Provides access to ROOT files with extension "root" Other extensions can be registered |
CRTObjectProvider | Provider for all known TObject-based classes |
CRV7HistDrawProvider | |
CTBranchBrowseProvider | |
►CTLeafProvider | Provider for drawing of branches / leafs in the TTree |
CTLeafDraw6Provider | Provider for drawing of ROOT6 classes |
CTLeafDraw7Provider | Provider for drawing TLeaf/TBranch in ROOT7 canvas |
CTObjectDraw6Provider | Provider for drawing of ROOT6 classes |
CTObjectDraw7Provider | Provider for drawing of ROOT7 classes |
►CROOT::RRangeCast< T, isDynamic, Range_t > | Wraps any collection that can be used in range-based loops and applies static_cast<T> or dynamic_cast<T> to each element |
CROOT::Detail::TRangeCast< T, isDynamic > | |
CROOT::RRangeCast< T *, isDynamic, TCollection const & > | |
►CROOT::Internal::RRawFile | The RRawFile provides read-only access to local and remote files |
CROOT::Internal::RRawFileDavix | Read-only access to remote non-ROOT files |
CROOT::Internal::RRawFileNetXNG | Read-only access to remote files using root/roots protocol |
CROOT::Internal::RRawFileTFile | The RRawFileTFile wraps an open TFile, but does not take ownership |
CROOT::Internal::RRawFileUnix | Uses POSIX calls to read from a mounted file system |
CROOT::Internal::RRawFileWin | Uses portable C I/O calls to read from a drive |
CROOT::Internal::RRawFileNetXNGImpl | |
CTMVA::Experimental::RReader | A replacement for the TMVA::Reader legacy interface |
CROOT::Internal::RIoUring::RReadEvent | Basic read event composed of IO data and a target file descriptor |
CROOT::Experimental::Internal::RClusterPool::RReadItem | Request to load a subset of the columns of a particular cluster |
►CROOT::RResultBase | Common handling of the error case for RResult<T> (T != void) and RResult<void> |
CROOT::RResult< T > | The class is used as a return type for operations that can fail; wraps a value of type T or an RError |
CROOT::RResult< void > | RResult<void> has no data member and no Inspect() method but instead a Success() factory method |
CROOT::RDF::RResultHandle | A type-erased version of RResultPtr and RResultMap |
CROOT::RDF::Experimental::RResultMap< T > | |
CROOT::RDF::RResultPtr< T > | Smart pointer for the return type of actions |
CROOT::RRulesList | |
►Crsa_KEY | |
CR__rsa_KEY | |
►Crsa_KEY_export | |
CR__rsa_KEY_export | |
►Crsa_NUMBER | |
CR__rsa_NUMBER | |
CROOT::RDF::Experimental::RSample | Class representing a sample which is a grouping of trees and their fileglobs, and, optionally, the sample's metadata information via the RMetaData object |
CROOT::RDF::RSampleInfo | This type represents a sample identifier, to be used in conjunction with RDataFrame features such as DefinePerSample() and per-sample callbacks |
CROOT::Experimental::RFieldBase::RSchemaIteratorTemplate< IsConstT > | Iterates over the sub tree of fields in depth-first search order |
CROOT::Experimental::Internal::RPageStorage::RSealedPage | A sealed page contains the bytes of a page as written to storage (packed & compressed) |
CROOT::Experimental::Internal::RPageStorage::RSealedPageGroup | A range of sealed pages referring to the same column that can be used for vector commit |
CROOT::Experimental::Internal::RSealedPageMergeData | |
CROOT::Experimental::Internal::RPageSink::RSealPageConfig | Parameters for the SealPage() method |
CRShared< T > | Holder of with shared_ptr<T> instance |
CROOT::Experimental::Internal::RPageSource::RSharedDescriptorGuard | An RAII wrapper used for the read-only access to RPageSource::fDescriptor . See GetExclDescriptorGuard() ` |
CROOT::Experimental::RFieldBase::RSharedPtrDeleter | |
CROOT::Experimental::Internal::RPageSink::RSinkGuard | An RAII wrapper used to synchronize a page sink. See GetSinkGuard() |
CROOT::Internal::RSlotStack | A thread-safe stack of N indexes (0 to size - 1) |
CROOT::Internal::RSlotStackRAII | A RAII object to pop and push slot numbers from a RSlotStack object |
CROOT::RDF::RSnapshotOptions | A collection of options to steer the creation of the dataset on file |
CTMVA::Experimental::RSofieReader | TMVA::RSofieReader class for reading external Machine Learning models in ONNX files, Keras .h5 files or PyTorch .pt files and performing the inference using SOFIE It is reccomended to use ONNX if possible since there is a larger support for model operators |
CROOT::RDF::Internal::RSqliteDSDataSet | The state of an open dataset in terms of the sqlite3 C library |
CROOT::Experimental::Internal::RPageSink::RStagedCluster | Cluster that was staged, but not yet logically appended to the RNTuple |
CROOT::Experimental::RClassField::RStagingItem | |
CTMVA::Experimental::RStandardScaler< T > | |
CROOT::Internal::RStl | |
CROOT::Internal::RDF::RStringCache | A Thread-safe cache for strings |
CROOT::Experimental::Internal::RPageSourceFile::RStructureBuffer | Holds the uncompressed header and footer |
CROOT::Experimental::RStyle | A set of defaults for graphics attributes, e.g |
CROOT::Experimental::RClassField::RSubFieldInfo | |
CROOT::Internal::RTaskArenaWrapper | Wrapper for tbb::task_arena |
►CROOT::Experimental::Internal::RPageStorage::RTaskScheduler | The interface of a task scheduler to schedule page (de)compression tasks |
CROOT::Experimental::Internal::RNTupleImtTaskScheduler | |
CTMVA::Experimental::RTensor< V, C > | RTensor is a container with contiguous memory and shape information |
►CTMVA::Experimental::RTensor< AFloat, TCpuBuffer< AFloat > > | |
CTMVA::DNN::TCpuTensor< AFloat > | |
CTMVA::Experimental::RTensor< float > | |
CTMVA::Experimental::RTensor< int > | |
CTMVA::Experimental::RTensor< Value_t, Container_t > | |
CROOT::Experimental::Internal::RTestFutureColumn | |
CROOT::Experimental::Internal::RTFileControlBlock | If a TFile container is written by a C stream (simple file), on dataset commit, the file header and the TFile record need to be updated |
CROOT::RTreeViewer | Web-based ROOT TTree viewer |
CTMVA::Rule | Implementation of a rule |
CTMVA::RuleCut | A class describing a 'rule cut' |
CTMVA::RuleEnsemble | |
CTMVA::RuleFit | A class implementing various fits of rule ensembles |
CTMVA::RuleFitAPI | J Friedman's RuleFit method |
CTMVA::RuleFitParams | A class doing the actual fitting of a linear model using rules as base functions |
CRUnique< T > | Holder of with unique_ptr<T> instance |
CROOT::Experimental::RNTupleModel::RUpdater | A model is usually immutable after passing it to an RNTupleWriter |
CROOT::Experimental::RFrame::RUserRanges | |
CROOT::Experimental::RFieldBase::RValue | Points to an object with RNTuple I/O support and keeps a pointer to the corresponding field |
CROOT::Experimental::RColumnDescriptor::RValueRange | |
►CROOT::Internal::RDF::RVariationBase | This type includes all parts of RVariation that do not depend on the callable signature |
CROOT::Internal::RDF::RJittedVariation | A wrapper around a concrete RVariation, which forwards all calls to it RJittedVariation is a placeholder that is inserted in the computation graph in place of a RVariation that will be just-in-time compiled |
CROOT::Internal::RDF::RVariation< F, IsSingleColumn > | |
CROOT::RDF::RVariationsDescription | A descriptor for the systematic variations known to a given RDataFrame node |
CROOT::Internal::RDF::RVariationsWithReaders | |
CROOT::Internal::VecOps::RVecInlineStorageSize< T > | The size of the inline storage of an RVec |
CROOT::Experimental::Internal::RVirtualBinsToLocalBins< I, NDIMS, BINS, AXES > | Recursively converts zero-based virtual bins where the underflow bin has index 0 and the overflow bin has index N+1 where N is the axis' number of regular bins, to the standard kUnderflowBin /kOverflowBin for under/overflow bin indexing convention |
CROOT::Experimental::Internal::RVirtualBinsToLocalBins<-1, NDIMS, BINS, AXES > | |
►CROOT::Experimental::Internal::RVirtualCanvasPainter | Abstract interface for painting a canvas |
CROOT::Experimental::RCanvasPainter | Implementation of painter for ROOT::Experimental::RCanvas, using RWebWindow |
CROOT::RWebDisplayArgs | Holds different arguments for starting browser with RWebDisplayHandle::Display() method |
►CROOT::RWebDisplayHandle | Handle of created web-based display Depending from type of web display, holds handle of started browser process or other display-specific information to correctly stop and cleanup display |
CROOT::RWebBrowserHandle | Specialized handle to hold information about running browser process Used to correctly cleanup all processes and temporary directories |
CROOT::RWebWindow | Represents web window, which can be shown in web browser or any other supported environment |
CROOT::Details::RWebWindowPlugin | |
CROOT::RWebWindowsManager | Central instance to create and show web-based windows like Canvas or FitPanel |
CROOT::Experimental::Internal::RDaosContainer::RWOperation | Describes a read/write operation on multiple attribute keys under the same object ID and distribution key, see the ReadV /WriteV functions |
CROOT::Experimental::Internal::RWritePageMemoryManager | Helper to maintain a memory budget for the write pages of a set of columns |
CTGeoParallelWorld::SafetyVoxelInfo | |
CRooStats::HistFactory::Sample | |
CROOT::Experimental::RPadExtent::ScaleFactor | A scale factor (separate factors for horizontal and vertical) for scaling a RPadLength |
CROOT::Experimental::RPadPos::ScaleFactor | A scale factor (separate factors for horizontal and vertical) for scaling a RPadLength |
CROOT::Experimental::REveScene::SceneCommand | |
CROOT::MacOSX::Util::ScopedArray< T > | |
CRooFit::Experimental::CodegenContext::ScopeRAII | |
CROOT::Math::SDeterminant< n, idim > | Dsfact |
CRooFit::TestStatistics::RooAbsL::Section | A part of some range delimited by two fractional points between 0 and 1 (inclusive) |
CSegment_t | Used for drawing line segments (maps to the X11 XSegments structure) |
CSelectionRules | The class representing the collection of selection rules |
CROOT::Meta::Selection::SelectNoInstance | Used to avoid to select all instances of a template |
CROOT::Internal::ParsingStateRAII::SemaExprCleanupsRAII | |
CROOT::Internal::ParsingStateRAII::SemaParsingInitForAutoVarsRAII | |
►CTMVA::SeparationBase | An interface to calculate the "SeparationGain" for different separation criteria used in various training algorithms |
CTMVA::CrossEntropy | Implementation of the CrossEntropy as separation criterion |
CTMVA::GiniIndex | Implementation of the GiniIndex as separation criterion |
CTMVA::GiniIndexWithLaplace | Implementation of the GiniIndex With Laplace correction as separation criterion |
CTMVA::MisClassificationError | Implementation of the MisClassificationError as separation criterion |
CTMVA::SdivSqrtSplusB | Implementation of the SdivSqrtSplusB as separation criterion |
CTStreamerInfoActions::TActionSequence::SequencePtr | |
CROOT::Experimental::REveManager::ServerState | |
CSetFreeIfTMapFile_t | Set ROOT::Internal::gFreeIfTMapFile on library load |
►CTMVA::DNN::Settings | Settings for the training of the neural net |
CTMVA::DNN::ClassificationSettings | Settings for classificationused to distinguish between different function signatures |
CSetWindowAttributes_t | Attributes that can be used when creating or changing a window |
CROOT::Detail::TCollectionProxyInfo::SfinaeHelper | |
CSgEsc_t | |
CROOT::Internal::SHA256::sha256_t | |
CSHA_CTX | |
CROOT::RGeomDescription::ShapeDescr | |
►Cstd::shared_ptr< const RooFitResult > | |
CROOT::Experimental::XRooFit::xRooNLLVar::xRooFitResult | |
►Cstd::shared_ptr< RooAbsReal > | |
CROOT::Experimental::XRooFit::xRooNLLVar | This xRooNLLVar object has several special methods, e.g |
CSharedOffset | |
CTString::ShortStr_t | |
CSHtmlExtensions_t | |
CSHtmlIndex_t | |
CSHtmlMargin_t | |
CSHtmlStyle_t | |
CSHtmlStyleStack_t | |
CSHtmlTokenMap_t | |
CSignalmap_t | |
CROOT::Fit::FitUtil::SimpleGradientCalculator | |
CROOT::Minuit2::SimplexParameters | Class describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process |
CTMVA::SimulatedAnnealing | Base implementation of simulated annealing fitting procedure |
CROOT::Minuit2::SinParameterTransformation | Class for the transformation for double-limited parameter Using a sin function one goes from a double-limited parameter range to an unlimited one |
CROOT::Math::SInverter< T, n, idim > | Dsinv |
CROOT::Math::SkipFunction< SkipNumber > | |
CROOT::Math::SkipFunction< 0 > | |
CROOT::Experimental::REveCaloData::SliceInfo_t | |
CTEveCaloData::SliceInfo_t | |
CROOT::Detail::RDF::ExtraArgsForDefine::Slot | |
CROOT::Detail::RDF::ExtraArgsForDefine::SlotAndEntry | |
Cbvh::v2::SmallStack< T, Capacity > | Fixed-size stack that can be used for a BVH traversal |
CROOT::Internal::VecOps::SmallVectorAlignmentAndSize< T > | Used to figure out the offset of the first element of an RVec |
►CROOT::Internal::VecOps::SmallVectorBase | This is all the stuff common to all SmallVectors |
CROOT::Internal::VecOps::SmallVectorTemplateCommon< bool > | |
CROOT::Internal::VecOps::SmallVectorTemplateCommon< float > | |
CROOT::Internal::VecOps::SmallVectorTemplateCommon< double > | |
CROOT::Internal::VecOps::SmallVectorTemplateCommon< ULong64_t > | |
CROOT::Internal::VecOps::SmallVectorTemplateCommon< unsigned int > | |
CROOT::Internal::VecOps::SmallVectorTemplateCommon< Long64_t > | |
CROOT::Internal::VecOps::SmallVectorTemplateCommon< int > | |
►CROOT::Internal::VecOps::SmallVectorTemplateCommon< T > | This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD |
CROOT::Internal::VecOps::SmallVectorTemplateBase< bool > | |
CROOT::Internal::VecOps::SmallVectorTemplateBase< float > | |
CROOT::Internal::VecOps::SmallVectorTemplateBase< double > | |
CROOT::Internal::VecOps::SmallVectorTemplateBase< ULong64_t > | |
CROOT::Internal::VecOps::SmallVectorTemplateBase< unsigned int > | |
CROOT::Internal::VecOps::SmallVectorTemplateBase< Long64_t > | |
CROOT::Internal::VecOps::SmallVectorTemplateBase< int > | |
►CROOT::Internal::VecOps::SmallVectorTemplateBase< T, bool > | SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put method implementations that are designed to work with non-trivial T's |
CROOT::Detail::VecOps::RVecImpl< bool > | |
CROOT::Detail::VecOps::RVecImpl< float > | |
CROOT::Detail::VecOps::RVecImpl< double > | |
CROOT::Detail::VecOps::RVecImpl< ULong64_t > | |
CROOT::Detail::VecOps::RVecImpl< unsigned int > | |
CROOT::Detail::VecOps::RVecImpl< Long64_t > | |
CROOT::Detail::VecOps::RVecImpl< int > | |
►CROOT::Detail::VecOps::RVecImpl< T > | This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter |
►CROOT::VecOps::RVecN< T, Internal::VecOps::RVecInlineStorageSize< T >::value > | |
CROOT::VecOps::RVec< T > | A "std::vector"-like collection of values implementing handy operation to analyse them |
CROOT::VecOps::RVecN< bool, Internal::VecOps::RVecInlineStorageSize< bool >::value > | |
CROOT::VecOps::RVecN< float, Internal::VecOps::RVecInlineStorageSize< float >::value > | |
CROOT::VecOps::RVecN< double, Internal::VecOps::RVecInlineStorageSize< double >::value > | |
CROOT::VecOps::RVecN< ULong64_t, Internal::VecOps::RVecInlineStorageSize< ULong64_t >::value > | |
CROOT::VecOps::RVecN< unsigned int, Internal::VecOps::RVecInlineStorageSize< unsigned int >::value > | |
CROOT::VecOps::RVecN< Long64_t, Internal::VecOps::RVecInlineStorageSize< Long64_t >::value > | |
CROOT::VecOps::RVecN< int, Internal::VecOps::RVecInlineStorageSize< int >::value > | |
►CROOT::VecOps::RVecN< T, N > | |
CROOT::VecOps::RVec< bool > | |
CROOT::VecOps::RVec< float > | |
CROOT::VecOps::RVec< double > | |
CROOT::VecOps::RVec< ULong64_t > | |
CROOT::VecOps::RVec< unsigned int > | |
CROOT::VecOps::RVec< Long64_t > | |
CROOT::VecOps::RVec< int > | |
CROOT::Internal::VecOps::SmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put method implementations that are designed to work with trivially copyable T's |
►CROOT::Internal::VecOps::SmallVectorStorage< T, N > | Storage for the SmallVector elements |
CROOT::VecOps::RVecN< T, Internal::VecOps::RVecInlineStorageSize< T >::value > | |
CROOT::VecOps::RVecN< bool, Internal::VecOps::RVecInlineStorageSize< bool >::value > | |
CROOT::VecOps::RVecN< float, Internal::VecOps::RVecInlineStorageSize< float >::value > | |
CROOT::VecOps::RVecN< double, Internal::VecOps::RVecInlineStorageSize< double >::value > | |
CROOT::VecOps::RVecN< ULong64_t, Internal::VecOps::RVecInlineStorageSize< ULong64_t >::value > | |
CROOT::VecOps::RVecN< unsigned int, Internal::VecOps::RVecInlineStorageSize< unsigned int >::value > | |
CROOT::VecOps::RVecN< Long64_t, Internal::VecOps::RVecInlineStorageSize< Long64_t >::value > | |
CROOT::VecOps::RVecN< int, Internal::VecOps::RVecInlineStorageSize< int >::value > | |
CROOT::VecOps::RVecN< T, N > | |
CROOT::Internal::VecOps::SmallVectorStorage< bool, N > | |
CROOT::Internal::VecOps::SmallVectorStorage< double, N > | |
CROOT::Internal::VecOps::SmallVectorStorage< float, N > | |
CROOT::Internal::VecOps::SmallVectorStorage< int, N > | |
CROOT::Internal::VecOps::SmallVectorStorage< Long64_t, N > | |
CROOT::Internal::VecOps::SmallVectorStorage< T, 0 > | We need the storage to be properly aligned even for small-size of 0 so that the pointer math in SmallVectorTemplateCommon::getFirstEl() is well-defined |
CROOT::Internal::VecOps::SmallVectorStorage< ULong64_t, N > | |
CROOT::Internal::VecOps::SmallVectorStorage< unsigned int, N > | |
CROOT::Math::SMatrix< T, D1, D2, R > | SMatrix: a generic fixed size D1 x D2 Matrix class |
CROOT::Math::SMatrix< T, D1, D2, R > | |
CROOT::Math::SMatrixIdentity | |
CROOT::Math::SMatrixNoInit | |
CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow | |
CROOT::Math::SMatrix< T, D1, D2, R >::SMatrixRow_const | |
Csocket | |
CSOFIE_GNN | |
CTMVA::Experimental::SofieFunctorHelper< I, F, T > | Helper class used by SOFIEFunctor to wrap the infer signature interface to RDataFrame |
CTMVA_SOFIE_GNN.SofieGNN | |
CROOT::Experimental::REveDataSimpleProxyBuilder::SPBProduct | |
CTClingCXXRecMethIter::SpecFuncIter | |
Cbvh::v2::BinnedSahBuilder< Node, BinCount >::Split | |
Cbvh::v2::SweepSahBuilder< Node >::Split | |
Cbvh::v2::SplitHeuristic< T > | |
Cbvh::v2::SplitHeuristic< Scalar > | |
CSQLite3_Stmt_t | |
CROOT::Math::Sqr< T > | Unary Square Operation Class |
CROOT::Math::Sqrt< T > | Unary Square Root Operation Class |
CROOT::Minuit2::SqrtLowParameterTransformation | Transformation from external to internal Parameter based on sqrt(1 + x**2) |
CROOT::Minuit2::SqrtUpParameterTransformation | Transformation from external to internal Parameter based on sqrt(1 + x**2) |
Csrv_HS_t | |
Cssl_func | |
CROOT::Minuit2::StackAllocator | StackAllocator controls the memory allocation/deallocation of Minuit |
CROOT::Minuit2::StackAllocatorHolder | |
CROOT::Minuit2::StackError | |
CROOT::Minuit2::StackOverflow | Define stack allocator symbol |
►CSTAT | |
CROOT::Experimental::Detail::RHistData< DIMENSIONS, PRECISION, STORAGE, STAT > | A RHistImplBase 's data, provides accessors to all its statistics |
CTMVA::StatDialogBDT | |
CTMVA::StatDialogBDTReg | |
CTMVA::StatDialogMVAEffs | |
CROOT::TVirtualRWMutex::State | Earlier lock state as returned by GetState() that can be passed to Restore() |
CROOT::TVirtualRWMutex::StateAndRecurseCount | |
CROOT::TVirtualRWMutex::StateDelta | State as returned by GetStateDelta() that can be passed to Restore() |
CRooStats::HistFactory::StatErrorConfig | Configuration to automatically assign nuisance parameters for the statistical error of the Monte Carlo simulations |
CROOT::option::Stats | Determines the minimum lengths of the buffer and options arrays used for Parser |
CROOT::Math::StdEngine< Generator > | Class to wrap engines from the C++ standard random library in the ROOT Random interface |
CROOT::Math::StdEngineType< Generator > | |
CROOT::Math::StdRandomEngine | |
CTMVA::DNN::Steepest | Steepest Gradient Descent algorithm (SGD) |
CTJSONStackObj::StlRead | |
►Cstd::streambuf | |
CTGTextViewStreamBuf | |
CRooMsgService::StreamConfig | |
CTGenCollectionProxy::StreamHelper | Helper class to facilitate I/O |
CROOT::Browsable::RProvider::StructBrowse | |
CROOT::Browsable::RProvider::StructClass | |
CROOT::Browsable::RProvider::StructDraw6 | |
CROOT::Browsable::RProvider::StructDraw7 | |
CROOT::Browsable::RProvider::StructFile | |
CTGDMLWrite::StructLst | |
CROOT::Browsable::RProvider::StructProgress | |
CStyleTemplate_t | |
CTGL5DPainter::Surf_t | |
CTCling::SuspendAutoLoadingRAII | |
CTInterpreter::SuspendAutoLoadingRAII | |
CTInterpreter::SuspendAutoParsing | |
CROOT::Math::SVector< T, D > | SVector: a generic fixed size Vector class |
CTMVA::SVEvent | Event class for Support Vector Machine |
CTMVA::SVKernelFunction | Kernel for Support Vector Machine |
CTMVA::SVKernelMatrix | Kernel matrix for Support Vector Machine |
CTMVA::SVWorkingSet | Working class for Support Vector Machine |
CSXmlAttr_t | |
CSXmlDoc_t | |
CSXmlNode_t | |
CROOT::Minuit2::sym | |
CSysInfo_t | |
CSYSTEM_BASIC_INFORMATION | |
CSYSTEM_PERFORMANCE_INFORMATION | |
CTA | |
CTGTableLayout::TableData_t | |
►CTMVA::TActivation | Interface for TNeuron activation function classes |
CTMVA::TActivationIdentity | Identity activation function for TNeuron |
CTMVA::TActivationRadial | Radial basis activation function for ANN |
CTMVA::TActivationReLU | Rectified Linear Unit activation function for TNeuron |
CTMVA::TActivationSigmoid | Sigmoid activation function for TNeuron |
CTMVA::TActivationTanh | Tanh activation function for ANN |
CTMVA::TActivationChooser | Class for easily choosing activation functions |
CTakeAValue | |
CROOT::TypeTraits::TakeFirstParameter< T > | Return first of possibly many template parameters |
CROOT::TypeTraits::TakeFirstParameter< Template< T, Rest... > > | |
CROOT::TypeTraits::TakeFirstType< T, Rest > | |
►CTApplicationImp | ABC describing GUI independent application implementation protocol |
CTRootApplication | This class create the ROOT native GUI version of the ROOT application environment |
CTArcBall | Implements the arc-ball rotation manipulator |
►CTArray | Abstract array base class |
►CTArrayC | Array of chars or bytes (8 bits per element) |
CTH1C | 1-D histogram with a byte per channel (see TH1 documentation) |
CTH2C | 2-D histogram with a byte per channel (see TH1 documentation) |
►CTH3C | 3-D histogram with a byte per channel (see TH1 documentation) |
CTGLTH3Composition | |
►CTArrayD | Array of doubles (64 bits per element) |
►CTH1D | 1-D histogram with a double per channel (see TH1 documentation) |
CTProfile | Profile Histogram |
►CTH2D | 2-D histogram with a double per channel (see TH1 documentation) |
CTProfile2D | Profile2D histograms are used to display the mean value of Z and its error for each cell in X,Y |
►CTH3D | 3-D histogram with a double per channel (see TH1 documentation) |
CTProfile3D | Profile3D histograms are used to display the mean value of T and its RMS for each cell in X,Y,Z |
►CTArrayF | Array of floats (32 bits per element) |
CTH1F | 1-D histogram with a float per channel (see TH1 documentation) |
CTH1K | TH1K class supports the nearest K Neighbours method, widely used in cluster analysis |
CTH2F | 2-D histogram with a float per channel (see TH1 documentation) |
CTH3F | 3-D histogram with a float per channel (see TH1 documentation) |
►CTArrayI | Array of integers (32 bits per element) |
CTH1I | 1-D histogram with an int per channel (see TH1 documentation) |
CTH2I | 2-D histogram with an int per channel (see TH1 documentation) |
CTH3I | 3-D histogram with an int per channel (see TH1 documentation) |
CTArrayL | Array of longs (32 or 64 bits per element) |
►CTArrayL64 | Array of long64s (64 bits per element) |
CTH1L | 1-D histogram with a long64 per channel (see TH1 documentation) |
CTH2L | 2-D histogram with a long64 per channel (see TH1 documentation) |
CTH3L | 3-D histogram with a long64 per channel (see TH1 documentation) |
►CTArrayS | Array of shorts (16 bits per element) |
CTH1S | 1-D histogram with a short per channel (see TH1 documentation) |
CTH2S | 2-D histogram with a short per channel (see TH1 documentation) |
CTH3S | 3-D histogram with a short per channel (see TH1 documentation) |
CTArrayIndexProducer | JSON array separators for multi-dimensional JSON arrays It fully reproduces array dimensions as in original ROOT classes Contrary to binary I/O, which always writes flat arrays |
CROOT::Internal::TArrayType< T, d > | Helper template to be able to determine and use array dimensions |
CROOT::Internal::TArrayType< T, 0 > | Helper class for proxy around multi dimension array |
►Ctbb::task_arena | |
CROOT::ROpaqueTaskArena | |
CRooFit::TestStatistics::LikelihoodGradientJob::task_result_t | |
CRooFit::TestStatistics::LikelihoodJob::task_result_t | |
CTASLogHandlerGuard | |
CTASPngWriter | C++ wrapper over simple writer of PNG files for standard GL memory formats: LUMINANCE, LUMINANCE_ALPHA, RGB, and RGBA |
CTAtomicCount | |
CROOT::Internal::TAtomicPointer< T > | Helper class to manage atomic pointers |
CROOT::Internal::TAtomicPointer< TObjArray * > | |
►CTAtt3D | Use this attribute class when an object should have 3D capabilities |
CROOT::Experimental::REveCaloViz | |
CROOT::Experimental::REveDigitSet | |
CTEveArrow | Class used for display of a thick arrow |
►CTEveCaloViz | Base class for calorimeter data visualization |
CTEveCalo2D | Visualization of a calorimeter event data in 2D |
CTEveCalo3D | Visualization of a calorimeter event data in 3D |
CTEveCaloLego | Visualization of calorimeter data as eta/phi histogram |
►CTEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
CTEveBoxSet | Collection of 3D primitives (fixed-size boxes, boxes of different sizes, or arbitrary sexto-epipeds, cones) |
CTEveQuadSet | Supports various internal formats that result in rendering of a set of planar (lines, rectangles, hexagons with shared normal) objects |
CTEveProjectionAxes | Axes for non-linear projections |
►CTEveShape | Abstract base-class for 2D/3D shapes |
CTEveBox | 3D box with arbitrary vertices (cuboid) |
CTEveBoxProjected | Projection of TEveBox |
CTEveGeoShape | Wrapper for TGeoShape with absolute positioning and color attributes allowing display of extracted TGeoShape's (without an active TGeoManager) and simplified geometries (needed for non-linear projections) |
CTEveGeoShapeProjected | A 3D projected TEveGeoShape |
CTEveJetCone | Draws a jet cone with leading particle is specified in (eta,phi) and cone radius is given |
CTEveJetConeProjected | Projection of TEveJetCone |
CTEvePolygonSetProjected | A set of projected polygons |
►CTEveStraightLineSet | Set of straight lines with optional markers along the lines |
CTEveScalableStraightLineSet | Straight-line-set with extra scaling, useful for projectables that need to be scaled in accordance with an external object |
CTEveStraightLineSetProjected | Projected replica of a TEveStraightLineSet |
CTEveText | TEveElement class used for displaying FreeType GL fonts |
CTEveTriangleSet | Made from a list of vertices and a list of triangles (triplets of vertex indices) |
CTGeoOverlap | Base class describing geometry overlaps |
►CTGeoVolume | TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes |
CTGeoVolumeAssembly | Volume assemblies |
CTGeoVolumeMulti | Volume families |
►CTH3 | The 3-D histogram classes derived from the 1-D histogram classes |
CTH3C | 3-D histogram with a byte per channel (see TH1 documentation) |
CTH3D | 3-D histogram with a double per channel (see TH1 documentation) |
CTH3F | 3-D histogram with a float per channel (see TH1 documentation) |
CTH3I | 3-D histogram with an int per channel (see TH1 documentation) |
CTH3L | 3-D histogram with a long64 per channel (see TH1 documentation) |
CTH3S | 3-D histogram with a short per channel (see TH1 documentation) |
CTMarker3DBox | A special 3-D marker designed for event display |
►CTNode | TNode description |
CTNodeDiv | Description of parameters to divide a 3-D geometry object |
►CTParticle | Description of the dynamic properties of a particle |
CJet | |
CROOT::Experimental::REveMCTrack | REveMCTrack |
CTEveMCTrack | |
►CTPolyLine3D | A 3-dimensional polyline |
CTHelix | THelix has two different constructors |
►CTPolyMarker3D | A 3D polymarker |
►CTPointSet3D | TPolyMarker3D using TPointSet3DGL for direct OpenGL rendering |
►CTEvePointSet | TEvePointSet is a render-element holding a collection of 3D points with optional per-point TRef and an arbitrary number of integer ids (to be used for signal, volume-id, track-id, etc) |
►CTEveLine | An arbitrary polyline with fixed line and marker attributes |
CTEveLineProjected | Projected copy of a TEveLine |
►CTEveTrack | Visual representation of a track |
CTEveTrackProjected | Projected copy of a TEveTrack |
CTEvePointSetProjected | Projected copy of a TEvePointSet |
CTPrimary | Old version of a dynamic particle class created by event generators |
►CTShape | This is the base class for all geometry shapes |
►CTBRIK | A box with faces perpendicular to the axes |
CTGTRA | A general twisted trapezoid |
CTPARA | A parallelepiped |
CTTRAP | A general trapezoid |
CTTRD1 | A trapezoid with the x dimension varying along z |
CTTRD2 | A trapezoid with both x and y dimensions varying along z |
►CTPCON | A polycone |
CTPGON | A polygon |
CTSPHE | A Sphere |
►CTTUBE | A tube |
CTCONE | A conical tube |
CTELTU | A cylinder with an elliptical section |
CTHYPE | An hyperboloid (not implemented) |
►CTTUBS | A segment of a tube |
CTCONS | A segment of a conical tube |
CTCTUB | A cut tube with 11 parameters |
CTXTRU | A poly-extrusion |
►CTAttAxis | Manages histogram axis attributes |
►CTAxis | Class to manage histogram axis |
CAxis2 | |
CTEveProjectionAxes | Axes for non-linear projections |
►CTAttBBox | Helper for management of bounding-box information |
CROOT::Experimental::REveCaloViz | |
CROOT::Experimental::REveDigitSet | |
CROOT::Experimental::REvePointSet | |
CROOT::Experimental::REveProjectionManager | REveProjectionManager Manager class for steering of projections and managing projected objects |
CROOT::Experimental::REveShape | |
CROOT::Experimental::REveStraightLineSet | REveStraightLineSet Set of straight lines with optional markers along the lines |
CTEveArrow | Class used for display of a thick arrow |
CTEveCaloViz | Base class for calorimeter data visualization |
CTEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
CTEveProjectionAxes | Axes for non-linear projections |
CTEveProjectionManager | Manager class for steering of projections and managing projected objects |
CTEveShape | Abstract base-class for 2D/3D shapes |
CTEveStraightLineSet | Set of straight lines with optional markers along the lines |
CTEveText | TEveElement class used for displaying FreeType GL fonts |
CTEveTriangleSet | Made from a list of vertices and a list of triangles (triplets of vertex indices) |
CTPointSet3D | TPolyMarker3D using TPointSet3DGL for direct OpenGL rendering |
►CTAttBBox2D | Abstract base class for elements drawn in the editor |
►CTBox | Create a Box |
►CTPave | A TBox with a bordersize and a shadow option |
CTLegend | This class displays a legend box (TPaveText) containing several legend entries |
CTPaletteAxis | The palette painting class |
►CTPaveLabel | A Pave (see TPave) with a text centered in the Pave |
CTPaveClass | A TPaveLabel specialized to process classes inside a TClassTree |
►CTPaveText | A Pave (see TPave) with text, lines or/and boxes inside |
CTDiamond | Draw a Diamond |
CTPaveStats | The histogram statistics painter class |
CTPavesText | A PaveText (see TPaveText) with several stacked paves |
►CTWbox | A TBox with a bordersize and a bordermode |
CTFrame | Define a Frame |
CTSliderBox | The moving box in a TSlider |
►CTCurlyLine | Implements curly or wavy polylines used to draw Feynman diagrams |
CTCurlyArc | Implements curly or wavy arcs used to draw Feynman diagrams |
►CTEllipse | Draw Ellipses |
CTArc | Create an Arc |
CTCrown | To draw a Crown |
►CTLine | Use the TLine constructor to create a simple line |
CTASPaletteEditor::LimitLine | |
CTArrow | Draw all kinds of Arrows |
CTGaxis | The axis painter class |
CTMarker | Manages Markers |
►CTPad | The most important graphics class in the ROOT system |
►CTButton | A TButton object is a user interface object |
CTGroupButton | A specialized TButton used in a group of Buttons |
►CTCanvas | The Canvas class |
CTDialogCanvas | A canvas specialized to set attributes |
CTInspectCanvas | A TInspectCanvas is a canvas specialized to inspect Root objects |
CTEvePad | This was intended as a TPad wrapper to allow smart updates of groups of pads |
CTSlider | A specialized TPad including a TSliderBox object |
►CTText | Base class for several text objects |
►CTLatex | To draw Mathematical Formula |
CTAnnotation | An annotation is a TLatex which can be drawn in a 2D or 3D space |
CTLink | Special TText object used to show hyperlinks |
CTMathText | To draw TeX Mathematical Formula |
CTMathTextRenderer | |
CTAttCanvas | Manages canvas attributes |
►CTAttFill | Fill Area Attributes class |
►CROOT::Experimental::XRooFit::xRooNLLVar::xRooHypoSpace | |
CROOT::Experimental::XRooFit::xRooHypoSpace | |
CROOT::v5::TF1Data | |
CTArrow | Draw all kinds of Arrows |
CTBox | Create a Box |
►CTBranch | A TTree is a list of TBranches |
CTBranchClones | A Branch for the case of an array of clone objects |
CTBranchElement | A Branch for the case of an object |
CTBranchObject | A Branch for the case of an object |
CTBranchRef | A branch containing and managing a TRefTable for TRef autoloading |
CTBranchSTL | A Branch handling STL collection of pointers (vectors, lists, queues, sets and multisets) while storing them in split mode |
CTHbookBranch | HBOOK Branch |
CTCandle | The candle plot painter class |
CTEfficiency | Class to handle efficiency histograms |
CTEllipse | Draw Ellipses |
►CTF1 | 1-Dim function class |
CTF12 | A projection of a TF2 along X or Y |
►CTF2 | A 2-Dim function with parameters |
CTF3 | A 3-Dim function with parameters |
CTGeoBatemanSol | |
►CTGeoMaterial | Base class describing materials |
CTGeoMixture | Mixtures of elements |
CTGeoOverlap | Base class describing geometry overlaps |
CTGeoVolume | TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes |
►CTGraph | A TGraph is an object made of two arrays X and Y with npoints each |
CRooCurve | One-dimensional graphical representation of a real-valued function |
CRooEllipse | Two-dimensional ellipse that can be used to represent an error contour |
CTCutG | Graphical cut class |
►CTGraphAsymmErrors | TGraph with asymmetric error bars |
CRooHist | Graphical representation of binned data based on the TGraphAsymmErrors class |
CTGraphBentErrors | A TGraphBentErrors is a TGraph with bent, asymmetric error bars |
►CTGraphErrors | A TGraphErrors is a TGraph with error bars |
CTGraphPolar | To draw a polar graph |
CTGraphMultiErrors | TGraph with asymmetric error bars and multiple y error dimensions |
CTGraphQQ | This class allows to draw quantile-quantile plots |
►CTGraph2D | Graphics object made of three arrays X, Y and Z with the same number of points each |
CTGraph2DAsymmErrors | Graph 2D class with errors |
CTGraph2DErrors | Graph 2D class with errors |
CTGraphNode | A graph node object which can be added in a TGraphStruct |
►CTH1 | TH1 is the base class of all histogram classes in ROOT |
CTH1C | 1-D histogram with a byte per channel (see TH1 documentation) |
CTH1D | 1-D histogram with a double per channel (see TH1 documentation) |
CTH1F | 1-D histogram with a float per channel (see TH1 documentation) |
CTH1I | 1-D histogram with an int per channel (see TH1 documentation) |
CTH1K | TH1K class supports the nearest K Neighbours method, widely used in cluster analysis |
CTH1L | 1-D histogram with a long64 per channel (see TH1 documentation) |
CTH1S | 1-D histogram with a short per channel (see TH1 documentation) |
►CTH2 | Service class for 2-D histogram classes |
CTH2C | 2-D histogram with a byte per channel (see TH1 documentation) |
CTH2D | 2-D histogram with a double per channel (see TH1 documentation) |
CTH2F | 2-D histogram with a float per channel (see TH1 documentation) |
CTH2I | 2-D histogram with an int per channel (see TH1 documentation) |
CTH2L | 2-D histogram with a long64 per channel (see TH1 documentation) |
►CTH2Poly | 2D Histogram with Polygonal Bins |
CTProfile2Poly | 2D Profile Histogram with Polygonal Bins |
CTH2S | 2-D histogram with a short per channel (see TH1 documentation) |
CTH3 | The 3-D histogram classes derived from the 1-D histogram classes |
CTLegendEntry | Storage class for one entry of a TLegend |
CTMarker3DBox | A special 3-D marker designed for event display |
►CTMaterial | Manages a detector material |
CTMixture | Manages a detector mixture |
CTMathText | To draw TeX Mathematical Formula |
CTMathTextRenderer | |
CTNode | TNode description |
CTPainter3dAlgorithms | The Legos and Surfaces painter class |
CTParallelCoordVar | TParallelCoord axes |
CTPieSlice | A slice of a piechart, see the TPie class |
►CTPolyLine | Defined by an array on N points in a 2-D space |
CTCurlyLine | Implements curly or wavy polylines used to draw Feynman diagrams |
CTScatter | A TScatter is able to draw four variables scatter plot on a single plot |
CTShape | This is the base class for all geometry shapes |
CTSpider | Spider class |
►CTSpline | Base class for spline implementation containing the Draw/Paint methods |
CTMVA::TSpline1 | Linear interpolation of TGraph |
CTMVA::TSpline2 | Quadratic interpolation of TGraph |
CTSpline3 | Class to create third splines to interpolate knots Arbitrary conditions can be introduced for first and second derivatives at beginning and ending points |
CTSpline5 | Class to create quintic natural splines to interpolate knots Arbitrary conditions can be introduced for first and second derivatives using double knots (see BuildCoeff) for more on this |
CTStyle | TStyle objects may be created to define special styles |
►CTTree | A TTree represents a columnar dataset |
►CTChain | A chain is a collection of files containing TTree objects |
CTProofChain | |
CTHbookTree | A wrapper class supporting Hbook ntuples (CWN and RWN) |
CTNtuple | A simple TTree restricted to a list of float variables only |
CTNtupleD | A simple TTree restricted to a list of double variables only |
CTTreeSQL | A TTree object is a list of TBranch |
►CTVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
CTImageDump | Save canvas as an image (GIF, JPEG, PNG, XPM, TIFF etc.) |
CTPDF | Interface to PDF |
CTPostScript | Interface to PostScript |
CTSVG | Interface to SVG |
CTTeXDump | Interface to TeX |
CTWebPS | |
►CTVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
CTPad | The most important graphics class in the ROOT system |
►CTVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
►CTGCocoa | This class implements TVirtualX interface for MacOS X, using Cocoa and Quartz 2D |
CTGQuartz | This is non-GUI part of TVirtualX interface, implemented for MacOS X, using CoreGraphics (Quartz) |
CTGWin32 | This class is the basic interface to the Win32 graphics system |
CTGWin32VirtualXProxy | |
►CTGX11 | This class is the basic interface to the X11 (Xlib) graphics system |
CTGX11TTF | Interface to low level X11 (Xlib) |
CTWebPadPainter | Implement TVirtualPadPainter which abstracts painting operations |
►CTAttImage | TImage attributes |
►CTImage | An abstract interface to image processing library |
CTASImage | Image class |
►CTAttLine | Line Attributes class |
CROOT::Experimental::REveLine | REveLine An arbitrary polyline with fixed line and marker attributes |
CROOT::Experimental::REveStraightLineSet | REveStraightLineSet Set of straight lines with optional markers along the lines |
CROOT::Experimental::REveTrackList | REveTrackList A list of tracks supporting change of common attributes and selection based on track parameters |
CROOT::Experimental::XRooFit::xRooNLLVar::xRooHypoSpace | |
CROOT::v5::TF1Data | |
CTBox | Create a Box |
CTCandle | The candle plot painter class |
CTEfficiency | Class to handle efficiency histograms |
CTEllipse | Draw Ellipses |
CTEveLine | An arbitrary polyline with fixed line and marker attributes |
CTEveStraightLineSet | Set of straight lines with optional markers along the lines |
►CTEveTrackList | A list of tracks supporting change of common attributes and selection based on track parameters |
CTEveTrackListProjected | Specialization of TEveTrackList for holding TEveTrackProjected objects |
CTF1 | 1-Dim function class |
CTGLAxis | GL Axis |
CTGeoBatemanSol | |
CTGeoOverlap | Base class describing geometry overlaps |
CTGeoPhysicalNode | Physical nodes are the actual 'touchable' objects in the geometry, representing a path of positioned volumes starting with the top node: path=/TOP/A_1/B_4/C_3 , where A, B, C represent names of volumes |
CTGeoVolume | TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes |
CTGraph | A TGraph is an object made of two arrays X and Y with npoints each |
CTGraph2D | Graphics object made of three arrays X, Y and Z with the same number of points each |
CTGraphEdge | An edge object connecting two nodes which can be added in a TGraphStruct |
CTGraphNode | A graph node object which can be added in a TGraphStruct |
CTGraphPolargram | To draw polar axis |
CTH1 | TH1 is the base class of all histogram classes in ROOT |
CTLatex | To draw Mathematical Formula |
CTLegendEntry | Storage class for one entry of a TLegend |
CTLine | Use the TLine constructor to create a simple line |
CTMarker3DBox | A special 3-D marker designed for event display |
CTNode | TNode description |
CTPainter3dAlgorithms | The Legos and Surfaces painter class |
CTParallelCoordRange | A TParallelCoordRange is a range used for parallel coordinates plots |
CTParallelCoordSelect | A TParallelCoordSelect is a specialised TList to hold TParallelCoordRanges used by TParallelCoord |
CTParallelCoordVar | TParallelCoord axes |
CTParticle | Description of the dynamic properties of a particle |
CTPieSlice | A slice of a piechart, see the TPie class |
CTPolyLine | Defined by an array on N points in a 2-D space |
CTPolyLine3D | A 3-dimensional polyline |
CTPrimary | Old version of a dynamic particle class created by event generators |
CTScatter | A TScatter is able to draw four variables scatter plot on a single plot |
CTShape | This is the base class for all geometry shapes |
CTSpider | Spider class |
CTSpline | Base class for spline implementation containing the Draw/Paint methods |
CTStyle | TStyle objects may be created to define special styles |
CTTree | A TTree represents a columnar dataset |
►CTView | See TView3D |
CTView3D | The 3D view class |
►CTVirtualGeoTrack | Base class for user-defined tracks attached to a geometry |
CTGeoTrack | |
CTVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
CTVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
CTVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
CTWebPadPainter | Implement TVirtualPadPainter which abstracts painting operations |
►CTAttMarker | Marker Attributes class |
CROOT::Experimental::REvePointSet | |
CROOT::Experimental::REvePointSetArray | |
CROOT::Experimental::REveStraightLineSet | REveStraightLineSet Set of straight lines with optional markers along the lines |
CROOT::Experimental::REveTrackList | REveTrackList A list of tracks supporting change of common attributes and selection based on track parameters |
CROOT::Experimental::XRooFit::xRooNLLVar::xRooHypoSpace | |
CROOT::v5::TF1Data | |
CTCandle | The candle plot painter class |
CTEfficiency | Class to handle efficiency histograms |
CTEvePointSetArray | An array of point-sets with each point-set playing a role of a bin in a histogram |
CTEveStraightLineSet | Set of straight lines with optional markers along the lines |
CTEveTrackList | A list of tracks supporting change of common attributes and selection based on track parameters |
CTF1 | 1-Dim function class |
CTGeoBatemanSol | |
CTGraph | A TGraph is an object made of two arrays X and Y with npoints each |
CTGraph2D | Graphics object made of three arrays X, Y and Z with the same number of points each |
CTH1 | TH1 is the base class of all histogram classes in ROOT |
CTLegendEntry | Storage class for one entry of a TLegend |
CTMarker | Manages Markers |
CTPolyMarker | A PolyMarker is defined by an array on N points in a 2-D space |
CTPolyMarker3D | A 3D polymarker |
CTScatter | A TScatter is able to draw four variables scatter plot on a single plot |
CTSpline | Base class for spline implementation containing the Draw/Paint methods |
CTStyle | TStyle objects may be created to define special styles |
CTTree | A TTree represents a columnar dataset |
CTVirtualGeoTrack | Base class for user-defined tracks attached to a geometry |
CTVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
CTVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
CTWebPadPainter | Implement TVirtualPadPainter which abstracts painting operations |
►CTAttPad | Manages default Pad attributes |
CTVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
►CTAttText | Text Attributes class |
CTAxisModLab | TAxis helper class used to store the modified labels |
CTButton | A TButton object is a user interface object |
CTDialogCanvas | A canvas specialized to set attributes |
CTGLAxis | GL Axis |
CTGLText | GL Text |
CTGaxis | The axis painter class |
CTGraphNode | A graph node object which can be added in a TGraphStruct |
CTGraphPolargram | To draw polar axis |
CTInspectCanvas | A TInspectCanvas is a canvas specialized to inspect Root objects |
CTLegend | This class displays a legend box (TPaveText) containing several legend entries |
CTLegendEntry | Storage class for one entry of a TLegend |
CTPaveLabel | A Pave (see TPave) with a text centered in the Pave |
CTPaveText | A Pave (see TPave) with text, lines or/and boxes inside |
CTPie | Draw a Pie Chart, |
CTStyle | TStyle objects may be created to define special styles |
CTText | Base class for several text objects |
CTVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
CTVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
CTWebPadPainter | Implement TVirtualPadPainter which abstracts painting operations |
CTBase64 | This code implements the Base64 encoding and decoding |
CTMVA::DNN::TBatch< AArchitecture > | TBatch |
CTMVA::DNN::TBatchIterator< Data_t, AArchitecture > | TBatchIterator |
CTBinIterator | |
CROOT::Internal::TBranchCacheInfo | |
CROOT::Internal::TBranchIMTHelper | A helper class for managing IMT work during TTree:Fill operations |
►CROOT::Detail::TBranchProxy | Base class for all the proxy object |
CROOT::Internal::TArrayCharProxy | Concrete Implementation of the branch proxy around the data members which are array of char |
CROOT::Internal::TArrayProxy< T > | Template for concrete implementation of proxy around array of T |
►CROOT::Internal::TClaProxy | Base class for the proxy around object in TClonesArray |
CROOT::Internal::TClaArrayProxy< T > | Template of the Concrete Implementation of the branch proxy around an TClonesArray of array of T |
CROOT::Internal::TClaImpProxy< T > | Template of the Concrete Implementation of the branch proxy around TClonesArray of T |
CROOT::Internal::TImpProxy< T > | Template of the proxy around objects |
►CROOT::Internal::TStlProxy | Base class for the proxy around STL containers |
CROOT::Internal::TStlArrayProxy< T > | Template of the Concrete Implementation of the branch proxy around an stl container of array of T |
CROOT::Internal::TStlImpProxy< T > | Template of the Concrete Implementation of the branch proxy around an stl container of T |
CTBranchProxyClassDescriptor | Hold the processed information about a TClass used in a TBranch while TTreeProxyGenerator is parsing the TTree information |
CTBranchProxyDescriptor | /Hold the processed information about a TBranch while /TTreeProxyGenerator is parsing the TTree information |
CROOT::Internal::TBranchProxyDirector | |
CTBranchProxyDirector | This class is used to 'drive' and hold a serie of TBranchProxy objects which represent and give access to the content of TTree object |
CROOT::Internal::TBranchProxyHelper | String builder to be used in the constructors |
►CTBrowserImp | ABC describing GUI independent browser implementation protocol |
CROOT::RWebBrowserImp | |
CTGFileBrowser | System file browser, used as TRootBrowser plug-in |
CTMyBrowserImp | |
►CTRootBrowser | This class creates a ROOT object browser, constituted by three main tabs |
CTEveBrowser | Specialization of TRootBrowser for Eve |
CTRootBrowserLite | This class creates a ROOT object browser (looking like Windows Explorer) |
CTBtItem | Item stored in inner nodes of a TBtree |
►CTBtNode | Abstract base class (ABC) of a TBtree node |
CTBtInnerNode | Inner node of a TBtree |
CTBtLeafNode | Leaf node of a TBtree |
CTBuffer3DTypes | |
CROOT::TBufferMerger | TBufferMerger is a class to facilitate writing data in parallel from multiple threads, while writing to a single output file |
CROOT::Experimental::Internal::TBulkBranchRead | Helper class for reading many branch entries at once to optimize throughput |
►CTCanvasImp | ABC describing GUI independent main window (with menubar, scrollbars and a drawing area) |
CTRootCanvas | This class creates a main window with menubar, scrollbars and a drawing area |
CTWebCanvas | Basic TCanvasImp ABI implementation for Web-based Graphics Provides painting of main ROOT classes in web browsers using JSROOT |
CTCanvasInit | |
►CROOT::Internal::TCDGIILIBase | |
CROOT::Internal::ClassDefGenerateInitInstanceLocalInjector< T > | |
CRgl::Mc::TCell< V > | |
CTChainIndex::TChainIndexEntry | Holds a description of indices of trees in the chain |
CROOT::Internal::TClaObjProxy< T > | |
CTClass__GetCallingNewRAII | |
CROOT::TClassAlt | |
CROOT::Internal::TClassGetClassHelper< T > | |
CROOT::TClassRec | |
CTClassRef | TClassRef is used to implement a permanent reference to a TClass object |
►CTClassStreamer | |
CTCollectionClassStreamer | Class streamer object to implement TClassStreamer functionality for I/O emulation |
CTProofPlayer::TCleanup | |
CTClingBaseClassInfo | Emulation of the CINT BaseClassInfo class |
CTClingCallFunc | Emulation of the CINT CallFunc class |
►CTClingDeclInfo | |
CTClingClassInfo | Emulation of the CINT ClassInfo class |
CTClingDataMemberInfo | Emulation of the CINT DataMemberInfo class |
CTClingMethodArgInfo | Emulation of the CINT MethodInfo class |
CTClingMethodInfo | Emulation of the CINT MethodInfo class |
CTClingTypeInfo | Emulation of the CINT TypeInfo class |
CTClingTypedefInfo | Emulation of the CINT TypedefInfo class |
►CTClingMemberIter | Iterate over all DeclT-s (or UsingShadowDecl-s pointing to DeclT-s) of a decl context, skipping those for which DerivedT::ShouldSkip(const Decl*) returns true when invoked with the Decl |
CTClingCXXRecMethIter | Iterate over FunctionDecl and UsingShadowDecls of FunctionDecl, within a scope, recursing through "transparent" scopes (see DCIter::HandleInlineDeclContext()) |
CTClingDataMemberIter | Iterate over VarDecl, FieldDecl, EnumConstantDecl, IndirectFieldDecl, and UsingShadowDecls thereof, within a scope, recursing through "transparent" scopes (see DCIter::HandleInlineDeclContext()) |
CROOT::Internal::TClonesArrayOwnershipRAII | |
CTTree::TClusterIterator | Helper class to iterate over cluster of baskets |
CTCollectionProxyFactory | TCollectionProxyFactory Interface to collection proxy and streamer generator |
CROOT::Detail::TCollectionProxyInfo | |
►CTCollectionStreamer | Class streamer object to implement TClassStreamer functionality for I/O emulation |
CTCollectionClassStreamer | Class streamer object to implement TClassStreamer functionality for I/O emulation |
CTCollectionMemberStreamer | Class streamer object to implement TMemberStreamer functionality for I/O emulation |
CTGLUtil::TColorLocker | |
CTColorNumber | |
CTStreamerInfo::TCompInfo | |
CTComplex | |
►CTStreamerInfoActions::TConfiguration | Base class of the Configurations |
CTStreamerInfoActions::TBitsConfiguration | |
CTStreamerInfoActions::TConfNoFactor | |
CTStreamerInfoActions::TConfObject | |
CTStreamerInfoActions::TConfStreamerLoop | |
CTStreamerInfoActions::TConfSubSequence | |
CTStreamerInfoActions::TConfWithFactor | |
►CTStreamerInfoActions::TConfigSTL | |
CTStreamerInfoActions::TConfSTLNoFactor | |
CTStreamerInfoActions::TConfSTLWithFactor | |
CTStreamerInfoActions::TConfigurationPushDataCache | |
CTStreamerInfoActions::TConfigurationUseCache | |
CTStreamerInfoActions::TGenericConfiguration | |
CTDirectory::TContext | TDirectory::TContext keeps track and restore the current directory |
CTVirtualPad::TContext | Small helper class to store/restore gPad context in TPad methods |
►CTContextMenuImp | This class provides an interface to GUI independent context sensitive popup menus |
CTRootContextMenu | This class provides an interface to context sensitive popup menus |
►CTControlBarImp | ABC describing GUI independent control bar |
CTRootControlBar | This class provides an interface to the GUI dependent functions of the TControlBar class |
CTWebControlBar | Web-based implementation for TControlBar class |
CTMVA::DNN::CNN::TConvParams | |
CTMVA::DNN::TCpu< AReal > | The TCpu architecture class |
CTMVA::DNN::TCpuBuffer< AFloat > | TCpuBuffer |
CTMVA::DNN::TCpuMatrix< AFloat > | The TCpuMatrix class |
CTCreatePrimitives | Creates new primitives |
CTMVA::DNN::TCuda< AReal > | The TCuda architecture class |
CTMVA::DNN::TCudaDeviceBuffer< AFloat > | TCudaDeviceBuffer |
CTMVA::DNN::TCudaDeviceReference< AFloat > | TCudaDeviceReference |
CTMVA::DNN::TCudaHostBuffer< AFloat > | TCudaHostBuffer |
CTMVA::DNN::TCudaMatrix< AFloat > | TCudaMatrix Class |
CTMVA::DNN::TCudaTensor< AFloat > | TCudaTensor Class |
CTCursorSwitcher | Helper class used to change the cursor in a method and restore the original one when going out of the method scope |
CROOT::RDF::TCutInfo | |
CTMVA::DNN::TDataLoader< Data_t, AArchitecture > | TDataLoader |
CTMVA::DNN::TDataLoader< AData, TReference< AReal > > | |
CROOT::Math::TDataPoint< K, _val_type > | |
CROOT::Math::TDataPointN< _val_type > | |
CTDatime | This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130 124559) |
CTDavixFileInternal | |
CTClass::TDeclNameRegistry | |
CTMVA::DNN::TDeepNet< Architecture_t, Layer_t > | Generic Deep Neural Network class |
CTMVA::DNN::TDeepNet< Architecture_t, VGeneralLayer< Architecture_t > > | |
►CTMVA::DNN::TDescriptors | |
CTMVA::DNN::CNN::TCNNDescriptors< Layer_t > | |
CTMVA::DNN::RNN::TRNNDescriptors< Architecture_t > | |
CTMVA::DNN::TDNNGenDescriptors< Layer_t > | |
CTMVA::DNN::TCpuBuffer< AFloat >::TDestructor | |
CTMVA::DNN::TCudaDeviceBuffer< AFloat >::TDestructor | |
CTMVA::DNN::TCudaHostBuffer< AFloat >::TDestructor | |
CTMVA::DNN::TDevice | TDevice |
CROOT::Internal::TDirectoryAtomicAdapter | Internal class used in the implementation of gDirectory The objects of type TDirectoryAtomicAdapter should only be used inside the thread that created them |
CTMVA::DNN::TDLGradientDescent< Architecture_t > | |
CTDomParser | DOM stands for the Document Object Model; this is an API for accessing XML or HTML structured documents |
CTGLUtil::TDrawQualityModifier | |
CTGLUtil::TDrawQualityScaler | |
CTElementActionT< Element > | |
CTElementPosActionT< Element > | |
CtempFileNamesCatalog | Little helper class to bookkeep the files names which we want to make temporary |
COuter::Template< T, U > | |
COuter::Template< Inner, 1 > | Simple specialisation |
COuter::Template< Template< Inner, 2 >, 1 > | Complex specialisation |
CCPyCppyy::TemplateInfo | |
CROOT::Internal::DictSelectionReader::TemplateInfo | |
CCPyCppyy::TemplateProxy | |
CCPyCppyy::CallContext::Temporary | |
CTEngineHolder | |
CTMVA::DNN::TCudaTensor< AFloat >::TensorDescriptor | |
CTMVA::Experimental::SOFIE::TensorInfo | |
CROOT::Math::TensorMulOp< Vector1, Vector2 > | Class for Tensor Multiplication (outer product) of two vectors giving a matrix |
CTMVA::Experimental::SOFIE::TensorType< T > | |
CTMVA::Experimental::SOFIE::TensorType< double > | |
CTMVA::Experimental::SOFIE::TensorType< float > | |
CTMVA::Experimental::SOFIE::TensorType< int32_t > | |
CTMVA::Experimental::SOFIE::TensorType< int64_t > | |
CTMVA::Experimental::SOFIE::TensorType< uint32_t > | |
CTMVA::Experimental::SOFIE::TensorType< uint64_t > | |
►CTEnvParser | TEnv Parser |
CTReadEnvParser | |
CTWriteEnvParser | |
CRgl::Pad::Tesselator | |
►CRooStats::TestStatistic | TestStatistic is an interface class to provide a facility for construction test statistics distributions to the NeymanConstruction class |
CRooStats::DebuggingTestStat | |
CRooStats::MaxLikelihoodEstimateTestStat | MaxLikelihoodEstimateTestStat: TestStatistic that returns maximum likelihood estimate of a specified parameter |
CRooStats::NumEventsTestStat | NumEventsTestStat is a simple implementation of the TestStatistic interface used for simple number counting |
CRooStats::ProfileLikelihoodTestStat | ProfileLikelihoodTestStat is an implementation of the TestStatistic interface that calculates the profile likelihood ratio at a particular parameter point given a dataset |
CRooStats::RatioOfProfiledLikelihoodsTestStat | TestStatistic that returns the ratio of profiled likelihoods |
CRooStats::SimpleLikelihoodRatioTestStat | TestStatistic class that returns -log(L[null] / L[alt]) where L is the likelihood |
CROOT::Experimental::XRooFit::xRooFit::TestStatistic | |
►CRooStats::TestStatSampler | TestStatSampler is an interface class for a tools which produce RooStats SamplingDistributions |
CRooStats::DebuggingSampler | |
►CRooStats::ToyMCSampler | ToyMCSampler is an implementation of the TestStatSampler interface |
CRooStats::ToyMCImportanceSampler | ToyMCImportanceSampler is an extension of the ToyMCSampler for Importance Sampling |
CROOT::Experimental::EveGlu::TestTriangleHandler | TestTriangleHandler is just helper class to get access to protected members of TriangleCollector Hide static declarations, let use "native" GL types |
►CTEveChunkManager | Vector-like container with chunked memory allocation |
CTEveChunkVector< T > | |
►CTEveElement | Base class for TEveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management |
CTEveArrow | Class used for display of a thick arrow |
►CTEveCaloData | A central manager for calorimeter event data |
CTEveCaloDataHist | A central manager for calorimeter data of an event written in TH2F |
CTEveCaloDataVec | Calo data for universal cell geometry |
CTEveCaloViz | Base class for calorimeter data visualization |
CTEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
►CTEveElementList | A list of TEveElements |
►CTEveCompound | Description of TEveCompound |
CTEveCompoundProjected | Description of TEveCompoundProjected |
CTEveElementListProjected | A projected element list – required for proper propagation of render state to projected views |
CTEveEventManager | Base class for event management and navigation |
CTEvePlot3D | Description of TEvePlot3D |
CTEveProjectionManager | Manager class for steering of projections and managing projected objects |
CTEveScene | Eve representation of TGLScene |
CTEveSceneList | List of Scenes providing common operations on TEveScene collections |
CTEveSelection | Make sure there is a SINGLE running TEveSelection for each selection type (select/highlight) |
CTEveShape | Abstract base-class for 2D/3D shapes |
CTEveTrackList | A list of tracks supporting change of common attributes and selection based on track parameters |
CTEveTrackPropagator | Holding structure for a number of track rendering parameters |
CTEveTriangleSet | Made from a list of vertices and a list of triangles (triplets of vertex indices) |
CTEveViewerList | List of Viewers providing common operations on TEveViewer collections |
►CTEveWindow | Abstract base-class for representing eve-windows |
►CTEveWindowFrame | Encapsulates TGFrame into an eve-window |
CTEveViewer | Eve representation of TGLViewer |
CTEveWindowPack | Encapsulates TGPack into an eve-window |
CTEveWindowSlot | Description of TEveWindowSlot |
CTEveWindowTab | Encapsulates TGTab into an eve-window |
CTEveWindowManager | Manager for EVE windows |
►CTEveGeoNode | Wrapper for TGeoNode that allows it to be shown in GUI and controlled as a TEveElement |
CTEveGeoTopNode | A wrapper over a TGeoNode, possibly displaced with a global trasformation stored in TEveElement |
CTEveParamList | Collection of named parameters |
CTEvePointSet | TEvePointSet is a render-element holding a collection of 3D points with optional per-point TRef and an arbitrary number of integer ids (to be used for signal, volume-id, track-id, etc) |
CTEvePointSetArray | An array of point-sets with each point-set playing a role of a bin in a histogram |
CTEveProjectionAxes | Axes for non-linear projections |
CTEveSceneInfo | TEveUtil representation of TGLSceneInfo |
CTEveStraightLineSet | Set of straight lines with optional markers along the lines |
CTEveText | TEveElement class used for displaying FreeType GL fonts |
CTEveFrameBoxGL | A class encapsulating GL rendering of TEveFrameBox via a static member function |
CTEveGeoManagerHolder | Exception safe wrapper for setting gGeoManager |
CTEveElement::TEveListTreeInfo | Structure holding information about TGListTree and TGListTreeItem that represents given TEveElement |
►CTEveMagField | Abstract base-class for interfacing to magnetic field needed by the TEveTrackPropagator |
CTEveMagFieldConst | Implements constant magnetic field, given by a vector fB |
CTEveMagFieldDuo | Implements constant magnetic filed that switches on given axial radius fR2 from vector fBIn to fBOut |
CTEveManager | Central application manager for Eve |
CTEvePadHolder | Exception safe wrapper for setting gPad |
CTEvePathMarkT< TT > | Special-point on track: |
►CTEvePointSelectorConsumer | TEvePointSelectorConsumer is a virtual base for classes that can be filled from TTree data via the TEvePointSelector class |
CTEvePointSet | TEvePointSet is a render-element holding a collection of 3D points with optional per-point TRef and an arbitrary number of integer ids (to be used for signal, volume-id, track-id, etc) |
CTEvePointSetArray | An array of point-sets with each point-set playing a role of a bin in a histogram |
►CTEveProjectable | Abstract base-class for non-linear projectable objects |
CTEveCaloViz | Base class for calorimeter data visualization |
CTEveElementList | A list of TEveElements |
CTEvePointSet | TEvePointSet is a render-element holding a collection of 3D points with optional per-point TRef and an arbitrary number of integer ids (to be used for signal, volume-id, track-id, etc) |
CTEveStraightLineSet | Set of straight lines with optional markers along the lines |
►CTEveProjected | Abstract base class for classes that hold results of a non-linear projection transformation |
CTEveBoxProjected | Projection of TEveBox |
CTEveCalo2D | Visualization of a calorimeter event data in 2D |
CTEveCompoundProjected | Description of TEveCompoundProjected |
CTEveElementListProjected | A projected element list – required for proper propagation of render state to projected views |
CTEveGeoShapeProjected | A 3D projected TEveGeoShape |
CTEveJetConeProjected | Projection of TEveJetCone |
CTEveLineProjected | Projected copy of a TEveLine |
CTEvePointSetProjected | Projected copy of a TEvePointSet |
CTEvePolygonSetProjected | A set of projected polygons |
CTEveStraightLineSetProjected | Projected replica of a TEveStraightLineSet |
CTEveTrackListProjected | Specialization of TEveTrackList for holding TEveTrackProjected objects |
CTEveTrackProjected | Projected copy of a TEveTrack |
►CTEveProjection | Base-class for non-linear projections |
CTEve3DProjection | 3D scaling projection |
CTEveRPhiProjection | XY projection with distortion around given center |
CTEveRhoZProjection | Transformation from 3D to 2D |
CTEveXZProjection | XZ projection with distortion around given center |
CTEveYZProjection | YZ projection with distortion around given center |
CTEveZXProjection | ZX projection with distortion around given center |
CTEveZYProjection | ZY projection with distortion around given center |
►CTEveRefCnt | Base-class for reference-counted objects |
CTEveRGBAPalette | A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes |
►CTEveRefBackPtr | Base-class for reference-counted objects with reverse references to TEveElement objects |
CTEveFrameBox | Description of a 2D or 3D frame that can be used to visually group a set of objects |
CTEveTrackPropagator | Holding structure for a number of track rendering parameters |
►CTEveSecondarySelectable | Semi-abstract interface for classes supporting secondary-selection |
CTEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
CTEveUtil | Standard utility functions for Eve |
CTEveVector2T< TT > | Minimal, templated two-vector |
►CTEveVectorT< TT > | Minimal, templated three-vector |
CTEveVector4T< TT > | Minimal, templated four-vector |
CTEveVectorT< Double_t > | |
CTEveVectorT< Float_t > | |
CTExceptionHandler | |
CROOT::TExecutorCRTP< SubC > | This class defines an interface to execute the same task multiple times, possibly in parallel and with different arguments every time |
►CROOT::TExecutorCRTP< TExecutor > | |
CROOT::Internal::TExecutor | This class implements the interface to execute the same task multiple times, sequentially or in parallel depending on the execution policy passed as a first parameter on construction, and possibly with different arguments every time |
►CROOT::TExecutorCRTP< TProcessExecutor > | |
CROOT::TProcessExecutor | This class provides a simple interface to execute the same task multiple times in parallel, possibly with different arguments every time |
►CROOT::TExecutorCRTP< TSequentialExecutor > | |
CROOT::TSequentialExecutor | |
►CROOT::TExecutorCRTP< TThreadExecutor > | |
CROOT::TThreadExecutor | This class provides a simple interface to execute the same task multiple times in parallel threads, possibly with different arguments every time |
CTExMapIter | |
►Cclang::TextDiagnosticPrinter | |
CTClingDelegateDiagnosticPrinter | Uses clang::TextDiagnosticPrinter to format diagnostics, which are then passed to a user-specified function |
CROOT::Quartz::TextLine | |
CTLatex::TextSpec_t | TLatex helper struct holding the attributes of a piece of text |
CROOT::Internal::TF1Builder< Func > | Internal class used by TF1 for defining template specialization for different TF1 constructors |
CROOT::Internal::TF1Builder< const char * > | TF1 building from a string used to build a TFormula based on a lambda function |
CROOT::Internal::TF1Builder< Func * > | |
CTF1Convolution_EvalWrapper | |
►CTF1::TF1FunctorPointer | |
CTF1::TF1FunctorPointerImpl< T > | |
CTF1Parameters | TF1 Parameters class |
CTFdSet | |
CTFileMergeInfo | |
CTFitResultPtr | Provides an indirection to the TFitResult class and with a semantics identical to a TFitResult pointer, i.e |
CTFormulaFunction | Helper class for TFormula |
CTFormulaParamOrder | Functor defining the parameter order |
CTFormulaVariable | Another helper class for TFormula |
CROOT::TForNamespace | |
CTTree::TFriendLock | Helper class to prevent infinite recursion in the usage of TTree Friends |
CROOT::Internal::TFriendProxy | |
CTFriendProxy | Concrete implementation of the proxy around a Friend Tree |
CTFriendProxyDescriptor | Hold the processed information about a Friend TTree while TTreeProxyGenerator is parsing the TTree information |
CTGClientInit | |
CTGDimension | |
CTGDMAssignmentHelper< T > | |
CTGenCollectionProxy__SlowIterator | |
►CTGenericCollectionIterator | |
CTGenericCollectionIterator::RegularIterator | |
CTGenericCollectionIterator::VectorIterator | |
►CTGeoAtt | Visualization and tracking attributes for volumes and nodes |
►CTGeoNode | A node represent a volume positioned inside another.They store links to both volumes and to the TGeoMatrix representing the relative positioning |
CTGeoNodeMatrix | A node containing local transformation |
CTGeoNodeOffset | Node containing an offset |
CTGeoVolume | TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes |
CTVirtualGeoTrack | Base class for user-defined tracks attached to a geometry |
CTGeoElemIter | Iterator for decay branches |
CTGeoFacet | |
CTGeoIterator | A geometry iterator |
CTGeoRCPtr< T > | A reference counting-managed pointer for classes derived from TGeoExtension which can be used as C pointer |
CTGeoStateInfo | Statefull info for the current geometry level |
CTGeoVector3 | Simple 3-vector representation |
CTGeoVoxelGrid< T, S > | A finite 3D grid structure, mapping/binning arbitrary 3D cartesian points onto discrete "voxels" |
CTGeoVoxelGrid< TGeoParallelWorld::SafetyVoxelInfo > | |
CTGeoVoxelGridIndex | |
CTGFileEntry | Utility class used by the file selection dialog (TGFSDialog) |
CTGFileInfo | |
CTGFSContainer | Utility class used by the file selection dialog (TGFSDialog) |
CROOT::Internal::TGILRAII | Class to acquire and release the Python GIL where it applies, i.e |
CTGInsets | |
CTGL5DDataSetEditor::TGL5DEditorPrivate | |
►CTGLAxisPainter | Utility class to paint axis in GL |
CTGLAxisPainterBox | Painter class for axes encompassing a 3D box |
CTGLBoundingBox | Concrete class describing an orientated (free) or axis aligned box of 8 vertices |
CTGLBoxCut | Used by plot-painters to determine the area of the plot that is cut away |
CTGLCapabilityEnabler | |
CTGLCapabilitySwitch | |
CTGLColor | Class encapsulating color information in preferred GL format - an array of four unsigned bytes |
CTGLColorSet | Class encapsulating a set of colors used throughout standard rendering |
CTGLContext | This class encapsulates window-system specific information about a GL-context and alows their proper management in ROOT |
CTGWin32GLManager::TGLContext | |
CTX11GLManager::TGLContext_t | |
CTGLContextIdentity | Identifier of a shared GL-context |
CTGLContextPrivate | |
CTGLDisableGuard | |
CTGLEnableGuard | |
CTGLFaderHelper | |
CTGLFBO | Frame-buffer object |
CTGLFloatHolder | |
CTGLFont | A wrapper class for FTFont |
CTGLFontManager | A FreeType GL font manager |
CTGLFormat | Encapsulation of format / contents of an OpenGL buffer |
►CTGListTreeItem | |
CTEveListTreeItem | Special list-tree-item for Eve |
CTGListTreeItemStd | |
CTGLLevelPalette | |
CTGLLine3 | 3D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex' |
►CTGLLockable | Simple locking interface used by viewer and scene |
►CTGLSceneBase | Scene base-class – provides basic interface expected by the TGLViewer or its sub-classes: |
►CTGLScene | TGLScene provides management and rendering of ROOT's default 3D /object representation as logical and physical shapes |
CTGLScenePad | Implements VirtualViewer3D interface and fills the base-class visualization structures from pad contents |
►CTGLViewerBase | Base class for GL viewers |
►CTGLViewer | Base GL viewer object - used by both standalone and embedded (in pad) GL |
CTGLEmbeddedViewer | Minimal GL-viewer that can be embedded in a standard ROOT frames |
CTGLSAViewer | The top level standalone GL-viewer - created via plugin manager |
►CTGLLogicalShape | Abstract logical shape - a GL 'drawable' - base for all shapes - faceset sphere etc |
CTGLCylinder | Implements a native ROOT-GL cylinder that can be rendered at different levels of detail |
CTGLFaceSet | Implements a native ROOT-GL representation of an arbitrary set of polygons |
►CTGLObject | Base-class for direct OpenGL renderers |
CTEveArrowGL | OpenGL renderer class for TEveArrow |
CTEveBoxGL | OpenGL renderer class for TEveBox |
CTEveBoxProjectedGL | OpenGL renderer class for TEveBoxProjected |
CTEveCalo2DGL | OpenGL renderer class for TEveCalo2D |
CTEveCalo3DGL | OpenGL renderer class for TEveCalo3D |
CTEveCaloLegoGL | OpenGL renderer class for TEveCaloLego |
►CTEveDigitSetGL | OpenGL renderer class for TEveDigitSet |
CTEveBoxSetGL | A GL rendering class for TEveBoxSet |
CTEveQuadSetGL | GL-renderer for TEveQuadSet class |
►CTEveJetConeGL | OpenGL renderer class for TEveJetCone |
CTEveJetConeProjectedGL | OpenGL renderer class for TEveJetConeProjected |
CTEvePlot3DGL | OpenGL renderer class for TEvePlot3D |
CTEvePolygonSetProjectedGL | GL-renderer for TEvePolygonSetProjected class |
CTEveProjectionAxesGL | OpenGL renderer class for TEveProjectionAxes |
CTEveStraightLineSetGL | GL-renderer for TEveStraightLineSet class |
CTEveTextGL | OpenGL renderer class for TEveText |
CTEveTriangleSetGL | GL-renderer for TEveTriangleSet class |
►CTGLPlot3D | Description of TGLPlot3D |
CTF2GL | GL renderer for TF2 |
CTGLParametricEquationGL | GL-renderer wrapper for TGLParametricEquation |
CTH2GL | Rendering of TH2 and derived classes |
CTH3GL | OpenGL renderer class for TH3 |
►CTPointSet3DGL | Direct OpenGL renderer for TPointSet3D |
►CTEveLineGL | GL-renderer for TEveLine class |
►CTEveTrackGL | GL-renderer for TEveTrack class |
CTEveTrackProjectedGL | GL-renderer for TEveTrackProjected class |
CTGLPolyLine | To draw a 3D polyline in a GL window |
CTGLPolyMarker | To draw a 3D polymarker in a GL window |
CTGLSphere | Implements a native ROOT-GL sphere that can be rendered at different levels of detail |
CTGLMatrix | 16 component (4x4) transform matrix - column MAJOR as per GL |
►CTGLMesh | |
CTCylinderMesh | |
CTCylinderSegMesh | |
CTubeMesh | |
CTubeSegMesh | |
CTGLongPosition | |
CTGLOutput | Wrapper class for GL capture & output routines |
►CTGLOverlayElement | An overlay element |
CTEveRGBAPaletteOverlay | Description of TEveRGBAPaletteOverlay |
CTGLAnnotation | GL-overlay annotation |
CTGLCameraGuide | Draws arrows showing camera orientation in the overlay |
►CTGLCameraOverlay | A GL overlay element which displays camera furstum |
CTEveCaloLegoOverlay | GL-overlay control GUI for TEveCaloLego |
CTGLClipSet | A collection of concrete TGLClip objects to be selected from |
CTGLManipSet | Combine all available manipulators in a collection |
CTGLOverlayButton | GL-overlay button |
CTGLOverlayList | Manage a collection of overlay elements |
►CTGLPaintDevice | |
CTGLAdapter | Allow plot-painters to be used for gl-inpad and gl-viewer |
CTGLWidget | GL window with context |
►CTGLPhysicalShape | Concrete physical shape - a GL drawable |
►CTGLClip | Abstract clipping shape - derives from TGLPhysicalShape Adds clip mode (inside/outside) and pure virtual method to approximate shape as set of planes |
CTGLClipBox | Concrete clip box object |
CTGLClipPlane | Concrete clip plane object |
CTGLPlane | 3D plane class - of format Ax + By + Cz + D = 0 |
CTGLPlotBox | Implementation of a box around a histogram/function for plot-painters |
CTGLPlotCamera | Camera for TGLPlotPainter and sub-classes |
CTGLPlotCoordinates | Helper class for plot-painters holding information about axis ranges, numbers of bins and flags if certain axis is logarithmic |
►CTGLPShapeRef | Base class for references to TGLPysicalShape that need to be notified when the shape is destroyed |
CTGLManipSet | Combine all available manipulators in a collection |
CTGLPShapeObjEditor | GUI editor for TGLPShapeObj |
CTGLQuadric | Wrapper class for GLU quadric shape drawing object |
CTGLRect | Viewport (pixel base) 2D rectangle class |
CTGLRnrCtx | Aggregates data for a given redering context as needed by various parts of the ROOT's OpenGL infrastructure |
►CTGLSceneInfo | Base class for extended scene context |
CTGLScene::TSceneInfo | |
CTGLSdfFontMaker | Helper class for generation of Signed Distance Field (SDF) fonts for REve |
CTGLSelectBuffer | Encapsulates OpenGL select buffer |
CTGLSelectionBuffer | |
►CTGLSelectRecordBase | Base class for select records |
CTGLOvlSelectRecord | Selection record for overlay objects |
CTGLSelectRecord | Standard selection record including information about containing scene and details ob out selected object (TGLPhysicalShape*, TObject* or simply a void* for foreign scenes) |
CTGLStopwatch | Stopwatch object for timing GL work |
CTGLUtil | Wrapper class for various misc static functions - error checking, draw helpers etc |
►CTGLVertex3 | 3 component (x/y/z) vertex class |
CTGLVector3 | 3 component (x/y/z) vector class |
CTGMdiFrameList | |
CTGMdiGeometry | |
CTGMdiMenu | This file contains the TGMdiMenuBar class |
►CTGNumberFormat | |
CTGNumberEntry | TGNumberEntry is a number entry input widget with up/down buttons |
CTGNumberEntryField | |
CTGPasswdDialog | Graphic dialog to enter passwords |
CTGPosition | |
CTMVA::DNN::TGradientDescent< Architecture_t > | |
CROOT::TF1Helper::TGradientParFunction | Function class representing the derivative with respect a parameter of a given TF1 |
CTGRectangle | |
CTGRedirectOutputGuard | This class provides output redirection to a TGTextView in guaranteed exception safe way |
►CRgl::Mc::TGridGeometry< V > | |
CRgl::Mc::TDefaultSplitter< H, E, V > | |
►CRgl::Mc::TGridGeometry< Double_t > | |
CRgl::Mc::TF3Adapter | |
CRgl::Mc::TF3EdgeSplitter | |
►CRgl::Mc::TGridGeometry< Float_t > | |
CRgl::Fgt::TKDEAdapter | |
CTGScrollBarElements | The "head", "tail" and "slider" |
CTGSearchType | |
CTGText | A TGText is a multi line text buffer |
CTGTextBuffer | A text buffer is used in several widgets, like TGTextEntry, TGFileDialog, etc |
CTGTextEditDialogs | This file defines several dialogs that are used by the TGTextEdit widget via its associated context popup menu |
CTGTextLine | |
CTGTextViewStream | A TGTextViewStream is a text viewer widget |
►CRgl::TGuardBase | |
CRgl::TOneArgGuard< Func, Arg > | |
CRgl::TTwoArgsGuard< Func, Arg1, Arg2 > | |
CTGuiBldDragManagerGrid | |
CTGuiBldDragManagerPimpl | |
►CTGuiBuilder | |
CTRootGuiBuilder | |
CTGuiNameFrame | |
►CTGWidget | The widget base class |
CTEveGTriVecValuator | Composite GUI element for setting three numerical values (label, three number-entries) |
►CTEveGValuatorBase | Base class for composite GUI elements for setting of numeric values |
CTEveGDoubleValuator | Composite GUI element for selection of range (label, two number-entries and double-slider) |
CTEveGValuator | Composite GUI element for single value selection (supports label, number-entry and slider) |
►CTGButton | A button abstract base class |
►CTGDockButton | |
CTGDockHideButton | |
►CTGPictureButton | Yield an action as soon as it is clicked |
CTGImageMap | (with TGRegion and TGRegionWithId help classes) |
CTGRepeatFireButton | |
CTGuiBldToolButton | |
►CTGTextButton | Yield an action as soon as it is clicked |
CTEveGedNameTextButton | Specialization of TGTextButton for EVE name frame |
►CTGCheckButton | Selects different options |
CTGColorSelect | Like a checkbutton but instead of the check mark there is color area with a little down arrow |
►CTGedSelect | Button that shows popup window when clicked |
CTGedMarkerSelect | Button showing selected marker and a little down arrow |
CTGedPatternSelect | Button with pattern area with a little down arrow |
CTGRadioButton | Selects different options |
CTGSplitButton | Implements a button with added menu functionality |
CTGuiBldHintsButton | Special button class used for editing layout hints in the ROOT GUI Builder |
CTGColorPalette | A widget showing an matrix of color cells |
CTGColorPick | A widget which allows a color to be picked from HLS color space |
►CTGComboBox | A combobox (also known as a drop down listbox) allows the selection of one item out of a list of items |
CTGFSComboBox | This is a combo box that is used in the File Selection dialog box |
CTGFontTypeComboBox | The TGFontTypeComboBox is user callable and it creates a combobox for selecting the font |
CTGLineStyleComboBox | The TGLineStyleComboBox user callable and it creates a combobox for selecting the line style |
CTGLineWidthComboBox | The TGLineWidthComboBox user callable and it creates a combobox for selecting the line width |
CTGDockableFrame | A frame with handles that allow it to be undocked (i.e |
►CTGDoubleSlider | DoubleSlider widgets allow easy selection of a min and a max value out of a range |
►CTGDoubleHSlider | Dragging the slider will generate the event: |
CTGTripleHSlider | TripleSlider inherit from DoubleSlider widgets and allow easy selection of a min, max and pointer value out of a range |
►CTGDoubleVSlider | Dragging the slider will generate the event: |
CTGTripleVSlider | TripleSlider inherit from DoubleSlider widgets and allow easy selection of a min, max and pointer value out of a range |
CTGListBox | A listbox is a box, possibly with scrollbar, containing entries |
►CTGMdiWinResizer | |
CTGMdiCornerWinResizer | |
CTGMdiHorizontalWinResizer | |
CTGMdiVerticalWinResizer | |
CTGNumberEntry | TGNumberEntry is a number entry input widget with up/down buttons |
►CTGScrollBar | The classes in this file implement scrollbars |
CTGHScrollBar | The TGHScrollBar will generate the following event messages: kC_HSCROLL, kSB_SLIDERPOS, position, 0 kC_HSCROLL, kSB_SLIDERTRACK, position, 0 |
CTGVScrollBar | The TGVScrollBar will generate the following event messages: kC_VSCROLL, kSB_SLIDERPOS, position, 0 kC_VSCROLL, kSB_SLIDERTRACK, position, 0 |
CTGShutterItem | |
►CTGSlider | Slider widgets allow easy selection of a range |
CTGHSlider | Concrete class for horizontal slider |
CTGVSlider | Concrete class for vertical slider |
CTGSpeedo | TGSpeedo is a widget looking like a speedometer, with a needle, a counter and a small odometer window |
CTGTab | A tab widget contains a set of composite frames each with a little tab with a name (like a set of folders with tabs) |
►CTGTable | Create an array to hold a bunch of numbers |
CTGSimpleTable | To provide a simple class to visualize an array of doubles, the class TGSimpleTable is provided |
CTGTreeTable | TGTreeTable is a TGTable that owns it's own interface |
►CTGTextEntry | A TGTextEntry is a one line text input widget |
CTGNumberEntryField | |
►CTGView | A TGView provides the infrastructure for text viewer and editor widgets |
CTGHtml | The ROOT HTML widget |
►CTGTextView | A TGTextView is a text viewer widget |
CTGTextEdit | A TGTextEdit is a specialization of TGTextView |
CTGTextViewostream | |
CTGeoPconSection | Utility frame used by TGeoPcon editor |
CTGWin32GL | The TGWin32GL is win32gdk implementation of TVirtualGLImp class |
CTGWin32GLManager::TGWin32GLImpl | |
►CTGWin32ProxyBase | Proxy classes provide thread-safe interface to global objects |
CTGWin32GLManagerProxy | |
CTGWin32VirtualXProxy | |
CTGWin32ProxyBasePrivate | |
CROOT::RDF::TH1DModel | A struct which stores the parameters of a TH1D |
CTH1Merger | |
CROOT::RDF::TH2DModel | A struct which stores the parameters of a TH2D |
CRgl::Mc::TH3Adapter< H, E > | |
CROOT::RDF::TH3DModel | A struct which stores the parameters of a TH3D |
CROOT::Internal::THashConsistencyHolder< T > | |
CTHistRange | |
CTHistRenderingRegion | |
CROOT::Internal::THnBaseBinIter | Iterator over THnBase bins (internal implementation) |
CROOT::RDF::THnDModel | A struct which stores the parameters of a THnD |
►CTHnSparseCoordCompression | THnSparseCoordCompression is a class used by THnSparse internally |
CTHnSparseCompactBinCoord | THnSparseCompactBinCoord is a class used by THnSparse internally |
CTGeoBoolNode::ThreadData_t | |
CTGeoPatternFinder::ThreadData_t | |
CTGeoPgon::ThreadData_t | |
CTGeoVolumeAssembly::ThreadData_t | |
CTGeoXtru::ThreadData_t | |
Cbvh::v2::ThreadPool | |
►CTHttpWSEngine | Internal instance used to exchange WS functionality between THttpServer and THttpWSHandler |
CTCivetwebWSEngine | TCivetwebWSEngine |
CTHttpLongPollEngine | Emulation of websocket with long poll requests |
CTIdleTOTimerGuard | |
CTStreamerInfoActions::TIDNode | |
CTimer | |
CTIndArray | |
►CROOT::Internal::TInitBehavior | |
►CROOT::Internal::TDefaultInitBehavior | |
CROOT::Internal::TQObjectInitBehavior | |
CTInspectorImp | ABC describing GUI independent object inspector (abstraction mainly needed for Win32 |
CTVirtualCollectionPtrIterators::TInternalIterator | |
►CTClassEdit::TInterpreterLookupHelper | |
CROOT::TMetaUtils::TClingLookupHelper | |
►CTInterpreterValue | |
CTClingValue | Bridge between cling::Value and ROOT |
CROOT::TIOFeatures | TIOFeatures provides the end-user with the ability to change the IO behavior of data written via a TTree |
CRgl::Mc::TIsoMesh< V > | |
CRgl::Mc::TIsoMesh< double > | |
CRgl::Mc::TIsoMesh< Float_t > | |
►CTIter | |
CTIterCategory< T > | |
CROOT::Detail::TKeyMapIterable::TIterator | |
►CTIterator | Iterator abstract base class |
CRooAbsCategoryLegacyIterator | |
CRooDataHistSliceIter | Iterates over all bins in a RooDataHist that occur in a slice defined by the bin coordinates of the input sliceSet |
CRooLinkedListIter | A wrapper around TIterator derivatives |
CRooLinkedListIterImpl | Implementation of the actual iterator on RooLinkedLists |
CTBtreeIter | Iterator of btree |
CTHashTableIter | Iterator of hash table |
CTIteratorToSTLInterface< STLContainer > | TIterator and GenericRooFIter front end with STL back end |
►CTListIter | Iterator of linked list |
CTListOfEnumsWithLockIter | Iterator for TListOfEnumsWithLock |
CTListOfFunctionsIter | Iterator for TListOfFunctions |
CTMapIter | Iterator of map |
CTObjArrayIter | Iterator of object array |
CTOrdCollectionIter | Iterator of ordered collection |
CTRefArrayIter | Iterator of object array |
CTTreeFriendLeafIter | Iterator on all the leaves in a TTree and its friend |
CTViewPubDataMembersIter | Iterator of over the view's content |
CTViewPubFunctionsIter | Iterator of over the view's content |
CTJoinHelper | |
CTKDEFGT | |
CTKDE::TKernel | |
CROOT::Detail::TKeyMapIterable | |
CROOT::Detail::TKeyMapNode | |
CTLatex::TLatexFormSize | TLatex helper class used to compute the size of a portion of a formula |
CTMVA::DNN::TLayer< Architecture_t > | Generic layer class |
CTLimit | Legacy Code TLimit is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TLimit might still be a valid solution. Consider switching to RooStats.Algorithm to compute 95% CL limits using the Likelihood ratio semi-bayesian method |
CTLockGuard | |
CTLockPathGuard | |
►CTStreamerInfoActions::TLoopConfiguration | Base class of the Configurations for the member wise looping routines |
CTStreamerInfoActions::TAssocLoopConfig | |
CTStreamerInfoActions::TGenericLoopConfig | |
CTStreamerInfoActions::TVectorLoopConfig | |
CTLorentzRotation::TLorentzRotationRow | |
CTMakeProject | |
CROOT::TMapDeclIdToTClass | |
CTMapRec | Keep track of an object in the mapped file |
CROOT::TMapTypeToClassRec | |
CROOT::TMapTypeToTClass | |
CTMatrixDEigen | TMatrixDEigen |
CTMatrixDSymEigen | TMatrixDSymEigen |
►CTMatrixTColumn_const< Element > | |
CTMatrixTColumn< Element > | |
CTMatrixTCramerInv | TMatrixTCramerInv |
►CTMatrixTDiag_const< Element > | |
CTMatrixTDiag< Element > | |
►CTMatrixTFlat_const< Element > | |
CTMatrixTFlat< Element > | |
►CTMatrixTRow_const< Element > | |
CTMatrixTRow< Element > | |
►CTMatrixTSparseDiag_const< Element > | |
CTMatrixTSparseDiag< Element > | |
►CTMatrixTSparseRow_const< Element > | |
CTMatrixTSparseRow< Element > | |
►CTMatrixTSub_const< Element > | |
CTMatrixTSub< Element > | |
CTMatrixTSymCramerInv | TMatrixTSymCramerInv |
CTMatrixTUtils | Matrix utility classes |
CTMD5 | This code implements the MD5 message-digest algorithm |
►CTMemberInspector | Abstract base class for accessing the data-members of a class |
CTAutoInspector | |
CTBuildRealData | |
CTDumpMembers | |
►CTMemberStreamer | |
CTCollectionMemberStreamer | Class streamer object to implement TMemberStreamer functionality for I/O emulation |
CTConvertClonesArrayToProxy | Small helper to read a TBuffer containing a TClonesArray into any valid collection |
CTConvertMapToProxy | |
CTMemFile::TMemBlock | |
CROOT::TModuleGenerator | |
►CTMPClient | Base class for multiprocess applications' clients |
CROOT::TProcessExecutor | This class provides a simple interface to execute the same task multiple times in parallel, possibly with different arguments every time |
CROOT::TTreeProcessorMP | This class provides an interface to process a TTree dataset in parallel with multi-process technology |
►CTMPWorker | This class works in conjuction with TMPClient, reacting to messages received from it as specified by the Notify and HandleInput methods |
CTMPWorkerExecutor< F, T, R > | This class works together with TProcessExecutor to allow the execution of functions in server processes |
CTMPWorkerExecutor< F, T, void > | |
CTMPWorkerExecutor< F, void, R > | |
►CTMPWorkerTree | This class works in conjunction with TTreeProcessorMP, reacting to messages received from it as specified by the Notify and HandleInput methods |
CTMPWorkerTreeFunc< F > | Templated derivation of TMPWorkerTree handlign generic function tree processing |
CTMPWorkerTreeSel | Templated derivation of TMPWorkerTree handlign selector tree processing |
CTMsgBox | A message dialog box |
CROOT::Internal::TMultiArrayType< T, d > | Helper class for proxy around multi dimension array |
CTMVA | Base Class for all classes that need option parsing |
CTMVA::TMVAGaussPair | |
CTMVA::TMVAGUI | |
CROOT::Internal::TNamedBranchProxy | |
CTNDArrayRef< T > | Gives access to a sub-dimension, e.g |
CTStreamerInfoActions::TNestedIDs | |
CTMVA::DNN::TNet< Architecture_t, Layer_t > | Generic neural network class |
►CTMVA::TNeuronInput | Interface for TNeuron input calculation classes |
CTMVA::TNeuronInputAbs | TNeuron input calculator – calculates the sum of the absolute values of the weighted inputs |
CTMVA::TNeuronInputSqSum | TNeuron input calculator – calculates the squared weighted sum of inputs |
CTMVA::TNeuronInputSum | TNeuron input calculator – calculates the weighted sum of inputs |
CTMVA::TNeuronInputChooser | Class for easily choosing neuron input functions |
CTNewCanvasPainterReg | |
►CTNonCopyable | |
CTThreadPool< aTask, aParam > | |
CROOT::TMetaUtils::TNormalizedCtxt | |
CROOT::TMetaUtils::TNormalizedCtxtImpl | |
CROOT::TNumSlots | Defines the number of threads in some of ROOT's interfaces |
►CTObject | Mother of all ROOT objects |
CTEveRecTrackT< Float_t > | |
CTMatrixTBase< Double_t > | |
CTMatrixTBase< AReal > | |
►CTParameter< Long64_t > | |
CTSelectorScalar | Named scalar type, based on Long64_t, streamable, storable and mergeable |
CTVectorT< Double_t > | |
CHit | |
CJet | |
CJetEvent | |
CRCaloTower | |
CROOT::Detail::TSchemaRuleSet | |
CROOT::Experimental::REveTrans | |
CROOT::Experimental::REveVSD | |
CROOT::Experimental::TTreeReaderFast | |
CROOT::Internal::TCheckHashRecursiveRemoveConsistency | |
CROOT::Internal::TTreeReaderDescriptor | |
CROOT::R::TRDataFrame | This is a class to create DataFrames from ROOT to R |
CROOT::R::TRFunctionExport | This is a class to pass functions from ROOT to R |
CROOT::R::TRFunctionImport | This is a class to pass functions from ROOT to R |
CROOT::R::TRInterface | ROOT R was implemented using the R Project library and the modules Rcpp and RInside |
CROOT::R::TRObject | This is a class to get ROOT's objects from R's objects |
CROOT::RBrowserDataCleanup | |
CROOT::TSchemaRule | |
CRecHit | |
CRooAbsCollection | Abstract container object that can hold multiple RooAbsArg objects |
CRooCFunction1Ref< VO, VI > | |
CRooCFunction2Ref< VO, VI1, VI2 > | |
CRooCFunction3Ref< VO, VI1, VI2, VI3 > | |
CRooCFunction4Ref< VO, VI1, VI2, VI3, VI4 > | |
CRooCatType | RooCatType is an auxiliary class for RooAbsCategory and defines a a single category state |
CRooCmdConfig | Configurable parser for RooCmdArg named arguments |
CRooExpensiveObjectCache | Singleton class that serves as repository for objects that are expensive to calculate |
CRooHelpers::WrapIntoTObject< T > | Wrap an object into a TObject. Sometimes needed to avoid reinterpret_cast or enable RTTI |
CRooLinkedList | Collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list |
CRooMinimizer | Wrapper class around ROOT::Math::Minimizer that provides a seamless interface between the minimizer functionality and the native RooFit interface |
CRooMsgService | Singleton class that organizes messages generated in RooFit |
CRooNumGenConfig | Holds the configuration parameters of the various numeric integrators used by RooRealIntegral |
CRooNumGenFactory | Factory to instantiate numeric integrators from a given function binding and a given configuration |
CRooNumIntConfig | Holds the configuration parameters of the various numeric integrators used by RooRealIntegral |
CRooNumIntFactory | Factory to instantiate numeric integrators from a given function binding and a given configuration |
►CRooSharedProperties | Class RooSharedProperties is the base class for shared properties that can be stored in RooSharedPropertiesList |
CRooRealVarSharedProperties | Implementation of RooSharedProperties that stores the properties of a RooRealVar that are shared among clones |
CRooStats::AcceptanceRegion | |
CRooStats::HistFactory::HistoToWorkspaceFactoryFast | This class provides helper functions for creating likelihood models from histograms |
CRooStats::MetropolisHastings | This class uses the Metropolis-Hastings algorithm to construct a Markov Chain of data points using Monte Carlo |
►CRooStats::ProposalFunction | ProposalFunction is an interface for all proposal functions that would be used with a Markov Chain Monte Carlo algorithm |
CRooStats::PdfProposal | PdfProposal is a concrete implementation of the ProposalFunction interface |
CRooStats::SequentialProposal | Class implementing a proposal function that samples the parameter space by moving only in one coordinate (chosen randomly) at each step |
CRooStats::UniformProposal | UniformProposal is a concrete implementation of the ProposalFunction interface for use with a Markov Chain Monte Carlo algorithm |
CRooStats::ProposalHelper | |
CRooStats::SamplingSummary | |
CRooStats::SamplingSummaryLookup | |
CRooWorkspace::CodeRepo | |
CTASPaletteEditor::PaintPalette | |
►CTApplication | This class creates the ROOT Application Environment that interfaces to the windowing system eventloop and eventhandlers |
CPyROOT::RPyROOTApplication | Interactive application for Python |
CTApplicationRemote | |
CTApplicationServer | |
CTGApplication | This class initialize the ROOT GUI toolkit |
►CTProofServ | Class providing the PROOF server |
CTProofServLite | Version of the PROOF worker server for local running |
CTRint | |
►CTArchiveFile | Class describing an archive file containing multiple sub-files, like a ZIP or TAR archive |
CTZIPFile | Describes a ZIP archive file containing multiple sub-files |
►CTArchiveMember | |
CTZIPMember | A ZIP archive consists of files compressed with the popular ZLIB compression algorithm; this class records the information about a single archive member |
CTAuthenticate | |
CTAxisModLab | TAxis helper class used to store the modified labels |
CTBinomialEfficiencyFitter | Binomial fitter for the division of two histograms |
CTBits | Container of bits |
CTBox | Create a Box |
►CTBuffer | Buffer base class used for serializing objects |
►CTBufferIO | Direct subclass of TBuffer, implements common methods for TBufferFile and TBufferText classes |
►CTBufferFile | The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket |
CTBufferSQL | Implement TBuffer for a SQL backend |
CTMessage | |
►CTBufferText | Base class for text-based streamers like TBufferJSON or TBufferXML Special actions list will use methods, introduced in this class |
CTBufferJSON | Class for serializing object to and from JavaScript Object Notation (JSON) format |
CTBufferSQL2 | Converts data to SQL statements or read data from SQL tables |
CTBufferXML | Class for serializing/deserializing object to/from xml |
►CTBuffer3D | Generic 3D primitive description class |
CTBuffer3DSphere | Sphere description class - see TBuffer3DTypes for producer classes Supports hollow and cut spheres |
►CTBuffer3DTube | Complete tube description class - see TBuffer3DTypes for producer classes |
►CTBuffer3DTubeSeg | Tube segment description class - see TBuffer3DTypes for producer classes |
CTBuffer3DCutTube | Cut tube segment description class - see TBuffer3DTypes for producer classes |
►CTClassGenerator | Objects following this interface can be passed onto the TROOT object to implement a user customized way to create the TClass objects |
CTPyClassGenerator | |
CTClassMenuItem | Describes one element of the context menu associated to a class The menu item may describe |
CTClassTable | This class registers for all classes their name, id and dictionary function in a hash table |
►CTCollection | Collection abstract base class |
►CTHashTable | THashTable implements a hash table to store TObject's |
CTListOfTypes | A collection of TDataType designed to hold the typedef information and numerical type information |
CTMap | TMap implements an associative array of (key,value) pairs using a THashTable for efficient retrieval (therefore TMap does not conserve the order of the entries) |
►CTSeqCollection | Sequenceable collection abstract base class |
CTBtree | B-tree class |
►CTList | A doubly linked list |
CTGTextEditHist | |
CTGridJobStatusList | |
CTGridResult | |
►CTHashList | THashList implements a hybrid collection class consisting of a hash table and a list to store TObject's |
CTListOfDataMembers | A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of TDataMember that were described unloaded data member |
►CTListOfEnums | A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum that were described unloaded enum |
CTListOfEnumsWithLock | A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum that were described unloaded enum |
CTListOfFunctionTemplates | A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFunction that were described unloaded function |
CTListOfFunctions | A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFunction that were described unloaded function |
CTSelectorList | A TList derived class that makes sure that objects added to it are not linked to the currently open file (like histograms, eventlists and trees) |
CTParallelCoordSelect | A TParallelCoordSelect is a specialised TList to hold TParallelCoordRanges used by TParallelCoord |
CTProofOutputList | Derivation of TList with an overload of ls() and Print() allowing to filter out some of the variables |
►CTQCommand | The Command design pattern is based on the idea, that all editing in an application is done by creating instances of command objects |
CTQUndoManager | Recorder of operations for undo and redo |
CTQConnectionList | TQConnectionList is the named list of connections, see also TQConnection class |
CTRootBrowserHistory | |
CTRootIconList | |
CTSortedList | A sorted doubly linked list |
CTViewPubDataMembers | View implementing the TList interface and giving access all the TDictionary describing public data members in a class and all its base classes without caching any of the TDictionary pointers |
CTViewPubFunctions | View implementing the TList interface and giving access all the TFunction describing public methods in a class and all its base classes without caching any of the TFunction pointers |
►CTVirtualQConnection | Mediates the link between the signal and the slot |
CTQConnection | TQConnection class is an internal class, used in the object communication mechanism |
►CTObjArray | An array of TObjects |
CRooRefArray | |
CTClonesArray | An array of clone (identical) objects |
CTGeoNavigatorArray | |
CTOrdCollection | Ordered collection |
CTRefArray | An array of references to TObjects |
CTCondition | |
►CTConditionImp | |
CTPosixCondition | |
CTWin32Condition | |
CTCondor | |
CTCondorSlave | |
CTConfidenceLevel | Class to compute 95% CL limits |
CTDNDData | Drag and drop data container |
►CTDataSetManager | |
CTDataSetManagerFile | |
CTDecayChannel | Description of the decay channel |
►CTDecompBase | Decomposition Base class |
CTDecompBK | The Bunch-Kaufman diagonal pivoting method decomposes a real symmetric matrix A using |
CTDecompChol | Cholesky Decomposition class |
CTDecompLU | LU Decomposition class |
CTDecompQRH | QR Decomposition class |
CTDecompSVD | Single Value Decomposition class |
CTDecompSparse | Sparse Symmetric Decomposition class |
CTDictAttributeMap | The ROOT object has a list of properties which are stored and retrieved using TDictAttributeMap |
CTDimensionInfo | A small helper class to help in keeping track of the array dimensions encountered in the analysis of the expression |
CTDrawFeedback | Utility class to draw objects in the feedback list during queries |
CTEllipse | Draw Ellipses |
CTEntryListBlock | Used by TEntryList to store the entry numbers |
CTEnv | Reads config files, by default named .rootrc |
CTEnvRec | |
CTEveCluster | |
CTEveFrameBox | Description of a 2D or 3D frame that can be used to visually group a set of objects |
CTEveGeoNode | Wrapper for TGeoNode that allows it to be shown in GUI and controlled as a TEveElement |
CTEveGridStepper | Provide discrete position coordinates for placement of objects on regular grids |
CTEveHit | |
CTEveMCRecCrossRef | |
CTEveRGBAPalette | A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes |
CTEveRecCascade | |
CTEveRecKink | |
CTEveRecTrackT< TT > | |
CTEveRecV0 | |
CTEveTrans | TEveTrans is a 4x4 transformation matrix for homogeneous coordinates stored internally in a column-major order to allow direct usage by GL |
CTEveVSD | Visualization Summary Data - a collection of trees holding standard event data in experiment independent format |
►CTEventIter | Special iterator class used in TProofPlayer to iterate over events or objects in the packets |
CTEventIterObj | |
CTEventIterTree | |
CTEventIterUnit | |
CTExMap | This class stores a (key,value) pair using an external hash |
►CTF1AbsComposition | |
CTF1Convolution | Class wrapping convolution of two functions |
CTF1NormSum | Class adding two functions: c1*f1+c2*f2 |
CTFPBlock | This class represents the encapsulation of a block request |
CTFTP | |
CTFeldmanCousins | Legacy Code TFeldmanCousins is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TFeldmanCousins might still be a valid solution. Consider switching to RooStats for non-trivial cases. |
►CTFileCacheRead | A cache when reading files over the network |
►CTTreeCache | A cache to speed-up the reading of ROOT datasets |
CTTreeCacheUnzip | A TTreeCache which exploits parallelized decompression of its own content |
CTFileCacheWrite | A cache when writing files over the network |
CTFileMerger | This class provides file copy and merging services |
CTFilePrefetch | The prefetching mechanism uses two classes (TFilePrefetch and TFPBlock) to prefetch in advance a block of tree entries |
CTFoam | TFoam is the main class of the multi-dimensional general purpose Monte Carlo event generator (integrator) FOAM |
CTFoamCell | Used by TFoam |
►CTFoamIntegrand | Abstract class representing n-dimensional real positive integrand function |
CFoamDistribution | |
CFoamIntegrandFunction | |
CTFoamMaxwt | Small auxiliary class for controlling MC weight |
CTFoamVect | Auxiliary class TFoamVect of n-dimensional vector, with dynamic allocation used for the cartesian geometry of the TFoam cells |
►CTFormLeafInfo | This class is a small helper class to implement reading a data member on an object stored in a TTree |
CTFormLeafInfoCast | A small helper class to implement casting an object to a different type (equivalent to dynamic_cast) |
CTFormLeafInfoClones | A small helper class to implement reading a data member on a TClonesArray object stored in a TTree |
CTFormLeafInfoCollection | A small helper class to implement reading a data member on a generic collection object stored in a TTree |
CTFormLeafInfoCollectionObject | A small helper class to implement reading a data member on a TClonesArray object stored in a TTree |
CTFormLeafInfoCollectionSize | Used to return the size of a collection |
CTFormLeafInfoDirect | A small helper class to implement reading a data member on an object stored in a TTree |
CTFormLeafInfoMethod | Asmall helper class to implement executing a method of an object stored in a TTree |
►CTFormLeafInfoMultiVarDim | A helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree |
CTFormLeafInfoMultiVarDimClones | A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree |
CTFormLeafInfoMultiVarDimCollection | A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree |
CTFormLeafInfoMultiVarDimDirect | A small helper class to implement reading a data member on a variable size array inside a TClonesArray object stored in a TTree |
CTFormLeafInfoNumerical | A small helper class to implement reading a numerical value inside a collection |
CTFormLeafInfoPointer | A small helper class to implement reading a data member by following a pointer inside a branch of TTree |
CTFormLeafInfoReference | A small helper class to implement the following of reference objects stored in a TTree |
CTFormLeafInfoTTree | A small helper class to implement reading from the containing TTree object itself |
CTFractionFitter | Fits MC fractions to data histogram |
CTFree | Service class for TFile |
CTGClient | Window client |
CTGDMLParse | This class contains the implementation of the GDML parser associated to all the supported GDML elements |
CTGDMLRefl | This class is a helper class for TGDMLParse |
CTGDMLWrite | This class contains implementation of converting ROOT's gGeoManager geometry to GDML file |
CTGDNDManager | |
►CTGFrameElement | |
CTGFSFrameElement | |
CTGFrameElementPack | |
CTGLBFrameElement | |
CTGGC | Encapsulate a graphics context used in the low level graphics |
►CTGHtmlElement | |
CTGHtmlBlock | |
►CTGHtmlMarkupElement | |
CTGHtmlAnchor | |
CTGHtmlCell | |
CTGHtmlForm | |
CTGHtmlHr | |
CTGHtmlImageMarkup | |
CTGHtmlInput | |
CTGHtmlLi | |
CTGHtmlListStart | |
CTGHtmlMapArea | |
CTGHtmlRef | |
CTGHtmlScript | |
CTGHtmlTable | |
CTGHtmlSpaceElement | |
CTGHtmlTextElement | |
CTGHtmlImage | |
CTGHtmlLayoutContext | |
CTGHtmlUri | |
CTGIdleHandler | Handle idle events, i.e |
CTGItemContext | Empty object used as context menu support for TGLVTreeEntries |
CTGLAutoRotator | Automatically rotates GL camera |
►CTGLCamera | Abstract base camera class - concrete classes for orthographic and perspective cameras derive from it |
CTGLOrthoCamera | Orthographic projection camera |
CTGLPerspectiveCamera | Perspective projection camera - with characteristic foreshortening |
CTGLLightSet | Encapsulates a set of lights for OpenGL |
CTGLPShapeObj | Wrap TGLPysicalShape into TObject so that it can be edited using GED |
►CTGLayoutHints | This class describes layout hints used by the layout classes |
CTGTableLayoutHints | This class describes layout hints used by the TGTableLayout class |
CTGXYLayoutHints | This layout hint must be used for the TGXYLayout manager! |
►CTGLayoutManager | Frame layout manager |
CTGMatrixLayout | This layout managers does not make use of TGLayoutHints |
CTGNumberEntryLayout | |
CTGTabLayout | Service classes of the tab widget |
CTGTableLayout | A layout manager, which places child frames in a table arranged in rows and columns, making it easy to align many widgets next each to other horizontally and vertically |
►CTGTileLayout | This is a layout manager for the TGListView widget |
CTGListDetailsLayout | This is a layout manager for the TGListView widget |
CTGListLayout | This is a layout manager for the TGListView widget |
►CTGVerticalLayout | |
CTGHorizontalLayout | |
►CTGRowLayout | The following two layout managers do not make use of TGLayoutHints |
CTGColumnLayout | The following layout manager do not make use of TGLayoutHints |
CTGXYLayout | Is a layout manager where the position and the size of each widget in the frame are defined by X / Y - coordinates |
CTGMainFrame::TGMapKey | |
CTGMenuEntry | This class contains all information about a menu entry |
CTGMime | TGMime is internally used by TGMimeTypes |
CTGMimeTypes | This class handles mime types, used by browsers to map file types to applications and icons |
►CTGObject | This class is the baseclass for all ROOT GUI widgets |
CTGFontPool | Provides a pool of fonts |
CTGGCPool | |
CTGResourcePool | This class implements a pool for the default GUI resource set, like GC's, colors, fonts, etc |
►CTGWindow | ROOT GUI Window base class |
►CTGFrame | A subclasses of TGWindow, and is used as base class for some simple widgets (buttons, labels, etc.) |
CTGAroundFrame | |
CTGButton | A button abstract base class |
►CTGCanvas | A frame containing two scrollbars (a horizontal and a vertical) and a viewport |
CTGListView | A list view is a widget that can contain a number of items arranged in a grid or list |
CTGMdiMainFrame | This file contains the TGMdiMainFrame class |
CTRootEmbeddedCanvas | This class creates a TGCanvas in which a TCanvas is created |
CTGColorFrame | A small frame with border showing a specific color |
CTGColorPalette | A widget showing an matrix of color cells |
CTGColorPick | A widget which allows a color to be picked from HLS color space |
►CTGCompositeFrame | The base class for composite widgets (menu bars, list boxes, etc.) |
CTEditQueryFrame | |
►CTEveCompositeFrame | Abstract base-class for frame-slots that encompass EVE-windows (sub-classes of TEveWindow) |
CTEveCompositeFrameInMainFrame | An EVE window-slot contained within a TGMainFrame |
CTEveCompositeFrameInPack | An EVE window-slot contained within one frame of a TGPack |
CTEveCompositeFrameInTab | An EVE window-slot contained within one tab of a TGTab |
CTEveGTriVecValuator | Composite GUI element for setting three numerical values (label, three number-entries) |
CTEveGValuatorBase | Base class for composite GUI elements for setting of numeric values |
CTG16ColorSelector | A composite frame with 16 TGColorFrames |
CTGColorPopup | A popup containing a TG16ColorSelector and a "More..." button which popups up a TGColorDialog allowing custom color selection |
CTGComboBox | A combobox (also known as a drop down listbox) allows the selection of one item out of a list of items |
CTGComboBoxPopup | A service class of the combobox |
►CTGContainer | Manages a content area |
CTGLBContainer | A Composite frame that contains a list of TGLBEnties |
►CTGLVContainer | |
►CTGFileContainer | |
CTRootIconBox | |
CTTVLVContainer | This class represent the list view container for the TreeView class |
CTGListTree | A list tree is a widget that can contain a number of items arranged in a tree structure |
CTGDockableFrame | A frame with handles that allow it to be undocked (i.e |
►CTGGroupFrame | A composite frame with a border and a title |
►CTGButtonGroup | Organizes TGButton widgets in a group |
CTGHButtonGroup | Organizes TGButton widgets in a group with one horizontal row |
CTGVButtonGroup | Organizes TGButton widgets in a group with one vertical column |
►CTGHorizontalFrame | A composite frame that layout their children in horizontal way |
CTGHeaderFrame | Horizontal Frame used to contain header buttons and splitters in a list view |
CTGMenuBar | The TGMenu.h header contains all different menu classes |
CTGStatusBar | Provides a StatusBar widget |
CTGStatusBarPart | |
CTGListBox | A listbox is a box, possibly with scrollbar, containing entries |
►CTGMainFrame | Defines top level windows that interact with the system Window Manager |
CTASPaletteEditor | This is a GUI window to edit a color palette |
CTEveGListTreeEditorFrame | Composite GUI frame for parallel display of a TGListTree and TEveGedEditor |
CTFitEditor | Allows to perform, explore and compare various fits |
CTGCommandPlugin | Class used to redirect the command line input/output |
CTGFileBrowser | System file browser, used as TRootBrowser plug-in |
CTGHtmlBrowser | A very simple HTML browser |
CTGLSAFrame | Standalone GL Viewer GUI main frame |
CTGRecorder | Provides GUI for TRecorder class |
CTGTextEditor | A simple text editor that uses the TGTextEdit widget |
►CTGTransientFrame | Defines transient windows that typically are used for dialogs windows |
CTAdvancedGraphicsDialog | Allows to create advanced graphics from the last fit made in the fitpanel |
CTFitParametersDialog | Create a dialog for fit function parameter settings |
CTFunctionParametersDialog | This class is used for function parameter settings |
CTGColorDialog | A full featured color selection dialog |
CTGFileDialog | This class creates a file selection dialog |
CTGFontDialog | Font selection dialog, allowing to select one in the list of available fonts in the system |
CTGGotoDialog | |
CTGInputDialog | Input Dialog Widget |
CTGMsgBox | |
CTGPrintDialog | |
CTGSearchDialog | |
CTGSelectBox | This class represent a specialized expression editor for TTVLVEntry 'true name' and 'alias' data members |
CTGUndockedFrame | |
►CTGeoTreeDialog | |
CTGeoMaterialDialog | |
CTGeoMatrixDialog | |
CTGeoMediumDialog | |
CTGeoShapeDialog | |
CTGeoVolumeDialog | |
CTGuiBldMenuDialog | |
CTNewChainDlg | |
CTNewQueryDlg | |
CTProofProgressLog | Dialog used to display Proof session logs from the Proof progress dialog |
CTProofProgressMemoryPlot | This class implements a dialog, used to display the memory footprint on the proof workers and master |
CTRootDialog | A TRootDialog is used to prompt for the arguments of an object's member function |
CTRootHelpDialog | A TRootHelpDialog is used to display help text (or any text in a dialog window) |
CTSessionLogView | Dialog used to display session logs from the session viewer |
CTStyleDialog | This small class is useful to ask the user for a name and a title, in order to rename a style, create a new style or import a style from a canvas |
CTStylePreview | This class may be used to preview the result of applying a style to a canvas |
CTTreeInput | Tree Input Dialog Widget |
CTUploadDataSetDlg | |
►CTGedEditor | |
CTEveGedEditor | Specialization of TGedEditor for proper update propagation to TEveManager |
CTGeoTransientPanel | |
CTGuiBldSaveFrame | |
CTRootBrowser | This class creates a ROOT object browser, constituted by three main tabs |
CTRootBrowserLite | This class creates a ROOT object browser (looking like Windows Explorer) |
CTRootCanvas | This class creates a main window with menubar, scrollbars and a drawing area |
CTRootControlBar | This class provides an interface to the GUI dependent functions of the TControlBar class |
CTRootGuiBuilder | |
CTSessionViewer | Widget used to manage PROOF or local sessions, PROOF connections, queries construction and results handling |
CTStructViewerGUI | |
CTStyleManager | This class provides a Graphical User Interface to manage styles in ROOT |
CTTreeViewer | A graphic user interface designed to handle ROOT trees and to take advantage of TTree class features |
CTGMdiButtons | |
CTGMdiDecorFrame | This file contains all different MDI frame decoration classes |
CTGMdiFrame | This file contains the TGMdiFrame class |
CTGMdiMenuBar | |
CTGMdiTitleBar | |
CTGNumberEntry | TGNumberEntry is a number entry input widget with up/down buttons |
CTGPack | Stack of frames in horizontal (default) or vertical stack |
CTGShapedFrame | A Shaped window |
CTGShutter | A shutter widget contains a set of shutter items that can be open and closed like a shutter |
CTGSplitFrame | A split frame |
CTGSplitTool | A split frame tool tip |
CTGTab | A tab widget contains a set of composite frames each with a little tab with a name (like a set of folders with tabs) |
CTGTable | Create an array to hold a bunch of numbers |
CTGTableHeaderFrame | TGTableHeaderFrame implements a frame used to display TGTableHeaders in a TGTable |
CTGToolBar | A toolbar is a composite frame that contains TGPictureButtons |
CTGToolTip | A tooltip can be a one or multiple lines help text that is displayed in a window when the mouse cursor overs a widget, without clicking it |
►CTGVerticalFrame | A composite frame that layout their children in vertical way |
CTEveGridStepperSubEditor | Sub-editor for TEveGridStepper class |
CTEveRGBAPaletteSubEditor | Sub-editor for TEveRGBAPalette class |
CTEveTrackPropagatorSubEditor | Sub-editor for TEveTrackPropagator class |
CTEveTransSubEditor | Sub-editor for TEveTrans class |
CTGLClipSetSubEditor | GUI sub-editor for TGLClipSet |
CTGLLightSetSubEditor | Sub-editor for TGLLightSet |
CTGShutterItem | |
CTGuiBldBorderFrame | |
CTGuiBldEditor | The property editor |
CTGuiBldGeometryFrame | |
CTGuiBldHintsEditor | Editor of widget's layout hints used by the ROOT GUI builder |
CTGuiBldHintsManager | |
CTGView | A TGView provides the infrastructure for text viewer and editor widgets |
CTGViewFrame | |
CTGViewPort | |
►CTGedFrame | Base frame for implementing GUI - a service class |
CTArrowEditor | Implements user interface for editing of arrow attributes: shape, size, angle |
CTAttFillEditor | Implements GUI for editing fill attributes |
CTAttLineEditor | Implements GUI for editing line attributes |
CTAttMarkerEditor | Implements GUI for editing marker attributes |
CTAttTextEditor | Implements GUI for editing text attributes |
CTAxisEditor | Implements GUI for axis attributes |
CTCurlyArcEditor | Implements GUI for editing CurlyArc attributes: radius, phi1, phi2 |
CTCurlyLineEditor | Implements GUI for editing CurlyLine attributes: shape, size, angle |
CTEveArrowEditor | GUI editor for TEveArrow |
CTEveCalo3DEditor | GUI editor for TEveCalo3D |
CTEveCaloLegoEditor | GUI editor for TEveCaloLego |
CTEveCaloVizEditor | GUI editor for TEveCaloEditor |
CTEveDigitSetEditor | Editor for TEveDigitSet class |
CTEveElementEditor | Editor for TEveElement class |
CTEveGedNameFrame | Specialization of TGedNameFrame used in EVE |
CTEveGeoNodeEditor | Editor for TEveGeoNode class |
CTEveGeoTopNodeEditor | Editor for TEveGeoTopNode class |
CTEveGridStepperEditor | Editor for TEveGridStepper class |
CTEveJetConeEditor | GUI editor for TEveJetCone |
CTEveLineEditor | Editor for TEveLine class |
CTEveParamListEditor | GUI editor for TEveParamList |
CTEvePointSetArrayEditor | Editor for TEvePointSetArray class |
CTEveProjectionAxesEditor | GUI editor for TEveProjectionAxes |
CTEveProjectionManagerEditor | GUI editor for TEveProjectionManager class |
CTEveRGBAPaletteEditor | Editor for TEveRGBAPalette class |
CTEveShapeEditor | GUI editor for TEveShape |
CTEveStraightLineSetEditor | Editor for TEveStraightLineSet class |
CTEveTextEditor | GUI editor for TEveText |
CTEveTrackEditor | Editor for TEveTrack class |
CTEveTrackListEditor | Editor for TEveTrackList class |
CTEveTrackPropagatorEditor | GUI editor for TEveTrackPropagator |
CTEveTransEditor | Editor for TEveTrans class |
CTEveTriangleSetEditor | Editor for TEveTriangleSet class |
CTEveViewerListEditor | GUI editor for TEveViewerList |
CTEveWindowEditor | GUI editor for TEveWindow |
CTF1Editor | GUI for TF1 attributes and parameters |
CTFrameEditor | Editor of frame objects |
CTGL5DDataSetEditor | GUI editor for OpenGL 5D Painter |
CTGLClipSetEditor | GUI editor for TGLClipSet |
CTGLLightSetEditor | |
CTGLPShapeObjEditor | GUI editor for TGLPShapeObj |
CTGLViewerEditor | GUI editor for TGLViewer |
CTGedNameFrame | |
►CTGeoGedFrame | Common base class for geombuilder editors |
CTGeoBBoxEditor | Editor for a TGeoBBox |
CTGeoCombiTransEditor | Editor for a TGeoCombiTrans |
►CTGeoConeEditor | Editor for a TGeoCone |
CTGeoConeSegEditor | Editor for a cone segment |
CTGeoEltuEditor | Editor for a TGeoEltu |
CTGeoHypeEditor | Editor for a TGeoHype |
►CTGeoMaterialEditor | Editors for materials |
CTGeoMixtureEditor | Editors for mixtures |
CTGeoMediumEditor | Editor class for TGeo tracking media |
CTGeoNodeEditor | Editor class for TGeoNode objects |
CTGeoParaEditor | Editor for a TGeoPara |
►CTGeoPconEditor | Editor for a TGeoPcon |
CTGeoPgonEditor | Editor for a TGeoPgon |
CTGeoRotationEditor | Editor for a TGeoRotation |
CTGeoSphereEditor | Editor for a TGeoSphere |
CTGeoTorusEditor | Editor for a TGeoTorus |
CTGeoTranslationEditor | Editor for a TGeoTranslation |
►CTGeoTrapEditor | Editor for a TGeoTrap |
CTGeoGtraEditor | Editor for a TGeoGtra |
CTGeoTrd1Editor | Editor for a TGeoTrd1 |
CTGeoTrd2Editor | Editor for a TGeoTrd2 |
►CTGeoTubeEditor | Editor for a TGeoTube |
►CTGeoTubeSegEditor | Editor for a TGeoTubeSeg |
CTGeoCtubEditor | Editor for a TGeoCtub |
CTGeoVolumeEditor | Editor for geometry volumes and assemblies of volumes |
CTGeoManagerEditor | Editor for TGeoManager class |
CTGraphEditor | Implements GUI for graph attributes |
CTH1Editor | Editor for changing TH1 histogram attributes, rebinning & fitting |
CTH2Editor | Editor for changing TH2 histogram attributes, rebinning & fitting |
CTLineEditor | Implements GUI for editing line attributes: shape, size, angle |
CTPadEditor | Editor of pad/canvas objects |
CTParallelCoordEditor | This is the TParallelCoord editor |
CTPaveStatsEditor | Implements GUI for editing attributes of TPaveStats objects |
CTPieEditor | Implements GUI for pie-chart attributes |
CTPieSliceEditor | Editor for changing pie-chart's slice attributes |
CTSpiderEditor | The TSpider editor class |
CTStructNodeEditor | |
CTTextEditor | Editor for changing TText's and TLatex's attributes |
CTGedPatternSelector | The TGedPatternSelector is a composite frame with TGedPatternFrames of all diferent styles |
►CTGedPopup | Popup window |
CTGedMarkerPopup | The TGedMarkerPopup is a popup containing buttons to select marker style |
CTGedPatternPopup | The TGedPatternPopup is a popup containing a TGedPatternSelector |
CTGeoPconSection | Utility frame used by TGeoPcon editor |
CTGuiBldNameFrame | |
CTRootContainer | |
CTRootEmbeddedContainer | Utility class used by TRootEmbeddedCanvas |
CTSessionFrame | |
CTSessionInputFrame | |
CTSessionOutputFrame | |
CTSessionQueryFrame | |
CTSessionServerFrame | |
CTGCursorWindow | |
CTGDoubleSlider | DoubleSlider widgets allow easy selection of a min and a max value out of a range |
CTGDragWindow | Window used as drag icon during drag and drop operations |
CTGGrabRect | |
CTGHorizontal3DLine | A horizontal 3D line is a line that typically separates a toolbar from the menubar |
►CTGIcon | This class handles GUI icons |
CTGFileIcon | Utility class used by the file selection dialog (TGFSDialog) |
CTGMdiTitleIcon | |
►CTGLBEntry | Basic listbox entries |
►CTGTextLBEntry | Text string listbox entries |
CTGHtmlLBEntry | |
CTGIconLBEntry | Icon + text listbox entry |
CTGLineLBEntry | Line style and width listbox entries |
CTGTreeLBEntry | |
►CTGLVEntry | |
►CTGFileItem | |
CTRootObjItem | |
CTTVLVEntry | This class represent entries that goes into the TreeViewer listview container |
CTGLWidget | GL window with context |
CTGLabel | This class handles GUI labels |
CTGMdiContainer | |
CTGMdiWinResizer | |
►CTGMenuTitle | This class creates a menu title |
CTGuiBldMenuTitle | |
►CTGPopupMenu | This class creates a popup menu object |
CTGuiBldPopupMenu | |
CTRootContextMenu | This class provides an interface to context sensitive popup menus |
►CTGProgressBar | The classes in this file implement progress bars |
CTGHProgressBar | |
CTGVProgressBar | |
CTGScrollBar | The classes in this file implement scrollbars |
CTGScrollBarElement | |
CTGSlider | Slider widgets allow easy selection of a range |
CTGSpeedo | TGSpeedo is a widget looking like a speedometer, with a needle, a counter and a small odometer window |
►CTGSplitter | A splitter allows the frames left and right or above and below of it to be resized |
CTGHSplitter | |
►CTGVSplitter | |
CTGVFileSplitter | |
CTGTabElement | Service classes of the tab widget |
►CTGTableCell | TGTableCell is the class that represents a single cell in a TGTable |
CTGTableHeader | TGTableHeader is the class that implements a header for a row or column |
CTGTextEntry | A TGTextEntry is a one line text input widget |
CTGVertical3DLine | A vertical 3D line is a line that can be used to separate groups of widgets |
CTGedPatternFrame | The TGedPatternFrame is a small frame with border showing a specific pattern (fill style |
CTGuiBldDragManager | Drag and drop manager used by the ROOT GUI Builder |
►CTGPicture | Implements pictures and icons used in the different GUI elements and widgets |
CTGSelectedPicture | |
CTGPicturePool | |
CTGRectMap | |
►CTGRegion | |
CTGRegionWithId | |
►CTGTextEditCommand | |
CTBreakLineCom | |
CTDelCharCom | |
CTDelTextCom | |
CTInsCharCom | |
CTInsTextCom | |
CTGTextLayout | Is used to keep track of string measurement information when using the text layout facilities |
CTGUnknownWindowHandler | Handle events for windows that are not part of the native ROOT GUI |
CTGWin32CallBackObject | |
CTGedFrame::TGedSubFrame | |
CTGedTabInfo | |
CTGenPhaseSpace | Legacy Code TGenPhaseSpace is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TGenPhaseSpace might still be a valid solution. No alternative classes are currently available. |
CTGeoBatemanSol | |
►CTGeoBoolNode | Base class for Boolean operations between two shapes |
CTGeoIntersection | |
CTGeoSubtraction | |
CTGeoUnion | |
CTGeoBranchArray | An array of daughter indices making a geometry path |
CTGeoBuilder | Utility class for creating geometry objects.These will be associated with the current selected geometry manager object: |
CTGeoCacheState | Class storing the state of the cache at a given moment |
CTGeoChecker | Geometry checking package |
CTGeoDecayChannel | A decay channel for a radionuclide |
CTGeoElementTable | Table of elements |
►CTGeoExtension | ABC for user objects attached to TGeoVolume or TGeoNode |
CTGeoRCExtension | Reference counted extension which has a pointer to and owns a user defined TObject |
CTGeoGlobalMagField | Global magnetic field manager |
CTGeoHelix | Class representing a helix curve |
►CTGeoIteratorPlugin | |
Citerplugin | |
CTGeoNavigator | Class providing navigation API for TGeo geometries |
CTGeoNodeCache | Special pool of reusable nodes |
►CTGeoPatternFinder | Base finder class for patterns |
CTGeoPatternCylPhi | |
CTGeoPatternCylR | |
CTGeoPatternHoneycomb | |
CTGeoPatternParaX | |
CTGeoPatternParaY | |
CTGeoPatternParaZ | |
CTGeoPatternSphPhi | |
CTGeoPatternSphR | |
CTGeoPatternSphTheta | |
CTGeoPatternTrapZ | |
CTGeoPatternX | |
CTGeoPatternY | |
CTGeoPatternZ | |
CTGeoPolygon | An arbitrary polygon defined by vertices |
CTGeoTabManager | Manager for all editor tabs |
CTGeoVoxelFinder | Finder class handling voxels |
CTGraph2DPainter | The TGraphDelaunay painting class |
CTGraphEdge | An edge object connecting two nodes which can be added in a TGraphStruct |
CTGraphStruct | The Graph Structure is an interface to the graphviz package |
CTGrid | |
CTGridCollection | |
CTGridJDL | |
CTGridJob | |
►CTH2PolyBin | Helper class to represent a bin in the TH2Poly histogram |
CTProfile2PolyBin | Helper class to represent a bin in the TProfile2Poly histogram |
►CTHLimitsFinder | Class to compute nice axis limits |
CTProofLimitsFinder | Class to find axis limits and synchronize them between workers |
CTHnChain | A class to chain together multiple histograms |
CTHnIter | Iterator over THnBase bins |
CTHnSparseArrayChunk | THnSparseArrayChunk is used internally by THnSparse |
CTHostAuth | |
►CTHttpCallArg | Contains arguments for single HTTP call |
CTFastCgiCallArg | |
CTIconBoxThumb | |
►CTImagePalette | A class to define a conversion from pixel values to pixel color |
CTDefHistImagePalette | |
CTWebPalette | |
►CTImagePlugin | |
►CTASImagePlugin | |
CTASPluginGS | Allows to read PS/EPS/PDF files via GhostScript |
CTInetAddress | This class represents an Internet Protocol (IP) address |
CTInspectorObject | This class is designed to wrap a Foreign object in order to inject it into the Browse sub-system |
CTJSONStackObj | |
CTKDTree< Index, Value > | Class implementing a kd-tree |
CTKDTreeBinning | <- TKDTreeBinning - A class providing multidimensional binning -> |
CTLegendEntry | Storage class for one entry of a TLegend |
CTLimitDataSource | This class serves as input for the TLimit::ComputeLimit method |
CTLine | Use the TLine constructor to create a simple line |
CTLockFile | A scoped lock based on files |
CTLockPath | Path locking class allowing shared and exclusive locks |
CTLorentzRotation | Legacy Code TLorentzRotation is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TLorentzRotation might still be a valid solution. Consider using instead ROOT::Math::LorentzRotation.The TLorentzRotation class describes Lorentz transformations including Lorentz boosts and rotations (see TRotation) |
CTLorentzVector | |
CTMLPAnalyzer | This utility class contains a set of tests useful when developing a neural network |
CTMVA::DataInputHandler | Class that contains all the data information |
CTMVA::DataSetFactory | Class that contains all the data information |
CTMVA::DataSetInfo | Class that contains all the data information |
CTMVA::DataSetManager | Class that contains all the data information |
CTMVA::Event | |
CTMVA::Experimental::ClassificationResult | |
CTMVA::MsgLogger | Ostringstream derivative to redirect and format output |
►CTMVA::OptionBase | Class for TMVA-option handling |
►CTMVA::Option< T > | |
CTMVA::Option< T * > | |
►CTMVA::PDEFoam | Implementation of PDEFoam |
►CTMVA::PDEFoamDiscriminant | This PDEFoam variant stores in every cell the discriminant |
CTMVA::PDEFoamDecisionTree | This PDEFoam variant acts like a decision tree and stores in every cell the discriminant |
►CTMVA::PDEFoamEvent | This PDEFoam variant stores in every cell the sum of event weights and the sum of the squared event weights |
CTMVA::PDEFoamMultiTarget | This PDEFoam variant is used to estimate multiple targets by creating an event density foam (PDEFoamEvent), which has dimension: |
CTMVA::PDEFoamTarget | This PDEFoam variant stores in every cell the average target fTarget (see the Constructor) as well as the statistical error on the target fTarget |
CTMVA::PDEFoamCell | |
►CTMVA::PDEFoamDensityBase | This is an abstract class, which provides an interface for a PDEFoam density estimator |
CTMVA::PDEFoamDecisionTreeDensity | This is a concrete implementation of PDEFoam |
CTMVA::PDEFoamDiscriminantDensity | This is a concrete implementation of PDEFoam |
CTMVA::PDEFoamEventDensity | This is a concrete implementation of PDEFoam |
CTMVA::PDEFoamTargetDensity | This is a concrete implementation of PDEFoam |
►CTMVA::PDEFoamKernelBase | This class is the abstract kernel interface for PDEFoam |
CTMVA::PDEFoamKernelGauss | This PDEFoam kernel estimates a cell value for a given event by weighting all cell values with a gauss function |
CTMVA::PDEFoamKernelLinN | This PDEFoam kernel estimates a cell value for a given event by weighting with cell values of the nearest neighbor cells |
CTMVA::PDEFoamKernelTrivial | This class is a trivial PDEFoam kernel estimator |
CTMVA::PDEFoamVect | |
►CTMVA::Results | Class that is the base-class for a vector of result |
CTMVA::ResultsClassification | Class that is the base-class for a vector of result |
CTMVA::ResultsMulticlass | Class which takes the results of a multiclass classification |
CTMVA::ResultsRegression | Class that is the base-class for a vector of result |
CTMVA::RootFinder | Root finding using Brents algorithm (translated from CERNLIB function RZERO) |
CTMVA::TNeuron | Neuron class used by TMVA artificial neural network methods |
CTMVA::TSynapse | Synapse class used by TMVA artificial neural network methods |
CTMVA::TreeInfo | |
►CTMVA::VariableTransformBase | Linear interpolation class |
CTMVA::VariableDecorrTransform | Linear interpolation class |
CTMVA::VariableGaussTransform | Gaussian Transformation of input variables |
CTMVA::VariableIdentityTransform | Linear interpolation class |
CTMVA::VariableNormalizeTransform | Linear interpolation class |
CTMVA::VariablePCATransform | Linear interpolation class |
CTMVA::VariableRearrangeTransform | Rearrangement of input variables |
CTMarker | Manages Markers |
CTMarker3DBox | A special 3-D marker designed for event display |
►CTMatrixTBase< Element > | TMatrixTBase |
CTMatrixT< Double_t > | |
CTMatrixT< AReal > | |
CTMatrixTSparse< Double_t > | |
CTMatrixTSym< Double_t > | |
CTMatrixT< Element > | TMatrixT |
CTMatrixTSparse< Element > | TMatrixTSparse |
CTMatrixTSym< Element > | TMatrixTSym |
►CTMatrixTLazy< Element > | Templates of Lazy Matrix classes |
CTHaarMatrixT< Element > | |
CTHilbertMatrixT< Element > | |
►CTMatrixTSymLazy< Element > | |
CTHilbertMatrixTSym< Element > | |
CTMergerInfo | |
CTMethodCall | Method or function calling interface |
CTMonitor | |
►CTMrbSubevent_Caen | |
CTUsrSevtData1 | |
CTUsrSevtData2 | |
CTMultiLayerPerceptron | This class describes a neural network |
►CTMutexImp | |
CTPosixMutex | |
CTWin32Mutex | |
►CTNDArray | N-Dim array class |
CTNDArrayT< double > | |
CTNDArrayT< T > | |
►CTNamed | Base class for all named ROOT classes |
CTProofVectorContainer< TProofDrawListOfGraphs::Point3D_t > | |
CTProofVectorContainer< TProofDrawListOfPolyMarkers3D::Point4D_t > | |
CROOT::Experimental::REveGeoShapeExtract | |
CROOT::Experimental::XRooFit::xRooFit::StoredFitResult | |
CROOT::Experimental::XRooFit::xRooNLLVar::xRooHypoPoint | |
CROOT::Experimental::XRooFit::xRooNLLVar::xRooHypoSpace | |
CROOT::Experimental::XRooFit::xRooNode | Designed to wrap over a TObject and provide functionality to aid with interacting with that object, particularly in the case where the object is a RooFit class instance |
CROOT::Internal::TBranchDescriptor | |
CROOT::Internal::TBranchProxyClassDescriptor | |
CROOT::Internal::TBranchProxyDescriptor | |
CROOT::Internal::TFriendProxyDescriptor | |
CROOT::Internal::THnBaseBrowsable | TBrowser helper for THnBase |
CROOT::TSchemaRule::TSources | |
►CROOT::v5::TFormula | The FORMULA class (ROOT version 5) |
CROOT::v5::TF1Data | |
CTTreeFormula | Used to pass a selection expression to the Tree drawing routine |
CROOT::v5::TFormulaPrimitive | The Formula Primitive class |
CRooAbsArg | Common abstract base class for objects that represent a value and a "shape" in RooFit |
CRooAbsBinning | Abstract base class for RooRealVar binning definitions |
CRooAbsData | Abstract base class for binned and unbinned datasets |
CRooAbsDataStore | Abstract base class for a data collection |
CRooAbsGenContext | Abstract base class for generator contexts of RooAbsPdf objects |
►CRooAbsMCStudyModule | Base class for add-on modules to RooMCStudy that can perform additional calculations on each generate+fit cycle managed by RooMCStudy |
CRooChi2MCSModule | RooChi2MCSModule is an add-on module to RooMCStudy that calculates the chi-squared of fitted p.d.f with respect to a binned version of the data |
CRooDLLSignificanceMCSModule | Add-on module to RooMCStudy that calculates the significance of a signal by comparing the likelihood of a fit fit with a given parameter floating with a fit with that given parameter fixed to a nominal value (usually zero) |
CRooRandomizeParamMCSModule | Add-on module to RooMCStudy that allows you to randomize input generation parameters |
CRooStats::UpperLimitMCSModule | This class allow to compute in the ToyMcStudy framework the ProfileLikelihood upper limit for each toy-MC sample generated |
►CRooAbsStudy | Abstract base class for RooStudyManager modules |
CRooGenFitStudy | Abstract base class for RooStudyManager modules |
CRooArgProxy | Abstract interface for RooAbsArg proxy classes |
►CRooCmdArg | 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 |
CRooFit::EvalBackend | |
CRooDouble | Minimal implementation of a TObject holding a double value |
CRooFactoryWSTool | Implementation detail of the RooWorkspace |
CRooFitResult | RooFitResult is a container class to hold the input and output of a PDF fit to a dataset |
CRooFormula | Internally uses ROOT's TFormula to compute user-defined expressions of RooAbsArgs |
CRooMCStudy | Helper class to facilitate Monte Carlo studies such as 'goodness-of-fit' studies, that involve fitting a PDF to multiple toy Monte Carlo sets |
CRooNameReg | Registry for const char* names |
CRooPlot | Plot frame and a container for graphics objects within that frame |
CRooSimWSTool::SplitRule | |
CRooStats::BayesianCalculator | BayesianCalculator is a concrete implementation of IntervalCalculator, providing the computation of a credible interval using a Bayesian method |
►CRooStats::ConfInterval | ConfInterval is an interface class for a generic interval in the RooStats framework |
CRooStats::LikelihoodInterval | LikelihoodInterval is a concrete implementation of the RooStats::ConfInterval interface |
CRooStats::MCMCInterval | MCMCInterval is a concrete implementation of the RooStats::ConfInterval interface |
CRooStats::PointSetInterval | PointSetInterval is a concrete implementation of the ConfInterval interface |
►CRooStats::SimpleInterval | SimpleInterval is a concrete implementation of the ConfInterval interface |
CRooStats::HypoTestInverterResult | HypoTestInverterResult class holds the array of hypothesis test results and compute a confidence interval |
CRooStats::ConfidenceBelt | ConfidenceBelt is a concrete implementation of the ConfInterval interface |
CRooStats::HLFactory | HLFactory is an High Level model Factory allows you to describe your models in a configuration file (datacards) acting as an interface with the RooFactoryWSTool |
CRooStats::HistFactory::Measurement | The RooStats::HistFactory::Measurement class can be used to construct a model by combining multiple RooStats::HistFactory::Channel objects |
CRooStats::HybridPlot | This class provides the plots for the result of a study performed with the HybridCalculatorOriginal class |
CRooStats::HypoTestInverterPlot | Class to plot a HypoTestInverterResult, the output of the HypoTestInverter calculator |
►CRooStats::HypoTestResult | HypoTestResult is a base class for results from hypothesis tests |
CRooStats::HybridResult | Class encapsulating the result of the HybridCalculatorOriginal |
CRooStats::LikelihoodIntervalPlot | This class provides simple and straightforward utilities to plot a LikelihoodInterval object |
CRooStats::MCMCCalculator | Bayesian Calculator estimating an interval or a credible region using the Markov-Chain Monte Carlo method to integrate the likelihood function with the prior to obtain the posterior function |
CRooStats::MCMCIntervalPlot | This class provides simple and straightforward utilities to plot a MCMCInterval object |
CRooStats::MarkovChain | Stores the steps in a Markov Chain of points |
CRooStats::ModelConfig | ModelConfig is a simple class that holds configuration information specifying how a model should be used in the context of various RooStats tools |
CRooStats::SPlot | A class to calculate "sWeights" used to create an "sPlot" |
CRooStats::SamplingDistPlot | This class provides simple and straightforward utilities to plot SamplingDistribution objects |
CRooStats::SamplingDistribution | This class simply holds a sampling distribution of some test statistic |
CRooStudyManager | Utility class to manage studies that consist of repeated applications of generate-and-fit operations on a workspace |
CRooStudyPackage | Utility class to manage studies that consist of repeated applications of generate-and-fit operations on a workspace |
CRooTable | Abstract interface for table objects |
CRooWorkspace | Persistable container for RooFit projects |
CTApplicationRemote::TARFileStat | |
CTAttParticle | Particle definition, partly based on GEANT3 particle definition |
CTAutoBinVal | |
CTAxis | Class to manage histogram axis |
CTAxis3D | The 3D axis painter class |
CTBenchmark | This class is a ROOT utility to help benchmarking applications |
CTBranch | A TTree is a list of TBranches |
►CTBrowser | Using a TBrowser one can browse all ROOT objects |
CROOT::Experimental::XRooFit::xRooBrowser | A version of the TBrowser that can be used to interact with RooFit models and datasets |
CTBrowserObject | This class is designed to wrap a Foreign object in order to inject it into the Browse sub-system |
CTBrowserPlugin | Helper class used to manage plugins (command or macro to be executed) |
CTChainElement | A TChainElement describes a component of a TChain |
CTClassTree | Draw inheritance tree and their relations for a list of classes |
►CTColor | The color creation and management class |
►CTColorGradient | TColorGradient extends basic TColor |
CTLinearGradient | |
CTRadialGradient | |
CTColorWheel | Draw the ROOT Color Wheel |
►CTContextMenu | This class provides an interface to context sensitive popup menus |
CTEveContextMenu | Specialization of TContext menu |
►CTControlBarButton | This class defines the control bar buttons |
CTControlBar | A Control Bar is a fully user configurable tool which provides fast access to frequently used operations |
CTCut | A specialized string object used for TTree selections |
►CTDSet | This class implements a data set to be used for PROOF processing |
CTDSetProxy | |
CTDSetElement | Manages an element of a TDSet |
CTDatabasePDG | Particle database manager class |
►CTDictionary | This class defines an abstract interface that must be implemented by all classes that contain dictionary information |
CTBaseClass | Each class (see TClass) has a linked list of its base class(es) |
►CTClass | TClass instances represent classes, structs and namespaces in the ROOT type system |
CTQClass | |
CTDataMember | All ROOT classes may have RTTI (run time type identification) support added |
CTDataType | Basic data type descriptor (datatype information is obtained from CINT) |
CTEnum | Implements the enum type |
►CTFunction | Global functions class (global functions are obtained from CINT) |
CTMethod | Each ROOT class (see TClass) has a linked list of methods |
CTFunctionTemplate | Dictionary for function template This class describes one single function template |
►CTGlobal | Global variables class (global variables are obtained from CINT) |
CTEnumConstant | Implements the constants of the enum type |
CTGlobalMappedFunction | |
CTMethodArg | Each ROOT method (see TMethod) has a linked list of its arguments |
►CTDirectory | Describe directory structure in memory |
►CTDirectoryFile | A ROOT file is structured in Directories (like a file system) |
CRooWorkspace::WSDir | |
►CTFile | A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-like logical structure, possibly including subdirectory hierarchies |
CTDCacheFile | A TDCacheFile is like a normal TFile except that it may read and write its data via a dCache server (for more on the dCache daemon see http://www-dcache.desy.de/ |
CTDavixFile | |
►CTMemFile | A TMemFile is like a normal TFile except that it reads and writes only from memory |
CROOT::TBufferMergerFile | A TBufferMergerFile is similar to a TMemFile, but when data is written to it, it is appended to the TBufferMerger queue |
CTParallelMergingFile | |
CTNetFile | A TNetFile is like a normal TFile except that it reads and writes its data via a rootd server (for more on the rootd daemon see the source files in root/rootd/src/ ) |
CTNetXNGFile | |
CTSQLFile | Access an SQL db via the TFile interface |
►CTWebFile | |
CTS3WebFile | A TS3WebFile is a TWebFile which retrieves the file contents from a web server implementing the REST API of the Amazon S3 protocol |
CTXMLFile | |
CTROOT | ROOT top level object description |
CTEfficiency | Class to handle efficiency histograms |
►CTEntryList | A List of entry numbers in a TTree or TChain |
CTEntryListArray | A list of entries and subentries in a TTree or TChain |
CTEntryListFromFile | Manages entry lists from different files, when they are not loaded in memory at the same time |
CTEveArrow | Class used for display of a thick arrow |
CTEveCaloData | A central manager for calorimeter event data |
CTEveCaloViz | Base class for calorimeter data visualization |
CTEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
CTEveElementList | A list of TEveElements |
CTEveGeoShapeExtract | Globally positioned TGeoShape with rendering attributes and an optional list of daughter shape-extracts |
CTEveParamList | Collection of named parameters |
CTEvePointSetArray | An array of point-sets with each point-set playing a role of a bin in a histogram |
CTEveProjectionAxes | Axes for non-linear projections |
CTEveSceneInfo | TEveUtil representation of TGLSceneInfo |
CTEveStraightLineSet | Set of straight lines with optional markers along the lines |
CTEveText | TEveElement class used for displaying FreeType GL fonts |
CTEventIterTree::TFileTree | |
CTEventList | Legacy Code TEventList is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TEventList might still be a valid solution. |
CTExec | TExec is a utility class that can be used to execute a C++ command when some event happens in a pad |
CTF1 | 1-Dim function class |
CTFITSHDU | FITS file interface class |
CTFileCollection | Class that contains a list of TFileInfo's and accumulated meta data information about its entries |
CTFileDrawMap | This class is automatically called by TFile::DrawMap |
CTFileInfo | Class describing a generic file including meta information |
CTFileInfoMeta | |
CTFileOpenHandle | Class holding info about the file being opened |
►CTFileStager | |
CTNetFileStager | |
CTNetXNGFileStager | |
CTFitResult | Extends the ROOT::Fit::Result class with a TNamed inheritance providing easy possibility for I/O |
CTFolder | Legacy Code TFolder is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TFolder might still be a valid solution. |
CTFormula | The Formula class |
CTFriendElement | A TFriendElement TF describes a TTree object TF in a file |
CTGDMLMatrix | This class is used in the process of reading and writing the GDML "matrix" tag |
►CTGEventHandler | |
►CTGLEventHandler | Base-class and default implementation of event-handler for TGLViewer |
CTEveLegoEventHandler | A base class of TGLEventHandler |
CTGFont | Encapsulate fonts used in the GUI system |
CTGL5DDataSet | |
►CTGLManager | |
CTGOSXGLManager | |
CTGWin32GLManager | |
CTGWin32GLManagerProxy | |
CTX11GLManager | The TX11GLManager is X11 implementation of TGLManager |
CTGLParametricEquation | A parametric surface is a surface defined by a parametric equation, involving two parameters (u, v): |
CTGLTH3Slice | A slice of a TH3 |
►CTGenerator | The interface to various event generators |
CTPythia8 | TPythia8 is an interface class to C++ version of Pythia 8.1
event generators, written by T.Sjostrand |
CTGeoBorderSurface | |
►CTGeoElement | Base class for chemical elements |
CTGeoElementRN | Class representing a radionuclidevoid TGeoManager::SetDefaultRootUnits() { if ( fgDefaultUnits == kRootUnits ) { return; } else if ( gGeometryLocked ) { TError::Fatal("TGeoManager","The system of units may only be changed once BEFORE any elements and materials are
created!"); } fgDefaultUnits = kRootUnits; } |
CTGeoIsotope | |
CTGeoManager | The manager class for any TGeo geometry |
CTGeoMaterial | Base class describing materials |
►CTGeoMatrix | Geometrical transformation package |
►CTGeoCombiTrans | Class describing rotation + translation |
CTGeoGenTrans | Most general transformation, holding a translation, a rotation and a scale |
CTGeoHMatrix | Matrix class used for computing global transformations Should NOT be used for node definition |
CTGeoIdentity | An identity transformation |
CTGeoRotation | Class describing rotations |
CTGeoScale | Class describing scale transformations |
CTGeoTranslation | Class describing translations |
CTGeoMedium | Media are used to store properties related to tracking and which are useful only when using geometry with a particle transport MC package (via VMC) |
CTGeoNode | A node represent a volume positioned inside another.They store links to both volumes and to the TGeoMatrix representing the relative positioning |
CTGeoOpticalSurface | This is a wrapper class to G4OpticalSurface |
CTGeoOverlap | Base class describing geometry overlaps |
CTGeoPNEntry | The knowledge of the path to the objects that need to be misaligned is essential since there is no other way of identifying them |
CTGeoParallelWorld | Base class for a flat parallel geometry |
CTGeoPhysicalNode | Physical nodes are the actual 'touchable' objects in the geometry, representing a path of positioned volumes starting with the top node: path=/TOP/A_1/B_4/C_3 , where A, B, C represent names of volumes |
CTGeoRegion | Regions are groups of volumes having a common set of user tracking cuts |
CTGeoRegionCut | |
►CTGeoShape | Base abstract class for all shapes |
►CTGeoBBox | Box class |
CROOT::Experimental::REveGeoPolyShape | |
CTEveGeoPolyShape | Description of TEveGeoPolyShape |
►CTGeoArb8 | An arbitrary trapezoid with less than 8 vertices standing on two parallel planes perpendicular to Z axis |
►CTGeoTrap | A general trapezoid |
CTGeoGtra | A twisted trapezoid |
CTGeoCompositeShape | Composite shapes are Boolean combinations of two or more shape components |
►CTGeoCone | The cones are defined by 5 parameters: |
CTGeoConeSeg | A cone segment is a cone having a range in phi |
CTGeoHalfSpace | A half space is limited just by a plane, defined by a point and the normal direction |
CTGeoPara | Parallelepiped class |
CTGeoParaboloid | A paraboloid is defined by the revolution surface generated by a parabola and is bounded by two planes perpendicular to Z axis |
►CTGeoPcon | A polycone is represented by a sequence of tubes/cones, glued together at defined Z planes |
CTGeoPgon | Polygons are defined in the same way as polycones, the difference being just that the segments between consecutive Z planes are regular polygons |
CTGeoScaledShape | A shape scaled by a TGeoScale transformation |
CTGeoShapeAssembly | The shape encapsulating an assembly (union) of volumes |
CTGeoSphere | TGeoSphere are not just balls having internal and external radii, but sectors of a sphere having defined theta and phi ranges |
CTGeoTessellated | Tessellated solid class |
CTGeoTorus | The torus is defined by its axial radius, its inner and outer radius |
CTGeoTrd1 | A trapezoid with only X varying with Z |
CTGeoTrd2 | A trapezoid with only X varying with Z |
►CTGeoTube | Cylindrical tube class |
CTGeoEltu | An elliptical tube is defined by the two semi-axes A and B |
CTGeoHype | A hyperboloid is represented as a solid limited by two planes perpendicular to the Z axis (top and bottom planes) and two hyperbolic surfaces of revolution about Z axis (inner and outer surfaces) |
►CTGeoTubeSeg | A tube segment is a tube having a range in phi |
CTGeoCtub | The cut tubes constructor has the form: |
CTGeoVGShape | Bridge class for using a VecGeom solid as TGeoShape |
CTGeoXtru | A TGeoXtru shape is represented by the extrusion of an arbitrary polygon with fixed outline between several Z sections |
CTGeoSkinSurface | |
CTGeoVolume | TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes |
CTGeometry | TGeometry description |
CTGraph | A TGraph is an object made of two arrays X and Y with npoints each |
CTGraph2D | Graphics object made of three arrays X, Y and Z with the same number of points each |
CTGraphDelaunay | TGraphDelaunay generates a Delaunay triangulation of a TGraph2D |
CTGraphDelaunay2D | TGraphDelaunay2D generates a Delaunay triangulation of a TGraph2D |
CTGraphNode | A graph node object which can be added in a TGraphStruct |
CTGraphPolargram | To draw polar axis |
CTGraphSmooth | A helper class to smooth TGraph |
CTGraphTime | TGraphTime is used to draw a set of objects evolving with nsteps in time between tmin and tmax |
CTGridJobStatus | |
CTGuiBldAction | |
►CTGuiFactory | This ABC is a factory for GUI components |
CTRootGuiFactory | This class is a factory for ROOT GUI components |
CTH1 | TH1 is the base class of all histogram classes in ROOT |
CTHStack | The Histogram stack class |
CTHbookFile | This class is an interface to the Hbook objects in Hbook files |
CTHbookKey | HBOOK Key |
►CTHnBase | Multidimensional histogram base |
►CTHn | Multidimensional histogram |
CTHnT< T > | Templated implementation of the abstract base THn |
►CTHnSparse | Efficient multidimensional histogram |
CTHnSparseT< CONT > | Templated implementation of the abstract base THnSparse |
►CTHttpEngine | Abstract class for implementing http protocol for THttpServer |
CTCivetweb | THttpEngine implementation, based on civetweb embedded server |
CTFastCgi | THttpEngine implementation, based on fastcgi package |
CTHttpServer | Online http server for arbitrary ROOT application |
►CTHttpWSHandler | Class for user-side handling of websocket with THttpServer |
CROOT::RWebWindowWSHandler | Just wrapper to deliver websockets call-backs to the RWebWindow class |
CTImage | An abstract interface to image processing library |
►CTInterpreter | This class defines an abstract interface to a generic command line interpreter |
CTCling | This class defines an interface to the cling C++ interpreter |
CTKDE | Kernel Density Estimation class |
►CTKey | Book space in a file, create I/O buffers, to fill them, (un)compress them |
CROOT::Experimental::Internal::RKeyBlob | The RKeyBlob writes an invisible key into a TFile |
►CTBasket | Manages buffers for branches of a Tree |
CTBasketSQL | Implement TBasket for a SQL backend |
CTKeySQL | TKeySQL represents meta-information about object, which was written to SQL database |
CTKeyXML | |
CTKeyMapFile | Utility class for browsing TMapFile objects |
►CTLeaf | A TLeaf describes individual elements of a TBranch See TBranch structure in TTree |
CTLeafB | A TLeaf for an 8 bit Integer data type |
CTLeafC | A TLeaf for a variable length string |
CTLeafD | A TLeaf for a 64 bit floating point data type |
CTLeafD32 | A TLeaf for a 24 bit truncated floating point data type |
CTLeafElement | A TLeaf for the general case when using the branches created via a TStreamerInfo (i.e |
CTLeafF | A TLeaf for a 32 bit floating point data type |
CTLeafF16 | A TLeaf for a 24 bit truncated floating point data type |
CTLeafG | A TLeaf for a 64 bit Integer data type |
CTLeafI | A TLeaf for an Integer data type |
CTLeafL | A TLeaf for a 64 bit Integer data type |
CTLeafO | A TLeaf for a bool data type |
CTLeafObject | A TLeaf for a general object derived from TObject |
CTLeafS | A TLeaf for a 16 bit Integer data type |
CTMVA::ClassInfo | Class that contains all the information of a class |
►CTMVA::Configurable | |
►CTMVA::CvSplit | |
CTMVA::CvSplitKFolds | |
CTMVA::DataLoader | |
►CTMVA::Envelope | Abstract base class for all high level ml algorithms, you can book ml methods like BDT, MLP |
CTMVA::CrossValidation | Class to perform cross validation, splitting the dataloader into folds |
CTMVA::Experimental::Classification | |
CTMVA::HyperParameterOptimisation | |
CTMVA::VariableImportance | |
CTMVA::Factory | This is the main MVA steering class |
►CTMVA::FitterBase | Base class for TMVA fitters |
CTMVA::GeneticFitter | Fitter using a Genetic Algorithm |
CTMVA::MCFitter | Fitter using Monte Carlo sampling of parameters |
CTMVA::MinuitFitter | /Fitter using MINUIT |
CTMVA::SimulatedAnnealingFitter | Fitter using a Simulated Annealing Algorithm |
CTMVA::MethodBase | Virtual base Class for all MVA method |
CTMVA::PDF | PDF wrapper for histograms; uses user-defined spline interpolation |
CTMVA::Reader | Serves to use the MVAs in a specific analysis context |
CTMVA::DataSet | Class that contains all the data information |
CTMVA::MethodInfo | |
CTMVA::VariableInfo | Class for type info of MVA input variable |
►CTMacro | Class supporting a collection of lines with C++ code |
CTEveMacro | Sub-class of TMacro, overriding Exec to unload the previous version and cleanup after the execution |
CTMaterial | Manages a detector material |
CTMessageHandler | Handle messages that might be generated by the system |
►CTMinuit | |
CTMVA::MinuitWrapper | Wrapper around MINUIT |
CTMinuit2TraceObject | |
CTMultiDimFit | Multidimensional Fits in ROOT |
CTMultiGraph | A TMultiGraph is a collection of TGraph (or derived) objects |
CTNeuron | This class describes an elementary neuron, which is the basic element for a Neural Network |
CTNode | TNode description |
CTPackMgr | The PROOF package manager contains tools to manage packages |
CTParallelCoord | Parallel Coordinates class |
CTParallelCoordRange | A TParallelCoordRange is a range used for parallel coordinates plots |
CTParallelCoordVar | TParallelCoord axes |
CTParticleClassPDG | Utility class used internally by TDatabasePDG |
CTParticlePDG | Description of the static properties of a particle |
CTPie | Draw a Pie Chart, |
CTPieSlice | A slice of a piechart, see the TPie class |
CTPrincipal | Principal Components Analysis (PCA) |
►CTProcessID | A TProcessID identifies a ROOT job in a unique way in time and space |
CTProcessUUID | This class is a specialized TProcessID managing the list of UUIDs |
►CTProof | This class controls a Parallel ROOT Facility, PROOF, cluster |
CTProofCondor | |
CTProofLite | This class starts a PROOF session on the local machine: no daemons, client and master merged, communications via UNIX-like sockets |
CTProofSuperMaster | Implementation of TProof controlling PROOF federated clusters |
CTProofDesc | |
CTProofLockPath | |
CTProofLog | Implementation of the PROOF session log handler |
CTProofLogElem | |
►CTProofMgr | The PROOF manager interacts with the PROOF server coordinator to create or destroy a PROOF session, attach to or detach from existing one, and to monitor any client activity on the cluster |
CTProofMgrLite | Basic TProofMgr functionality implementation in the case of Lite session |
►CTProofMonSender | Provides the interface for PROOF monitoring to different writers |
CTProofMonSenderSQL | TProofMonSender implementation for the SQL writers |
CTProofMonSender::TDSetPlet | |
CTProofOutputFile | Class to steer the merging of files produced on the workers |
CTProofPerfAnalysis | Set of tools to analyse the performance tree |
CTProofPerfAnalysis::TFileInfo | |
CTProofPerfAnalysis::TPackInfo | |
CTProofPerfAnalysis::TWrkInfo | |
CTProofPerfAnalysis::TWrkInfoFile | |
CTProofVectorContainer< T > | |
CTProtoClass | Persistent version of a TClass |
►CTQueryResult | A container class for query results |
CTProofQueryResult | TQueryResult version adapted to PROOF neeeds |
►CTRandom | This is the base class for the ROOT Random number generators |
CTRandom1 | The Ranlux Random number generator class |
CTRandom2 | Random number generator class based on the maximally quidistributed combined Tausworthe generator by L'Ecuyer |
CTRandom3 | Random number generator class based on M |
CTRandomGen< Engine > | |
CTRemoteObject | Protocol for browsing ROOT objects from a remote ROOT session |
►CTRootSniffer | Sniffer of ROOT objects, data provider for THttpServer |
CTRootSnifferFull | Extends TRootSniffer for many ROOT classes |
CTRotMatrix | Manages a detector rotation matrix |
CTSQLColumnInfo | |
CTSQLTableInfo | |
CTScatter | A TScatter is able to draw four variables scatter plot on a single plot |
CTShape | This is the base class for all geometry shapes |
►CTSocket | |
CTPSocket | |
CTSSLSocket | |
►CTServerSocket | |
CTPServerSocket | |
CTSpectrum | Advanced Spectra Processing |
CTSpectrum2 | Advanced 2-dimensional spectra processing |
CTSpectrum2Fit | Advanced 2-dimensional spectra fitting functions |
CTSpectrum2Painter | Legacy Code TSpectrum2Painter is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TSpectrum2Painter might still be a valid solution. |
CTSpectrum3 | Advanced 3-dimensional spectra processing functions |
CTSpectrumFit | Advanced 1-dimensional spectra fitting functions |
CTSpectrumTransform | Advanced 1-dimensional orthogonal transform functions |
CTSpline | Base class for spline implementation containing the Draw/Paint methods |
CTStatus | This class holds the status of an ongoing operation and collects error messages |
►CTStreamerElement | |
CTStreamerArtificial | |
CTStreamerBase | |
CTStreamerBasicPointer | |
CTStreamerBasicType | |
CTStreamerLoop | |
CTStreamerObject | |
CTStreamerObjectAny | |
CTStreamerObjectAnyPointer | |
CTStreamerObjectPointer | |
►CTStreamerSTL | |
CTStreamerSTLstring | |
CTStreamerString | |
CTStructNodeProperty | |
CTStyle | TStyle objects may be created to define special styles |
►CTSystem | Abstract base class defining a generic interface to the underlying Operating System |
CTDCacheSystem | |
CTDavixSystem | |
CTNetSystem | |
CTNetXNGSystem | |
►CTUnixSystem | |
CTMacOSXSystem | |
CTWebSystem | |
CTWinNTSystem | |
►CTSystemFile | A TSystemFile describes an operating system file |
CTSystemDirectory | Describes an Operating System directory for the browser |
CTTask | Legacy Code TTask is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TTask might still be a valid solution. |
CTText | Base class for several text objects |
CTThread | Legacy Code TThread is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TThread might still be a valid solution. |
►CTThreadFactory | |
CTPosixThreadFactory | |
CTWin32ThreadFactory | |
CTToggle | This class defines toggling facility for both - object's method or variables |
CTToggleGroup | This class defines check-box facility for TToggle objects It is used in context menu "selectors" for picking up a value |
CTTree | A TTree represents a columnar dataset |
CTUDPSocket | |
►CTUnfoldBinning | Binning schemes for use with the unfolding algorithm TUnfoldDensity |
CTUnfoldBinningXML | XML interfate to binning schemes, for use with the unfolding algorithm TUnfoldDensity |
►CTVirtualBranchBrowsable | TVirtualBranchBrowsable is a base class (not really abstract, but useless by itself) for helper objects that extend TBranch's browsing support |
CTCollectionPropertyBrowsable | A tiny browser helper object (and its generator) for adding a virtual (as in "not actually part of the class", not in C++ virtual) "@size()" method to a collection |
►CTMethodBrowsable | This helper object allows the browsing of methods of objects stored in branches |
CTCollectionMethodBrowsable | TCollectionMethodBrowsable extends TCollectionPropertyBrowsable by showing all methods of the collection itself |
CTNonSplitBrowsable | Allows a TBrowser to browse non-split branches as if they were split |
►CTVirtualFitter | Abstract Base Class for Fitting |
CTBackCompFitter | Backward compatible implementation of TVirtualFitter |
CTFitter | Legacy Code TFitter is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TFitter might still be a valid solution. Consider switching to ROOT::Fit::Fitter. |
CTFumili | |
CTLinearFitter | |
►CTVirtualIndex | Abstract interface for Tree Index |
CTChainIndex | A Chain Index |
CTTreeIndex | A Tree Index with majorname and minorname |
►CTVirtualMagField | Abstract class for magnetic field |
CTGeoUniformMagField | Implementation for uniform magnetic field |
CTVirtualMonitoringReader | |
►CTVirtualMonitoringWriter | |
CROOT::RTreeDrawMonitoring | |
CTSQLMonitoringWriter | |
CTTreeDrawMonitoring | |
CTVirtualPS | TVirtualPS is an abstract interface to Postscript, PDF, SVG |
►CTVirtualStreamerInfo | Abstract Interface class describing Streamer information for one class |
CTStreamerInfo | Describes a persistent version of a class |
CTVirtualX | Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...) |
CTXMLEntity | |
CfileDesc | |
►CTNotifyLinkBase | See TNotifyLink |
►CTNotifyLink< RNoCleanupNotifierHelper > | |
CROOT::Internal::TreeUtils::RNoCleanupNotifier | |
CTNotifyLink< ROOT::Detail::TBranchProxy > | |
CTNotifyLink< TTreeReader > | |
CTNotifyLink< Type > | A node in a doubly linked list of subscribers to TChain notifications |
►CTObjString | Collectable string class |
CTNamedFont | |
CTObjectRefSpy | |
CTObjectSpy | Monitors objects for deletion and reflects the deletion by reverting the internal pointer to zero |
CTObjectTable | This class registers all instances of TObject and its derived classes in a hash table |
CTOptionListItem | |
CTOutputListSelectorDataMap | Set the selector's data members to the corresponding elements of the output list |
CTPBHandleDSType | |
CTPBHistType | |
CTPBReadType | |
CTPackageDescription | |
CTPacketizer::TFileNode | |
CTPacketizer::TFileStat | |
CTPacketizerAdaptive::TFileNode | |
CTPacketizerAdaptive::TFileStat | |
CTPacketizerFile::TIterObj | |
CTPair | Class used by TMap to store (key,value) pairs |
CTParameter< AParamType > | Named parameter, streamable and storable |
CTParticle | Description of the dynamic properties of a particle |
CTPerfEvent | |
CTPluginHandler | |
CTPluginManager | This class implements a plugin library manager |
CTPoints3DABC | Abstract class to define Arrays of 3D points |
CTPolyLine | Defined by an array on N points in a 2-D space |
CTPolyLine3D | A 3-dimensional polyline |
CTPolyMarker | A PolyMarker is defined by an array on N points in a 2-D space |
CTPolyMarker3D | A 3D polymarker |
CTPrimary | Old version of a dynamic particle class created by event generators |
CTProofBench | Steering class for PROOF benchmarks |
CTProofBenchDataSet | Handle operations on datasets used by ProofBench |
►CTProofBenchRun | Abstract base class for PROOF benchmark runs |
CTProofBenchRunCPU | CPU-intensive PROOF benchmark test generates events and fill 1, 2, or 3-D histograms |
CTProofBenchRunDataRead | I/O-intensive PROOF benchmark test reads in event files distributed on the cluster |
CTProofNodeInfo | The purpose of this class is to provide a complete node description for masters, submasters and workers |
CTProofNodes | PROOF worker node information
|
CTProofPerfAnalysis::TWrkEntry | |
CTProofProgressInfo | |
CTProofProgressStatus | Container class for processing statistics |
►CTProofResources | |
CTProofResourcesStatic | The purpose of this class is to provide a standard interface to static config files |
CTPyDispatcher | |
CTQSlot | Slightly modified TMethodCall class used in the object communication mechanism |
►CTQpDataBase | Data for the general QP formulation |
CTQpDataDens | Data for the dense QP formulation |
CTQpDataSparse | Data for the sparse QP formulation |
►CTQpLinSolverBase | Implementation of main solver for linear systems |
CTQpLinSolverDens | Implements the aspects of the solvers for dense general QP formulation that are specific to the dense case |
CTQpLinSolverSparse | Implements the aspects of the solvers for dense general QP formulation that are specific to the dense case |
►CTQpProbBase | Default general problem formulation: |
CTQpProbDens | Dense matrix problem formulation |
CTQpProbSparse | Dense matrix problem formulation |
CTQpResidual | The Residuals class calculates and stores the quantities that appear on the right-hand side of the linear systems that arise at each interior-point iteration |
►CTQpSolverBase | The Solver class contains methods for monitoring and checking the convergence status of the algorithm, methods to determine the step length along a given direction, methods to define the starting point, and the solve method that implements the interior-point algorithm |
CTGondzioSolver | Derived class of TQpSolverBase implementing Gondzio-correction version of Mehrotra's original predictor-corrector algorithm |
CTMehrotraSolver | Derived class of TQpSolverBase implementing the original Mehrotra predictor-corrector algorithm |
CTQpVar | Class containing the variables for the general QP formulation |
CTQuaternion | Legacy Code TQuaternion is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TQuaternion might still be a valid solution. Consider using instead ROOT::Math::Quaternion.Quaternion is a 4-component mathematic object quite convenient when dealing with space rotation (or reference frame transformation) |
CTQueryDescription | |
CTQueryResultManager | Class managing the query-result area |
CTRWLock | |
CTRatioPlot | Class for displaying ratios, differences and fit residuals |
CTRealData | Manages the effective list of all data members for a given class |
►CTRecEvent | Abstract class that defines interface for a class storing information about 1 ROOT event |
CTRecCmdEvent | Class used for storing information about 1 commandline event |
CTRecExtraEvent | Class TRecExtraEvent |
CTRecGuiEvent | Class TRecGuiEvent |
CTRecWinPair | Class used for storing of window IDs mapping |
CTRecorder | Class provides direct recorder/replayer interface for a user |
CTRef | Persistent Reference link to a TObject A TRef is a lightweight object pointing to any TObject |
CTRefTable | A TRefTable maintains the association between a referenced object and the parent object supporting this referenced object |
CTRobustEstimator | |
CTRolke | Legacy Code TRolke is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TRolke might still be a valid solution. Consider switching to RooStats.This class computes confidence intervals for the rate of a Poisson process in the presence of uncertain background and/or efficiency |
CTRootBrowserHistoryCursor | |
►CTRootSnifferStore | Abstract interface for storage of hierarchy scan in TRootSniffer |
CTRootSnifferStoreJson | Storage of hierarchy scan in TRootSniffer in JSON format |
CTRootSnifferStoreXml | Storage of hierarchy scan in TRootSniffer in XML format |
CTRotation | Legacy Code TRotation is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TRotation might still be a valid solution. Consider using instead ROOT::Math::Rotation3D. |
CTS3HTTPRequest | |
CTSPlot | Legacy Code TSPlot is a legacy interface: there will be no bug fixes nor new developments. Therefore it is not recommended to use it in new long-term production code. But, depending on the context, using TSPlot might still be a valid solution. |
CTSQLClassColumnInfo | |
CTSQLClassInfo | Contains information about tables specific to one class and version |
CTSQLColumnData | |
CTSQLObjectData | TSQLObjectData is used in TBufferSQL2 class in reading procedure |
CTSQLObjectDataPool | XML object keeper class |
CTSQLObjectInfo | Info (classname, version) about object in database |
►CTSQLResult | |
CTMySQLResult | |
CTODBCResult | |
CTPgSQLResult | |
CTSQLiteResult | |
CTTreeResult | Class defining interface to a TTree query result with the same interface as for SQL databases |
►CTSQLRow | |
CTMySQLRow | |
CTODBCRow | |
CTPgSQLRow | |
CTSQLiteRow | |
CTTreeRow | Class defining interface to a row of a TTree query result |
►CTSQLServer | |
CTMySQLServer | |
CTODBCServer | |
CTPgSQLServer | |
CTSQLiteServer | |
►CTSQLStatement | |
CTMySQLStatement | |
CTODBCStatement | |
CTPgSQLStatement | |
CTSQLiteStatement | |
CTSQLStructure | This is hierarchical structure, which is created when data is written by TBufferSQL2 |
CTSQLTableData | |
CTSVDUnfold | SVD Approach to Data Unfolding |
►CTSecContext | |
CTRootSecContext | |
CTSecContextCleanup | |
►CTSelector | A TSelector object is used by the TTree::Draw, TTree::Scan, TTree::Process to navigate in a TTree and make selections |
►CTProofDraw | Implement Tree drawing using PROOF |
CTProofDrawEntryList | |
CTProofDrawEventList | |
CTProofDrawGraph | |
CTProofDrawHist | |
CTProofDrawListOfGraphs | |
CTProofDrawListOfPolyMarkers3D | |
CTProofDrawPolyMarker3D | |
CTProofDrawProfile | |
CTProofDrawProfile2D | |
CTSelEvent | Selector for PROOF I/O benchmark test |
CTSelEventGen | Selector for event file generation |
CTSelHandleDataSet | PROOF selector for file cache release |
CTSelHist | PROOF selector for CPU-intensive benchmark test |
CTSelVerifyDataSet | Selector to verify dataset in parallel on workers |
►CTSelectorDraw | A specialized TSelector for TTree::Draw |
CROOT::Experimental::REvePointSelector | REvePointSelector TSelector for direct extraction of point-like data from a Tree |
CROOT::Experimental::REveSelectorToEventList | REveSelectorToEventList TSelector that stores entry numbers of matching TTree entries into an event-list |
CTEvePointSelector | TEvePointSelector is a sub-class of TSelectorDraw for direct extraction of point-like data from a Tree |
CTEveSelectorToEventList | TSelector that stores entry numbers of matching TTree entries into an event-list |
CTSelectorEntries | The class is derived from the ROOT class TSelector |
Ch1analysis | |
Ch1analysisTreeReader | |
CTSemaphore | |
CTSessionDescription | |
►CTSlave | Class describing a PROOF worker server |
CTSlaveLite | Version of TSlave for local worker servers |
CTSlaveInfo | |
CTSpectrum2Transform | Advanced 2-dimensional orthogonal transform functions |
CTSpider | Spider class |
►CTSplinePoly | Base class for TSpline knot |
CTSplinePoly3 | Class for TSpline3 knot |
CTSplinePoly5 | Class for TSpline5 knot |
CTSqlCmdsBuffer | |
CTSqlRawBuffer | |
CTSqlRegistry | |
CTStatistic | Statistical variable, defined by its mean and variance (RMS) |
CTStatsFeedback | Utility class to display PROOF stats feedback histos during queries |
►CTStopwatch | Stopwatch class |
CTMVA::Timer | Timing information for training and evaluation of MVA methods |
CTStreamerInfoActions::TActionSequence | |
CTStreamerInfoActions::TConfiguredAction | |
CTStructNode | |
CTStructViewer | |
CTSynapse | This is a simple weighted bidirectional connection between two neurons |
►CTSysEvtHandler | Abstract base class for handling system events |
►CTFileHandler | |
CTASInputHandler | |
CTASLogHandler | |
CTGInputHandler | |
CTProofInputHandler | |
CTProofServInputHandler | |
CTProofServLiteInputHandler | |
CTProofServLogHandler | |
CTSocketHandler | |
CTTermInputHandler | |
►CTSignalHandler | |
CTARInterruptHandler | |
CTASInterruptHandler | |
CTASSigPipeHandler | |
CTInterruptHandler | |
CTProofInterruptHandler | |
CTProofServInterruptHandler | |
CTProofServLiteInterruptHandler | |
CTProofServLiteSegViolationHandler | |
CTProofServLiteSigPipeHandler | |
CTProofServLiteTerminationHandler | |
CTProofServSigPipeHandler | |
CTProofServTerminationHandler | |
►CTStdExceptionHandler | |
CROOT::Experimental::REveManager::RExceptionHandler | |
CTEveManager::TExceptionHandler | Exception handler for Eve exceptions |
►CTTimer | Handles synchronous and a-synchronous timer events |
CROOT::RBrowserTimer | |
CROOT::RTreeDrawInvokeTimer | |
CTBlinkTimer | |
CTBrowserTimer | Called whenever timer times out |
CTDispatchTimer | |
CTGContainerKeyboardTimer | |
CTGContainerScrollTimer | |
CTGLRedrawTimer | |
CTGuiBldDragManagerRepeatTimer | |
CTHttpTimer | |
CTIdleTOTimer | |
CTIdleTimer | |
CTPopupDelayTimer | |
CTProcessEventTimer | |
CTProctimeTimer | |
CTReaperTimer | |
CTRepeatTimer | |
CTSBRepeatTimer | |
CTShutdownTimer | |
CTSingleShotCleaner | |
CTStopTimer | |
CTThreadTimer | |
CTTimeOutTimer | |
CTTipDelayTimer | |
CTViewTimer | |
CTViewUpdateTimer | |
CTWebCanvasTimer | |
CTTVRecord | I/O classes for TreeViewer session handling |
CTTVSession | I/O classes for TreeViewer session handling |
►CTThreadImp | |
CTPosixThread | |
CTWin32Thread | |
CTTreeDrawArgsParser | A class that parses all parameters for TTree::Draw() |
CTTreeFormulaManager | Used to coordinate one or more TTreeFormula objects |
CTTreeReader | A simple, robust and fast interface to read values from ROOT columnar datasets such as TTree, TChain or TNtuple |
►CTUnfold | An algorithm to unfold distributions from detector to truth level |
►CTUnfoldSys | An algorithm to unfold distributions from detector to truth level, with background subtraction and propagation of systematic uncertainties |
CTUnfoldDensity | An algorithm to unfold distributions from detector to truth level |
CTUnfoldIterativeEM | |
CTUri | This class represents a RFC 3986 compatible URI |
CTUrl | This class represents a WWW compatible URL |
CTUsrHit | |
CTUsrHitBuffer | |
CTVector2 | |
CTVector3 | |
CTVectorT< Element > | TVectorT |
CTView | See TView3D |
►CTVirtualFFT | TVirtualFFT is an interface class for Fast Fourier Transforms |
CTFFTComplex | One of the interface classes to the FFTW package, can be used directly or via the TVirtualFFT class |
CTFFTComplexReal | One of the interface classes to the FFTW package, can be used directly or via the TVirtualFFT class |
CTFFTReal | One of the interface classes to the FFTW package, can be used directly or via the TVirtualFFT class |
CTFFTRealComplex | One of the interface classes to the FFTW package, can be used directly or via the TVirtualFFT class |
►CTVirtualGeoConverter | Abstract class for geometry converters |
CTGeoVGConverter | Geometry converter to VecGeom |
►CTVirtualGeoPainter | Abstract class for geometry painters |
CROOT::RGeoPainter | |
CTGeoPainter | Class implementing all draw interfaces for a generic 3D viewer using TBuffer3D mechanism |
CTVirtualGeoTrack | Base class for user-defined tracks attached to a geometry |
►CTVirtualGraphPainter | Abstract interface to a histogram painter |
CTGraphPainter | The graph painter class |
►CTVirtualHistPainter | Abstract interface to a histogram painter |
CTGLHistPainter | The histogram painter class using OpenGL |
CTHistPainter | The histogram painter class |
►CTVirtualMCDecayer | Abstract base class for particle decays |
CTPythia8Decayer | This class implements the TVirtualMCDecayer interface using TPythia8 |
►CTVirtualMapFile | Abstract base class for TMapFile |
CTMapFile | This class implements a shared memory region mapped to a file |
►CTVirtualPacketizer | The packetizer is a load balancing object created for each query |
CTPacketizer | This class generates packets to be processed on PROOF worker servers |
CTPacketizerAdaptive | This packetizer is based on TPacketizer but uses different load-balancing algorithms and data structures |
CTPacketizerFile | This packetizer generates packets which contain a single file path to be used in process |
CTPacketizerMulti | This class allows to do multiple runs in the same query; each run can be a, for example, different dataset or the same dataset with entry list |
CTPacketizerUnit | This packetizer generates packets of generic units, representing the number of times an operation cycle has to be repeated by the worker node, e.g |
►CTVirtualPacketizer::TVirtualSlaveStat | |
CTPacketizer::TSlaveStat | |
CTPacketizerAdaptive::TSlaveStat | |
CTPacketizerFile::TSlaveStat | |
CTPacketizerUnit::TSlaveStat | |
CTVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
►CTVirtualPerfStats | Provides the interface for the PROOF internal performance measurement and event tracing |
CTPerfStats | Provides the interface for the PROOF internal performance measurement and event tracing |
CTTreePerfStats | TTree I/O performance measurement |
►CTVirtualProofPlayer | Abstract interface for the PROOF player |
►CTProofPlayer | Internal class steering processing in PROOF |
CTProofPlayerLocal | |
►CTProofPlayerRemote | |
CTProofPlayerLite | Version of TProofPlayerRemote merges the functionality needed by clients and masters |
CTProofPlayerSuperMaster | |
CTProofPlayerSlave | |
►CTVirtualTreePlayer | Abstract base class defining the interface for the plugins that implement Draw, Scan, Process, MakeProxy, etc |
CTTreePlayer | Implement some of the functionality of the class TTree requiring access to extra libraries (Histogram, display, etc) |
►CTVirtualViewer3D | Abstract 3D shapes viewer |
CTGLScenePad | Implements VirtualViewer3D interface and fills the base-class visualization structures from pad contents |
CTGLViewer | Base GL viewer object - used by both standalone and embedded (in pad) GL |
CTViewer3DPad | Provides 3D viewer interface (TVirtualViewer3D) support on a pad |
CTWebPainting | Object used to store paint operations and deliver them to JSROOT |
►CTWebSnapshot | Paint state of object to transfer to JavaScript side |
►CTPadWebSnapshot | |
CTCanvasWebSnapshot | |
CTXMLAttr | TXMLAttribute is the attribute of an Element |
CTXMLDocument | TXMLDocument contains a pointer to an xmlDoc structure, after the parser returns a tree built during the document analysis |
CTXMLEngine | |
CTXMLNode | TXMLNode contains a pointer to xmlNode, which is a node under the DOM tree |
►CTXMLParser | TXMLParser is an abstract class which interfaces with Libxml2 |
CTDOMParser | |
CTSAXParser | TSAXParser is a subclass of TXMLParser, it is a wraper class to libxml library |
CTXMLPlayer | |
CTrack | |
►CROOT::Internal::TObjProxy< T > | |
CROOT::Internal::TStlSimpleProxy< T > | |
CROOT::Experimental::RDirectory::ToContentType< T > | |
CToolBarData_t | |
CTMVA::Tools | Global auxiliary applications and data treatment routines |
►Cbvh::v2::TopDownSahBuilder< Node > | Base class for all SAH-based, top-down builders |
Cbvh::v2::BinnedSahBuilder< Node, BinCount > | Single-threaded top-down builder that partitions primitives based on a binned approximation of the Surface Area Heuristic (SAH) |
Cbvh::v2::SweepSahBuilder< Node > | Single-threaded top-down builder that partitions primitives based on the Surface Area Heuristic (SAH) |
CROOT::Internal::TOperatorNewHelper | |
CROOT::v5::TOperOffset | |
►CTPaletteEditor | Edit the palette via a GUI |
CTASPaletteEditor | This is a GUI window to edit a color palette |
CTMySQLStatement::TParamData | |
CROOT::Internal::TParBranchProcessingRAII | |
CTMemberInspector::TParentBuf | |
CTPickerStackGuard | |
CTPoint | |
CTStreamerInfo::TPointerCollectionAdapter | |
►CROOT::Internal::TDS::TPointerHolder | Mother class of TTypedPointerHolder |
CROOT::Internal::TDS::TTypedPointerHolder< T > | Class to wrap a pointer and delete the memory associated to it correctly |
CTPoints | 2-D graphics point (world coordinates) |
CTPosixThreadCleanUp | |
►CTPRegexp | |
CTPMERegexp | Wrapper for PCRE library (Perl Compatible Regular Expressions) |
CROOT::RDF::TProfile1DModel | A struct which stores the parameters of a TProfile |
CROOT::RDF::TProfile2DModel | A struct which stores the parameters of a TProfile2D |
CTProfileHelper | |
CTProofDebug | |
CTProofLockPathGuard | |
CTProofMergePrg | |
CTProofProgressDialog | This class provides a query progress bar |
CTProofServLogHandlerGuard | |
CTProtoClass::TProtoRealData | |
CTVirtualCollectionProxy::TPushPop | RAII helper class that ensures that PushProxy() / PopProxy() are called when entering / leaving a C++ context |
CTPwdCtx | |
CTPyArg | |
CTPyReturn | |
CTPython | Accessing the Python interpreter from C++ |
►CTQObject | This is the ROOT implementation of the Qt object communication mechanism (see also http://www.troll.no/qt/metaobjects.html) |
CROOT::Experimental::XRooFit::xRooBrowser | A version of the TBrowser that can be used to interact with RooFit models and datasets |
CROOT::Experimental::XRooFit::xRooNode::InteractiveObject | |
CTApplication | This class creates the ROOT Application Environment that interfaces to the windowing system eventloop and eventhandlers |
CTDrawFeedback | Utility class to draw objects in the feedback list during queries |
CTEveDigitSet | Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox) |
CTEveParamList | Collection of named parameters |
CTEvePointSet | TEvePointSet is a render-element holding a collection of 3D points with optional per-point TRef and an arbitrary number of integer ids (to be used for signal, volume-id, track-id, etc) |
CTEveRGBAPalette | A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes |
CTEveSelection | Make sure there is a SINGLE running TEveSelection for each selection type (select/highlight) |
CTEveStraightLineSet | Set of straight lines with optional markers along the lines |
CTEveWindowManager | Manager for EVE windows |
CTGClient | Window client |
CTGEventHandler | |
CTGFrame | A subclasses of TGWindow, and is used as base class for some simple widgets (buttons, labels, etc.) |
CTGLOverlayButton | GL-overlay button |
CTGLViewer | Base GL viewer object - used by both standalone and embedded (in pad) GL |
CTGTableFrame | TGTableFrame contains a composite frame that uses a TGMatrixLayout to Layout the frames it contains |
CTMessageHandler | Handle messages that might be generated by the system |
CTMonitor | |
CTProof | This class controls a Parallel ROOT Facility, PROOF, cluster |
CTProofLog | Implementation of the PROOF session log handler |
CTQClass | |
CTQCommand | The Command design pattern is based on the idea, that all editing in an application is done by creating instances of command objects |
CTQConnection | TQConnection class is an internal class, used in the object communication mechanism |
CTQObjSender | |
CTStatsFeedback | Utility class to display PROOF stats feedback histos during queries |
CTSysEvtHandler | Abstract base class for handling system events |
CTVirtualPad | TVirtualPad is an abstract base class for the Pad and Canvas classes |
CTVirtualProofPlayer | Abstract interface for the PROOF player |
CTXMLParser | TXMLParser is an abstract class which interfaces with Libxml2 |
CTQSlotPool | |
CTMVA::TrainingHistory | Tracking data from training |
CTrainNodeInfo | |
►CROOT::Math::TRandomEngine | |
CROOT::Math::LCGEngine | |
CROOT::Math::MersenneTwisterEngine | Random number generator class based on M |
CROOT::Math::MixMaxEngine< N, SkipNumber > | MixMaxEngine is a wrapper class for the MIXMAX Random number generator |
CROOT::Math::RanluxppCompatEngineGslRanlxd< p > | Compatibility engine for gsl_rng_ranlxd* from the GNU Scientific Library |
CROOT::Math::RanluxppCompatEngineGslRanlxs< p > | Compatibility engine for gsl_rng_ranlxs* from the GNU Scientific Library |
CROOT::Math::RanluxppCompatEngineJames< p > | |
CROOT::Math::RanluxppCompatEngineLuescherRanlxd< p > | Compatibility engine for Lüscher's ranlxd implementation written in C |
CROOT::Math::RanluxppCompatEngineLuescherRanlxs< p > | Compatibility engine for Lüscher's ranlxs implementation written in C |
CROOT::Math::RanluxppCompatEngineStdRanlux24 | Compatibility engine for std::ranlux24 from the C++ standard |
CROOT::Math::RanluxppCompatEngineStdRanlux48 | Compatibility engine for std::ranlux48 from the C++ standard |
CROOT::Math::RanluxppEngine< p > | Implementation of the RANLUX++ generator |
CTRandom | This is the base class for the ROOT Random number generators |
CTRandomEngine | |
CROOT::Math::Impl::Transform3D< T > | Basic 3D Transformation class describing a rotation and then a translation The internal data are a 3D rotation data (represented as a 3x3 matrix) and a 3D vector data |
CTMVA::TransformationHandler | Class that contains all the data information |
CROOT::Math::Impl::Translation3D< T > | Class describing a 3 dimensional translation |
CROOT::Math::TransposeOp< Matrix, T, D1, D2 > | Class for Transpose Operations |
CROOT::Math::TranspPolicy< T, D1, D2, R > | Matrix transpose policy |
CROOT::Math::TranspPolicy< T, D1, D2, MatRepSym< T, D1 > > | |
CROOT::TReadLockGuard | |
►CTRecorderState | Abstract class that defines interface for a state of recorder |
CTRecorderInactive | Represents state of TRecorder just after its creation |
CTRecorderPaused | Represents state of TRecorder when replaying was paused by a user |
CTRecorderRecording | Represents state of TRecorder when recording events |
CTRecorderReplaying | Represents state of TRecorder when replaying previously recorded events |
CTRedirectOutputGuard | |
CTEveManager::TRedrawDisabler | |
CROOT::TReentrantRWLock< MutexT, RecurseCountsT > | |
CTReentrantRWLock | An implementation of a reentrant read-write lock with a configurable internal mutex/lock (default Spin Lock) |
CROOT::TReentrantRWLock< MutexT, ROOT::Internal::RecurseCounts > | |
►CTreeReadBuffer | |
CTypedTreeReadBuffer< T > | Helper for reading branches with various types from a TTree, and convert all to double |
CTreeUtils | Different standalone functions to work with trees and tuples, not reqiuired to be a member of any class |
►CTRefCnt | Definitions for TRefCnt, base class for reference counted objects |
CTGFont | Encapsulate fonts used in the GUI system |
CTGGC | Encapsulate a graphics context used in the low level graphics |
CTGLayoutHints | This class describes layout hints used by the layout classes |
CTGPicture | Implements pictures and icons used in the different GUI elements and widgets |
CTGRegionData | |
CTNamedFont | |
CTQSlot | Slightly modified TMethodCall class used in the object communication mechanism |
CTBits::TReference | |
CTMVA::DNN::TReference< AReal > | The reference architecture class |
CTRegexp | Regular expression class |
CTRF1 | |
CROOT::Math::Delaunay2D::Triangle | |
CROOT::Experimental::EveGlu::TriangleCollector | |
CROOT::Internal::TROOTAllocator | |
CTRootBrowserCursorSwitcher | |
CTRootIOCtor | |
CTRootSnifferScanRec | Structure used to scan hierarchies of ROOT objects |
CROOT::Internal::RootCling::TROOTSYSSetter | |
CTRotation::TRotationRow | |
CTRSA_fun | |
►Cstd::true_type | |
CROOT::Internal::VecOps::IsRVec< ROOT::VecOps::RVec< T > > | |
CTMVA::Experimental::Internal::and_types< Ts > | Type checking for all types of a parameter pack, e.g., used in combination with std::is_convertible |
Cis_specialization< Ref< Args... >, Ref > | |
CROOT::TRWSpinLock | |
CTRWSpinLock | An implementation of a read-write lock with an internal spin lock |
CROOT::TRWSpinLockReadGuard | |
CROOT::TRWSpinLockWriteGuard | |
CTSAXParserCallback | |
CROOT::Internal::TSchemaHelper | |
CROOT::Internal::TSchemaRuleProcessor | |
CROOT::Internal::TSchemaType | |
CROOT::TSeq< T > | A pseudo container class which is a generator of indices |
CTSessionDialogs | This file defines several dialogs that are used by TSessionViewer |
CTMVA::DNN::TSharedLayer< Architecture_t > | Layer class width shared weight and bias layers |
CTSimpleAnalysis | A TSimpleAnalysis object creates histograms from a TChain |
CRgl::Mc::TSlice< V > | |
CRgl::Mc::TSlice< ElementType_t > | |
CRgl::Mc::TSourceAdapterSelector< class > | |
CRgl::Mc::TSourceAdapterSelector< TF3 > | |
CRgl::Mc::TSourceAdapterSelector< TH3C > | |
CRgl::Mc::TSourceAdapterSelector< TH3D > | |
CRgl::Mc::TSourceAdapterSelector< TH3F > | |
CRgl::Mc::TSourceAdapterSelector< TH3I > | |
CRgl::Mc::TSourceAdapterSelector< TH3S > | |
CRgl::Mc::TSourceAdapterSelector< TKDEFGT > | |
CROOT::Internal::TSpinLockGuard | A spin mutex-as-code-guard class |
CROOT::TSpinMutex | A spin mutex class which respects the STL interface for mutexes |
CRgl::Mc::TSplitterSelector< class, class > | |
CRgl::Mc::TSplitterSelector< TF3, V > | |
CRgl::Mc::TSplitterSelector< TH3C, V > | |
CRgl::Mc::TSplitterSelector< TH3D, V > | |
CRgl::Mc::TSplitterSelector< TH3F, V > | |
CRgl::Mc::TSplitterSelector< TH3I, V > | |
CRgl::Mc::TSplitterSelector< TH3S, V > | |
CRgl::Mc::TSplitterSelector< TKDEFGT, V > | |
CTClassEdit::TSplitType | |
CTGenCollectionProxy::TStaging | Small helper to stage the content of an associative container when reading and before inserting it in the actual collection |
CROOT::Detail::TStatusBitsChecker | |
CTStatusBitsChecker | TStatusBitsChecker::Check and TStatusBitsChecker::CheckAllClasses will determine if the set of "status bit" declared in the class and its base classes presents any overlap |
CROOT::Internal::TStdBitsetHelper< T > | |
CROOT::Internal::TStlObjProxy< T > | |
CTStorage | Storage manager |
►CTString | Basic string class |
CTEveException | Exception class thrown by TEve classes and macros |
►CTGString | TGString wraps a TString and adds some graphics routines like drawing, size of string on screen depending on font, etc |
CTGHotString | TGHotString is a string with a "hot" character underlined |
CTStringLong | ATTENTION: this class is obsolete |
CTStringToken | Provides iteration through tokens of a given string |
CTSubString | A zero length substring is legal |
CTTabCom | |
CTTableRange | |
CROOT::Experimental::TTaskGroup | A class to manage the asynchronous execution of work items |
CTMVA::DNN::TTensorBatch< Architecture_t > | TTensorBatch |
CTMVA::DNN::TTensorBatchIterator< Data_t, Architecture_t > | TTensorBatchIterator |
CTMVA::DNN::TTensorDataLoader< Data_t, Architecture_t > | TTensorDataLoader |
CTMVA::DNN::TTensorDataLoader< AData, TReference< AReal > > | |
CTTF | Interface to the freetype 2 library |
CTTFX11Init | Small utility class that takes care of switching the current gVirtualX to the new TGX11TTF class as soon as the shared library containing this class is loaded |
CTTF::TTGlyph | TTF helper class containing glyphs description |
CTThreadCleaner | |
CROOT::TThreadedObject< T > | A wrapper to make object instances thread private, lazily |
CROOT::TThreadedObject< ROOT::Internal::TTreeView > | |
CTThreadPoolTask< aTask, aParam > | |
CTThreadPoolTaskImp< aTask, aParam > | |
CTThreadTearDownGuard | |
CTTime | Basic time type with millisecond precision |
CTTimeStamp | The TTimeStamp encapsulates seconds and ns since EPOCH |
CROOT::Experimental::REveDataItemList::TTip | |
CTMVA::MethodDNN::TTrainingSettings | |
CTMVA::TTrainingSettings | All of the options that can be specified in the training string |
CTTreeCloner | Class implementing or helping the various TTree cloning method |
►CROOT::Internal::TTreeGeneratorBase | Base class for code generators like TTreeProxyGenerator and TTreeReaderGenerator |
CROOT::Internal::TTreeProxyGenerator | |
CROOT::Internal::TTreeReaderGenerator | |
CROOT::TTreeProcessorMT | A class to process the entries of a TTree in parallel |
►CROOT::Internal::TTreeReaderValueBase | Base class of TTreeReaderValue |
CTTreeReaderValue< Float_t > | |
CTTreeReaderValue< int > | |
►CROOT::Internal::TTreeReaderArrayBase | Base class of TTreeReaderArray |
CTTreeReaderArray< int > | |
CTTreeReaderArray< Float_t > | |
CTTreeReaderArray< T > | An interface for reading collections stored in ROOT columnar datasets |
CROOT::Internal::TTreeReaderOpaqueValue | Read a value in a branch without knowledge of its type |
CTTreeReaderValue< T > | An interface for reading values stored in ROOT columnar datasets |
CTTreeReaderValueFast | Extracts data from a TTree |
►CROOT::Experimental::Internal::TTreeReaderValueFastBase | |
CROOT::Experimental::TTreeReaderValueFast< T > | |
CROOT::Experimental::TTreeReaderValueFast< Int_t > | |
CROOT::Experimental::TTreeReaderValueFast< UInt_t > | |
CROOT::Experimental::TTreeReaderValueFast< bool > | |
CROOT::Experimental::TTreeReaderValueFast< double > | |
CROOT::Experimental::TTreeReaderValueFast< float > | |
CROOT::Internal::TTreeView | |
CTTreeView | A helper class that encapsulates a file and a tree |
CTCling::TUniqueString | |
CTGLLockable::TUnlocker | |
CTUnuran | TUnuran class |
►CTUnuranBaseDist | TUnuranBaseDist, base class for Unuran distribution classes such as TUnuranContDist (for one-dimension) or TUnuranMultiContDist (multi-dimension) |
CTUnuranContDist | TUnuranContDist class describing one dimensional continuous distribution |
CTUnuranDiscrDist | TUnuranDiscrDist class for one dimensional discrete distribution |
CTUnuranEmpDist | TUnuranEmpDist class for describing empirical distributions |
CTUnuranMultiContDist | TUnuranMultiContDist class describing multi dimensional continuous distributions |
CTUtmpContent | |
CTUUID | This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDentifier) |
CROOT::Internal::RDF::TValueGetter | Helper class which keeps track for each slot where to get the entry |
CTVersionCheck | Used to check if the shared library or plugin is compatible with the current version of ROOT |
CTVirtualArray | Wrapper around an object and giving indirect access to its content even if the object is not of a class in the Cint/Reflex dictionary |
►CTVirtualAuth | |
CTRootAuth | |
CTVirtualCollectionIterators | Small helper class to generically acquire and release iterators |
►CTVirtualCollectionProxy | Defines a common interface to inspect/change the contents of an object that represents a collection |
►CTGenCollectionProxy | Proxy around an arbitrary container, which implements basic functionality and iteration |
CAnyCollectionProxy< T > | |
►CTEmulatedCollectionProxy | Streamer around an arbitrary STL like container, which implements basic container functionality |
CTEmulatedMapProxy | Streamer around a map container |
CTGenBitsetProxy | |
►CTGenCollectionStreamer | |
CAnyCollectionStreamer< T > | |
CTGenVectorBoolProxy | Local optimization class |
►CTGenVectorProxy | Local optimization class |
CTGenListProxy | |
►CTGenSetProxy | Localoptimization class |
CTGenMapProxy | Localoptimization class |
CTVirtualCollectionPtrIterators | |
CROOT::Internal::TVirtualCollectionReader | |
►CTVirtualDragManager | |
CTGuiBldDragManager | Drag and drop manager used by the ROOT GUI Builder |
CTVirtualGL | Abstract base class defining the OpenGL interface protocol |
►CTVirtualGLManip | |
►CTGLManip | Abstract base class for viewer manipulators, which allow direct in viewer manipulation of a (TGlPhysicalShape) object - currently translation, scaling and rotation along/round objects local axes |
CTGLRotateManip | Rotate manipulator - attaches to physical shape and draws local axes widgets - rings drawn from attached physical center, in plane defined by axis |
CTGLScaleManip | Scale manipulator - attaches to physical shape and draws local axes widgets with box heads |
CTGLTransManip | Translation manipulator - attaches to physical shape and draws local axes widgets with arrow heads |
►CTVirtualGLPainter | |
►CTGLPlotPainter | Base class for plot-painters that provide GL rendering of various 2D and 3D histograms, functions and parametric surfaces |
CTGL5DPainter | TGL5DPainter implements "gl5d" option for TTree::Draw |
CTGLBoxPainter | Paints TH3 histograms by rendering variable-sized boxes matching the bin contents |
CTGLH2PolyPainter | Paint TH2Poly |
CTGLIsoPainter | "gliso" option for TH3 |
CTGLLegoPainter | Plot-painter implementing LEGO rendering of TH2 histograms in cartesian, polar, cylindrical and spherical coordinates |
CTGLParametricPlot | |
CTGLSurfacePainter | Implements painting of TH2 with "SURF" option |
CTGLTF3Painter | Plot-painter for TF3 functions |
CTGLTH3CompositionPainter | |
CTGLVoxelPainter | Paint TH3 histograms as "voxels" - colored boxes, transparent if transfer function was specified |
►CTVirtualIsAProxy | |
CTInstrumentedIsAProxy< T > | |
CTIsAProxy | TIsAProxy implementation class |
CTVirtualMonitoring | Provides the interface for externel Monitoring |
►CTVirtualMutex | This class implements a mutex interface |
►CROOT::TVirtualRWMutex | |
CROOT::TRWMutexImp< MutexT, RecurseCountsT > | |
CTMutex | |
CTVirtualObject | Wrapper around an object and giving indirect access to its content even if the object is not of a class in the Cint/Reflex dictionary |
►CTVirtualPadEditor | Abstract base class used by ROOT graphics editor |
CTGedEditor | |
►CTVirtualPadPainter | To make it possible to use GL for 2D graphic in a TPad/TCanvas |
CTGLPadPainter | "Delegating" part of TGLPadPainter |
CTPadPainter | Implement TVirtualPadPainter which abstracts painting operations |
CTWebPadPainter | Implement TVirtualPadPainter which abstracts painting operations |
►CTVirtualPaveStats | |
CTPaveStats | The histogram statistics painter class |
►CTVirtualRefProxy | |
►CTRefProxy | |
CTRefArrayProxy | A container proxy, which allows to access references stored in a TRefArray from TTree::Draw |
►CTVirtualTableInterface | |
CTGSimpleTableInterface | TGSimpleTableInterface is a very simple implementation of a TVirtualTableInterface |
CTTreeTableInterface | TTreeTableInterface is used to interface to data that is stored in a TTree |
CTVirtualVectorIterators | |
CTWebMenuArgument | |
►CTWebMenuItem | Class contains info for producing menu item on the JS side |
CTWebArgsMenuItem | |
CTWebCheckedMenuItem | |
CTWebMenuItems | |
CTWebObjectOptions | Class used to transport drawing options from the client |
CTWebPadClick | Class used to transport pad click events |
CTWebPadOptions | Class used to transport ranges from JSROOT canvas |
CTWebSocket | |
CTWin32SplashThread | |
CTWin32ThreadCleanUp | |
►CTMVA::DNN::TWorkspace | |
CTMVA::DNN::CNN::TCNNWorkspace< Layer_t > | |
CTMVA::DNN::RNN::TRNNWorkspace< Layer_t > | |
CROOT::TWriteLockGuard | |
CTX11GLManager::TX11GLImpl | |
CTXMLInputStream | |
CTXMLOutputStream | |
►CTXMLSetup | |
CTBufferXML | Class for serializing/deserializing object to/from xml |
CTXMLFile | |
CTXMLStackObj | |
►Cstd::conditional::type | |
CZMQ::Detail::is_trivial< T > | |
►CTSourceAdapterSelector::Type_t | |
CRgl::Mc::TMeshBuilder< DataSource, ValueType > | |
►CTSourceAdapterSelector::Type_t | |
CRgl::Mc::TMeshBuilder< TKDEFGT, Float_t > | |
►CTSplitterSelector::Type_t | |
CRgl::Mc::TMeshBuilder< DataSource, ValueType > | |
►CTSplitterSelector::Type_t | |
CRgl::Mc::TMeshBuilder< TKDEFGT, Float_t > | |
CCPyCppyy::typedefpointertoclassobject | |
CROOT::Internal::TypedIter< T, WrappedIterator_t, isDynamic > | |
CROOT::TypeTraits::TypeList< Types > | Lightweight storage for a collection of types |
CTMVA::Types | Singleton class for Global types used by TMVA |
CTypeTraits | |
►Carrow::TypeVisitor | |
CROOT::RDF::RDFTypeNameGetter | Helper to get the contents of a given column |
CROOT::RDF::VerifyValidColumnType | Helper to determine if a given Column is a supported type |
CROOT::Math::UnaryOp< Operator, RHS, T > | UnaryOperation class A class representing unary operators in the parse tree |
CTMVA::Experimental::SOFIE::UnaryOpTraits< T, Op > | |
CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kCos > | |
CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kExp > | |
CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kLog > | |
CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kNeg > | |
CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kReciprocal > | |
CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kSin > | |
CTMVA::Experimental::SOFIE::UnaryOpTraits< T, EBasicUnaryOperator::kSqrt > | |
CRooRandomizeParamMCSModule::UniParam | |
CRooRandomizeParamMCSModule::UniParamSet | |
CRooFit::UniqueId< Class > | A UniqueId can be added as a class member to enhance any class with a unique identifier for each instantiated object |
CRooFit::UniqueId< RooAbsCollection > | |
CRooFit::UniqueId< RooAbsData > | |
CRooFit::UniqueId< RooArgSet > | |
CROOT::Internal::UniqueLockRecurseCount | |
Cbvh::v2::UnsignedInt< Bits > | Helper type that gives an unsigned integer type with the given number of bits |
Cbvh::v2::UnsignedInt< 16 > | |
Cbvh::v2::UnsignedInt< 32 > | |
Cbvh::v2::UnsignedInt< 64 > | |
Cbvh::v2::UnsignedInt< 8 > | |
CUnuranRng< Random > | UnuranRng class for interface ROOT random generators to Unuran |
CTTreeCacheUnzip::UnzipState | |
CROOT::Internal::Update | |
CRooFit::TestStatistics::LikelihoodJob::update_state_t | |
Cusa | |
CUserGroup_t | |
CClingMemberIterInternal::UsingDeclIter::UsingDeclFrame | |
CClingMemberIterInternal::UsingDeclIter | |
CTString::UStr_t | |
CRooSharedProperties::UUID | |
CTUUID::uuid_time_t | |
CROOT::Experimental::RAttrBase::Val_t | |
CCPyCppyy::Parameter::Value | |
CROOT::Internal::TCheckHashRecursiveRemoveConsistency::Value | |
CTGenCollectionProxy::Value | Small helper to describe the Value_type or the key_type of an STL container |
CValue | |
►CROOT::Experimental::RAttrMap::Value_t | |
CROOT::Experimental::RAttrMap::BoolValue_t | |
CROOT::Experimental::RAttrMap::DoubleValue_t | |
CROOT::Experimental::RAttrMap::IntValue_t | |
CROOT::Experimental::RAttrMap::NoValue_t | |
CROOT::Experimental::RAttrMap::StringValue_t | |
CROOT::RDF::RSqliteDS::Value_t | Used to hold a single "cell" of the SELECT query's result table. Can be changed to std::variant once available |
CROOT::Experimental::RAttrValue< T >::ValueExtractor< Q, bool > | |
CROOT::Experimental::RAttrValue< T >::ValueExtractor< Q, false > | |
CROOT::Internal::RDF::ValueType< T, IsDataContainer > | |
CROOT::Internal::RDF::ValueType< ROOT::VecOps::RVec< T >, false > | |
CROOT::Internal::RDF::ValueType< T, false > | |
CRooCmdConfig::Var< T > | |
CTMVA::VariableImportanceResult | |
CROOT::Minuit2::VariableMetricEDMEstimator | |
CTMVA::Config::VariablePlotting | |
CTMVA::TransformationHandler::VariableStat | |
CRooDataHist::VarInfo | Structure to cache information on the histogram variable that is frequently used for histogram weights retrieval |
CTMVA::MethodCFMlpANN_Utils::VARn2 | |
CTMVA::VarTransformHandler | |
►CROOT::Math::Vavilov | Base class describing a Vavilov distribution |
CROOT::Math::VavilovAccurate | Class describing a Vavilov distribution |
CROOT::Math::VavilovFast | Class describing a Vavilov distribution |
Cbvh::v2::Vec< T, N > | |
CROOT::Minuit2::vec | |
Cvec | |
CROOT::Math::VecExpr< ExprType, T, D > | Expression wrapper class for Vector objects |
►Cstd::vector< T > | STL class |
CTGL2DArray< TGLParametricPlot::Vertex_t > | |
CTGL2DArray< TGLVertex3 > | |
CTGL2DArray< double > | |
CTGL2DArray< TGLVector3 > | |
CTGL2DArray< T > | |
►Cstd::vector< const TSchemaRule * > | |
CROOT::Detail::TSchemaRuleSet::TMatches | |
►Cstd::vector< std::pair< RooArgSet *, RooArgList * > > | |
CRooProduct::ProdMap | |
►Cstd::vector< std::shared_ptr< xRooNode > > | |
CROOT::Experimental::XRooFit::xRooNode | Designed to wrap over a TObject and provide functionality to aid with interacting with that object, particularly in the case where the object is a RooFit class instance |
►Cstd::vector< std::vector< double > > | |
CVecVecDouble | |
►Cstd::vector< TVectorD > | |
CVecTVecDouble | |
►Cstd::vector< xRooHypoPoint > | |
CROOT::Experimental::XRooFit::xRooNLLVar::xRooHypoSpace | |
CROOT::Math::VectorMatrixColOp< Vector, Matrix, D1 > | Class for Vector-Matrix multiplication |
CROOT::Math::VectorMatrixRowOp< Matrix, Vector, D2 > | |
CROOT::Minuit2::VectorOuterProduct< M, T > | |
CROOT::Math::VegasParameters | Structures collecting parameters for VEGAS multidimensional integration For implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h |
CROOT::Geom::Vertex_t | |
CTGLParametricPlot::Vertex_t | |
►CTMVA::DNN::VGeneralLayer< Architecture_t > | Generic General Layer class |
CTMVA::DNN::CNN::TConvLayer< Architecture_t > | |
CTMVA::DNN::CNN::TMaxPoolLayer< Architecture_t > | Generic Max Pooling Layer class |
CTMVA::DNN::RNN::TBasicGRULayer< Architecture_t > | |
CTMVA::DNN::RNN::TBasicLSTMLayer< Architecture_t > | |
CTMVA::DNN::RNN::TBasicRNNLayer< Architecture_t > | |
CTMVA::DNN::TBatchNormLayer< Architecture_t > | Layer implementing Batch Normalization |
CTMVA::DNN::TDenseLayer< Architecture_t > | Generic layer class |
CTMVA::DNN::TReshapeLayer< Architecture_t > | |
►CROOT::Math::VirtualIntegrator | Abstract class for all numerical integration methods (1D and multi-dim) Interface defining the common methods for the numerical integrator classes of one and multi dimensions The derived class VirtualIntegratorOneDim defines the methods for one-dimensional integration |
►CROOT::Math::VirtualIntegratorMultiDim | Interface (abstract) class for multi numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLMCIntegrator |
CROOT::Math::AdaptiveIntegratorMultiDim | Class for adaptive quadrature integration in multi-dimensions using rectangular regions |
CROOT::Math::GSLMCIntegrator | |
►CROOT::Math::VirtualIntegratorOneDim | Interface (abstract) class for 1D numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLIntegrator |
CROOT::Math::GSLIntegrator | Class for performing numerical integration of a function in one dimension |
►CROOT::Math::GaussIntegrator | User class for performing function integration |
CROOT::Math::GaussLegendreIntegrator | User class for performing function integration |
►CVisual | |
CRVisual | |
CRVisual | |
CRVisual | |
CTMVA::Volume | Volume for BinarySearchTree |
►CTMVA::DNN::VOptimizer< Architecture_t, Layer_t, DeepNet_t > | Generic Optimizer class |
CTMVA::DNN::TAdadelta< Architecture_t, Layer_t, DeepNet_t > | Adadelta Optimizer class |
CTMVA::DNN::TAdagrad< Architecture_t, Layer_t, DeepNet_t > | Adagrad Optimizer class |
CTMVA::DNN::TAdam< Architecture_t, Layer_t, DeepNet_t > | Adam Optimizer class |
CTMVA::DNN::TRMSProp< Architecture_t, Layer_t, DeepNet_t > | RMSProp Optimizer class |
CTMVA::DNN::TSGD< Architecture_t, Layer_t, DeepNet_t > | Stochastic Batch Gradient Descent Optimizer class |
CTMVA::DNN::VOptimizer< Architecture_t, VGeneralLayer< Architecture_t >, TDeepNet< Architecture_t, VGeneralLayer< Architecture_t > > > | |
CROOT::Experimental::RCanvasPainter::WebCommand | |
CROOT::Experimental::RCanvasPainter::WebConn | |
CROOT::RWebWindow::WebConn | |
CTWebCanvas::WebConn | |
CWebFont_t | |
Cwebsocket_client_thread_data | |
CROOT::Experimental::RCanvasPainter::WebUpdate | |
CROOT::MacOSX::X11::CommandBuffer::WidgetRect | |
CWindowAttributes_t | Window attributes that can be inquired |
CTStreamerInfoActions::WithFactorMarker< From > | |
Cbvh::v2::TopDownSahBuilder< Node >::WorkItem | |
CRooFit::TestStatistics::WrapperCalculationCleanFlags | For communication with wrappers, an instance of this struct must be shared between them and MinuitFcnGrad |
CTStreamerInfoActions::GenericLooper::Write_WithoutFastArray_ConvertBasicType< To, From > | |
CTStreamerInfoActions::GenericLooper::WriteConvertBasicType< Onfile, Memory, Converter > | |
CTStreamerInfoActions::VectorLooper::WriteConvertBasicType< Onfile, Memory > | |
CTStreamerInfoActions::VectorPtrLooper::WriteConvertBasicType< To, From > | |
CTStreamerInfoActions::WriteConvertBasicType< Onfile, Memory > | |
CTStreamerInfoActions::VectorLooper::WriteConvertBasicType< NoFactorMarker< Onfile >, Memory > | |
CTStreamerInfoActions::GenericLooper::WriteConvertBasicType< NoFactorMarker< Onfile >, Memory, Converter > | |
CTStreamerInfoActions::VectorPtrLooper::WriteConvertBasicType< NoFactorMarker< To >, From > | |
CTStreamerInfoActions::VectorLooper::WriteConvertBasicType< WithFactorMarker< Onfile >, Memory > | |
CTStreamerInfoActions::GenericLooper::WriteConvertBasicType< WithFactorMarker< Onfile >, Memory, Converter > | |
CTStreamerInfoActions::VectorPtrLooper::WriteConvertBasicType< WithFactorMarker< To >, From > | |
CTStreamerInfoActions::AssociativeLooper::WriteConvertCollectionBasicType< Memory, Onfile > | |
CTStreamerInfoActions::GenericLooper::WriteConvertCollectionBasicType< Memory, Onfile > | |
CTStreamerInfoActions::VectorLooper::WriteConvertCollectionBasicType< Memory, Onfile > | |
CTStreamerInfoActions::AssociativeLooper::WriteConvertCollectionBasicType< Memory, NoFactorMarker< Onfile > > | |
CTStreamerInfoActions::AssociativeLooper::WriteConvertCollectionBasicType< Memory, WithFactorMarker< Onfile > > | |
CTStreamerInfoActions::CollectionLooper< Looper >::WriteStreamerLoop< kIsTextT, Ts > | |
►C<X11Drawable> | |
CQuartzImage | |
CQuartzPixmap | |
►C<X11Window> | |
CQuartzView | |
CQuartzWindow | |
►CXColor | |
CRXColor | |
CRXColor | |
CRXColor | |
CXColor_t | Description of a X11 color |
►CXGCValues | |
CRXGCValues | |
CRXGCValues | |
►CXImage | |
CRXImage | |
CRXImage | |
CXLFDAttributes_t | |
CROOT::MacOSX::X11::XLFDName | |
CTMVA::Experimental::Internal::XMLConfig | Container for information extracted from TMVA XML config |
CXMLReader | |
►CXpmAttributes | |
CRXpmAttributes | |
CROOT::Experimental::XRooFit::xRooFit | |
►CXSetWindowAttributes | |
CRXSetWindowAttributes | |
CXShapeEvent | |
►CXVisualInfo | |
CRXVisualInfo | |
CXWindow_t | Description of a X11 window |
CTGDMLWrite::Xyz | |
CTMemFile::ZeroCopyView_t | A read-only memory range which we do not control |
CZeroMQPoller | Wrapper class for polling ZeroMQ sockets |
CZeroMQSvc | Wrapper class for basic ZeroMQ context and socket management |
CZmqLingeringSocketPtrDeleter< PERIOD > | |
CAReal | |
►CROOT::Experimental::Detail::BASES | |
CROOT::Experimental::Detail::RHistBinStat< DATA, BASES > | Const view on a bin's statistical data |
Cbool | |
CCGContextRef | |
CCGImageRef | |
Cdouble | |
CEAlign | |
CECorner | |
CEngineType * | |
CEStyle | |
CFloat_t | |
►CFunctionType | |
CROOT::Math::BasicFitMethodFunction< FunctionType > | FitMethodFunction class Interface for objective functions (like chi2 and likelihood used in the fit) In addition to normal function interface provide interface for calculating each data contribution to the function which is required by some algorithm (like Fumili) |
Cint | |
CLong64_t | |
CMutexT | |
CR | |
CULong64_t | |
Cunsigned int | |
►CXPoint | |
CRXPoint | |