Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

►Nbvh
►Nv2
CBBox
►CBinnedSahBuilder	Single-threaded top-down builder that partitions primitives based on a binned approximation of the Surface Area Heuristic (SAH)
CBin
CSplit
CBvh
►CDefaultBuilder	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
CConfig
CExecutor	Helper object that provides iteration and reduction over one-dimensional ranges
CGrowingStack	Growing stack that can be used for BVH traversal
CIgnoreArgs	Helper callable object that just ignores its arguments and returns nothing
CIndex	Packed index data structure
CInputStream	Stream of data that can be used to deserialize data structures
►CMiniTreeBuilder	Multi-threaded top-down builder that partitions primitives using a grid
CBin
CBuildTask
CConfig
CLocalBins
CNode	Binary BVH node, containing its bounds and an index into its children or the primitives it contains
COctant
COutputStream	Stream of data that can be used to serialize data structures
CParallelExecutor	Executor that executes in parallel using the given thread pool
CRay
►CReinsertionOptimizer
CCandidate
CConfig
CReinsertion
CSequentialExecutor	Executor that executes serially
CSmallStack	Fixed-size stack that can be used for a BVH traversal
CSplitHeuristic
CStdInputStream	Stream adapter for standard library input streams
CStdOutputStream	Stream adapter for standard library output streams
►CSweepSahBuilder	Single-threaded top-down builder that partitions primitives based on the Surface Area Heuristic (SAH)
CSplit
CThreadPool
►CTopDownSahBuilder	Base class for all SAH-based, top-down builders
CConfig
CWorkItem
CUnsignedInt	Helper type that gives an unsigned integer type with the given number of bits
CUnsignedInt< 16 >
CUnsignedInt< 32 >
CUnsignedInt< 64 >
CUnsignedInt< 8 >
CVec
►NClingMemberIterInternal
CDCIter	Iteration over collected DeclContexts
►CUsingDeclIter
CUsingDeclFrame
►NCppyyLegacy
CExceptionContext_t
►NCPyCppyy
►NUtility
►CPyError_t
CPyObjectDeleter
CPyOperators
►CCallContext
CTemporary
CCallContextRAII
CConverter
CCPPAbstractClassConstructor
CCPPAllPrivateClassConstructor
CCPPClassMethod
CCPPConstructor
CCPPDataMember
CCPPExcInstance
CCPPFunction
CCPPGetItem
CCPPIncompleteClassConstructor
CCPPInstance
CCPPMethod
CCPPMultiConstructor
CCPPNamespaceConstructor
CCPPOperator
►CCPPOverload
CMethodInfo_t
CCPPReverseBinary
CCPPScope
CCPPSetItem
CCPPSmartClass
CDimensions
CDispatchPtr
CExecutor
Cindexiterobject
CInstancePtrConverter
CLowLevelView
CMemoryRegulator
►CParameter
CValue
Cproxyobject
CPyCallable
CPyCallArgs
CPyException
CPyResult
CRefExecutor
CStrictInstancePtrConverter
CTemplateInfo
CTemplateProxy
Ctypedefpointertoclassobject
Cvectoriterobject
CVoidArrayConverter
►NOuter
CInner
CTemplate
CTemplate< Inner, 1 >	Simple specialisation
CTemplate< Template< Inner, 2 >, 1 >	Complex specialisation
►NPyROOT
CPyObjRefCounter	A PyObject wrapper to track reference counting of external objects
CRPyROOTApplication	Interactive application for Python
►NReadSpeed
CArgs
CByteData
CData
CEntryRange
CReadSpeedRegex
CResult
►NRgl
►NFgt
CTKDEAdapter
►NMc
CTCell
CTDefaultSplitter
CTF3Adapter
CTF3EdgeSplitter
CTGridGeometry
CTH3Adapter
CTIsoMesh
CTMeshBuilder
CTSlice
CTSourceAdapterSelector
CTSourceAdapterSelector< TF3 >
CTSourceAdapterSelector< TH3C >
CTSourceAdapterSelector< TH3D >
CTSourceAdapterSelector< TH3F >
CTSourceAdapterSelector< TH3I >
CTSourceAdapterSelector< TH3S >
CTSourceAdapterSelector< TKDEFGT >
CTSplitterSelector
CTSplitterSelector< TF3, V >
CTSplitterSelector< TH3C, V >
CTSplitterSelector< TH3D, V >
CTSplitterSelector< TH3F, V >
CTSplitterSelector< TH3I, V >
CTSplitterSelector< TH3S, V >
CTSplitterSelector< TKDEFGT, V >
►NPad
CBoundingRect
CFillAttribSet
CGLLimits
CLineAttribSet
CMarkerPainter
CMeshPatch_t
COffScreenDevice
CPolygonStippleSet
CTesselator
CPlotTranslation
CTGuardBase
CTOneArgGuard
CTTwoArgsGuard
►NRooBatchCompute	Namespace for dispatching RooFit computations to various backends
►NCUDA
CRooBatchComputeClass	This class overrides some RooBatchComputeInterface functions, for the purpose of providing a cuda specific implementation of the library
►NCudaInterface
CArray	A templated class for managing an array of data using a specified memory type
CCudaEvent
CCudaStream
CAbsBuffer
CAbsBufferManager
CBatch
CBatches
CBracketAdapter	Little adapter that gives a bracket operator to types that don't have one
CBracketAdapterWithMask
CConfig	Minimal configuration struct to steer the evaluation of a single node with the RooBatchCompute library
CReduceNLLOutput
CRooBatchComputeInterface	The interface which should be implemented to provide optimised computation functions for implementations of RooAbsReal::doEval()
►NRooFit	The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or other types of arguments)
►NDetail
CCompileContext
CDataKey
CFlatMap
CHashAssistedFind	Helper for hash-map-assisted finding of elements by name
►CJSONNode
►Cchild_iterator_t
CImpl
Cchildren_view_t
CJSONTree
CRooAbsDataFiller
CRooFixedProdPdf	A RooProdPdf with a fixed normalization set can be replaced by this class
CRooNormalizedPdf
CRooPyBind
►NExperimental
►CCodegenContext	A class to maintain the context for squashing of RooFit models into code
CLoopScope	A class to manage loop scopes using the RAII technique
CScopeRAII
CCodegenIntegralImplCaller
CPrio
►CRooFuncWrapper	A wrapper class to store a C++ function of type 'double (*)(double*, double*)'
CObsInfo
►NJSONIO
►NDetail
►CDomains
►CProductDomain
CProductDomainElement
CExporter
CExportKeys
CImporter
CImportExpression
►NMultiProcess
►NDetail
CHeatmapAnalyzerJsonData
►CConfig	Configuration for MultiProcess infrastructure
CLikelihoodJob
CQueue
CFIFOQueue	A Queue with simple FIFO behavior
CHeatmapAnalyzer	Reads and processes logfiles produced by RooFit::MultiProcess::ProcessTimer
CJob	Interface class for defining the actual work that must be done
CJobManager	Main point of access for all MultiProcess infrastructure
CJobTask	Combined job_object, state and task identifier type
CMessenger	Manages ZeroMQ sockets and wraps send and receive calls
COrderedJobTask
CPriorityQueue	Queue that orders tasks according to specified task priorities
CProcessManager	Fork processes for queue and workers
CProcessTimer	Can be used to generate timings of multiple processes simultaneously and output logs
CQueue	Keeps a queue of tasks for workers and manages the queue process through its event loop
►NTestStatistics	Namespace for new RooFit test statistic calculation
CConstantTermsOptimizer	Analyzes a function given a dataset/observables for constant terms and caches those in the dataset
►CLikelihoodGradientJob
Ctask_result_t
CLikelihoodGradientWrapper	Virtual base class for implementation of likelihood gradient calculation strategies
►CLikelihoodJob
Ctask_result_t
Cupdate_state_t
CLikelihoodSerial	Serial likelihood calculation strategy implementation
CLikelihoodWrapper	Virtual base class for implementation of likelihood calculation strategies
CMinuitFcnGrad	Minuit-RooMinimizer interface which synchronizes parameter data and coordinates evaluation of likelihood (gradient) values
CNLLFactory
►CRooAbsL
CClonePdfData	Convenience wrapper class used to distinguish between pdf/data owning and non-owning constructors
CSection	A part of some range delimited by two fractional points between 0 and 1 (inclusive)
CRooBinnedL
CRooRealL	RooAbsReal that wraps RooAbsL likelihoods for use in RooFit outside of the RooMinimizer context
CRooSubsidiaryL
CRooSumL	Likelihood class that sums over multiple -log components
CRooUnbinnedL
CWrapperCalculationCleanFlags	For communication with wrappers, an instance of this struct must be shared between them and MinuitFcnGrad
CEvalBackend
CEvalContext
CEvaluator	Evaluates a RooAbsReal object in other ways than recursive graph traversal
CNodeInfo	A struct used by the Evaluator to store information on the RooAbsArgs in the computation graph
CUniqueId	A UniqueId can be added as a class member to enhance any class with a unique identifier for each instantiated object
►NRooHelpers
CBinnedLOutput
CHijackMessageStream	Hijacks all messages with given level and topic (and optionally object name) while alive
CLocalChangeMsgLevel	Switches the message service to a different level while the instance is alive
CWrapIntoTObject	Wrap an object into a TObject. Sometimes needed to avoid reinterpret_cast or enable RTTI
►NRooStats	Namespace for the RooStats classes
►NHistFactory
►NDetail
CCreateGammaConstraintsOutput
CAsimov	TODO Here, we are missing some documentation
CChannel	This class encapsulates all information for the statistical interpretation of one experiment
CConfigParser	TODO Add documentation
CData
CFlexibleInterpVar
Chf_exc
CHistFactoryNavigation
CHistoFactor	Configuration for an *un*constrained, coherent shape variation of affected samples
CHistogramUncertaintyBase	////////////////////////////////////////////////////////////////////////////////////////////Base class to store the up and down variations for histogram uncertainties
CHistoSys	Configuration for a constrained, coherent shape variation of affected samples
►CHistoToWorkspaceFactoryFast	This class provides helper functions for creating likelihood models from histograms
CConfiguration	Configuration settings for HistFactory behavior
CHistRef	Internal class wrapping an histogram and managing its content
CLinInterpVar	RooAbsReal that does piecewise-linear interpolations
CMeasurement	The RooStats::HistFactory::Measurement class can be used to construct a model by combining multiple RooStats::HistFactory::Channel objects
CNormFactor	Configuration for an un- constrained overall systematic to scale sample normalisations
COverallSys	Configuration for a constrained overall systematic to scale sample normalisations
CPreprocessFunction
►CRooBarlowBeestonLL	Class RooBarlowBeestonLL implements the profile likelihood estimator for a given likelihood and set of parameters of interest
CBarlowCache
CSample
CShapeFactor	*Un*constrained bin-by-bin variation of affected histogram
CShapeSys	Constrained bin-by-bin variation of affected histogram
CStatError	Statistical error of Monte Carlo predictions
CStatErrorConfig	Configuration to automatically assign nuisance parameters for the statistical error of the Monte Carlo simulations
CAcceptanceRegion
CAsymptoticCalculator	Hypothesis Test Calculator based on the asymptotic formulae for the profile likelihood ratio
CBayesianCalculator	BayesianCalculator is a concrete implementation of IntervalCalculator, providing the computation of a credible interval using a Bayesian method
CBernsteinCorrection	BernsteinCorrection is a utility in RooStats to augment a nominal PDF with a polynomial correction term
CBranchStore
CCombinedCalculator	CombinedCalculator is an interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals
CConfidenceBelt	ConfidenceBelt is a concrete implementation of the ConfInterval interface
CConfInterval	ConfInterval is an interface class for a generic interval in the RooStats framework
CDebuggingSampler
CDebuggingTestStat
CDetailedOutputAggregator	This class is designed to aid in the construction of RooDataSets and RooArgSets, particularly those naturally arising in fitting operations
CFeldmanCousins	(like the Feldman-Cousins technique) is essentially a specific configuration of the more general NeymanConstruction
CFrequentistCalculator	Does a frequentist hypothesis test
CHeaviside	Represents the Heaviside function
CHLFactory	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
CHybridCalculator	Same purpose as HybridCalculatorOriginal, but different implementation
CHybridPlot	This class provides the plots for the result of a study performed with the HybridCalculatorOriginal class
CHybridResult	Class encapsulating the result of the HybridCalculatorOriginal
CHypoTestCalculator	HypoTestCalculator is an interface class for a tools which produce RooStats HypoTestResults
CHypoTestCalculatorGeneric	Common base class for the Hypothesis Test Calculators
CHypoTestInverter	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
CHypoTestInverterPlot	Class to plot a HypoTestInverterResult, the output of the HypoTestInverter calculator
CHypoTestInverterResult	HypoTestInverterResult class holds the array of hypothesis test results and compute a confidence interval
CHypoTestPlot	This class provides the plots for the result of a study performed with any of the HypoTestCalculatorGeneric (e.g
CHypoTestResult	HypoTestResult is a base class for results from hypothesis tests
CIntervalCalculator	IntervalCalculator is an interface class for a tools which produce RooStats ConfIntervals
CLikelihoodFunction
CLikelihoodInterval	LikelihoodInterval is a concrete implementation of the RooStats::ConfInterval interface
CLikelihoodIntervalPlot	This class provides simple and straightforward utilities to plot a LikelihoodInterval object
CMarkovChain	Stores the steps in a Markov Chain of points
CMaxLikelihoodEstimateTestStat	MaxLikelihoodEstimateTestStat: TestStatistic that returns maximum likelihood estimate of a specified parameter
CMCMCCalculator	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
CMCMCInterval	MCMCInterval is a concrete implementation of the RooStats::ConfInterval interface
CMCMCIntervalPlot	This class provides simple and straightforward utilities to plot a MCMCInterval object
CMetropolisHastings	This class uses the Metropolis-Hastings algorithm to construct a Markov Chain of data points using Monte Carlo
CModelConfig	ModelConfig is a simple class that holds configuration information specifying how a model should be used in the context of various RooStats tools
CNeymanConstruction	NeymanConstruction is a concrete implementation of the NeymanConstruction interface that, as the name suggests, performs a NeymanConstruction
CNuisanceParametersSampler	Helper class for ToyMCSampler
CNumberCountingPdfFactory	A factory for building PDFs and data for a number counting combination
CNumEventsTestStat	NumEventsTestStat is a simple implementation of the TestStatistic interface used for simple number counting
CPdfProposal	PdfProposal is a concrete implementation of the ProposalFunction interface
CPointSetInterval	PointSetInterval is a concrete implementation of the ConfInterval interface
CPosteriorCdfFunction
CPosteriorFunction
CPosteriorFunctionFromToyMC	Posterior function obtaining sampling toy MC for the nuisance according to their pdf
CProfileInspector	Utility class to plot conditional MLE of nuisance parameters vs
CProfileLikelihoodCalculator	The ProfileLikelihoodCalculator is a concrete implementation of CombinedCalculator (the interface class for tools which can produce both a RooStats HypoTestResult and ConfInterval)
CProfileLikelihoodTestStat	ProfileLikelihoodTestStat is an implementation of the TestStatistic interface that calculates the profile likelihood ratio at a particular parameter point given a dataset
CProposalFunction	ProposalFunction is an interface for all proposal functions that would be used with a Markov Chain Monte Carlo algorithm
CProposalHelper
CRatioOfProfiledLikelihoodsTestStat	TestStatistic that returns the ratio of profiled likelihoods
CRooStatsConfig
CSamplingDistPlot	This class provides simple and straightforward utilities to plot SamplingDistribution objects
CSamplingDistribution	This class simply holds a sampling distribution of some test statistic
CSamplingSummary
CSamplingSummaryLookup
CSequentialProposal	Class implementing a proposal function that samples the parameter space by moving only in one coordinate (chosen randomly) at each step
CSimpleInterval	SimpleInterval is a concrete implementation of the ConfInterval interface
CSimpleLikelihoodRatioTestStat	TestStatistic class that returns -log(L[null] / L[alt]) where L is the likelihood
CSPlot	A class to calculate "sWeights" used to create an "sPlot"
CTestStatistic	TestStatistic is an interface class to provide a facility for construction test statistics distributions to the NeymanConstruction class
CTestStatSampler	TestStatSampler is an interface class for a tools which produce RooStats SamplingDistributions
CToyMCImportanceSampler	ToyMCImportanceSampler is an extension of the ToyMCSampler for Importance Sampling
CToyMCSampler	ToyMCSampler is an implementation of the TestStatSampler interface
CUniformProposal	UniformProposal is a concrete implementation of the ProposalFunction interface for use with a Markov Chain Monte Carlo algorithm
CUpperLimitMCSModule	This class allow to compute in the ToyMcStudy framework the ProfileLikelihood upper limit for each toy-MC sample generated
►NROOT	Tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tbb::task_arena without forward declaring tbb::interface7
►NBrowsable
CRAnyObjectHolder	Holder of any object instance
CRElement	Basic element of browsable hierarchy
CRGroup	Group of browsable elements - combines several different elements together
CRHolder	Basic class for object holder of any kind
CRItem	Representation of single item in the browser
CRLevelIter	Iterator over single level hierarchy like any array, keys list, ..
►CRProvider	Provider of different browsing methods for supported classes
CClassArg
CProgressHandle
CStructBrowse
CStructClass
CStructDraw6
CStructDraw7
CStructFile
CStructProgress
CRShared
CRSysDirLevelIter	Iterator over files in in sub-directory
CRSysFile
CRSysFileItem	Representation of single item in the file browser
CRUnique
CRWrapper	Wrapper for other element - to provide different name
CTGeoBrowseProvider	Provider for TGeo browsing
CTGeoManagerElement	Representing TGeoManager in browsables
CTGeoNodeElement	Representing TGeoNode in browsables
CTGeoVolumeElement	Representing TGeoVolume in browsables
CTGeoVolumeIter	Iterating over nodes in the volume
CTKeyItem	Representation of single item in the file browser for object from TKey
CTObjectElement	Access to TObject basic properties for RBrowsable
CTObjectHolder	Holder of TObject instance
CTObjectItem	Representation of single item in the file browser for generic TObject object
►NDetail	Special implementation of ROOT::RRangeCast for TCollection, including a check that the cast target type inherits from TObject and a new constructor that takes the TCollection by pointer
►NRDF
►NExtraArgsForDefine
CNone
CSlot
CSlotAndEntry
CRActionImpl	Base class for action helpers, see RInterface::Book() for more information
CRCallCleanUpTask	A RAII object that calls RLoopManager::CleanUpTask at destruction
CRColumnReaderBase
CRDefaultValueFor	The implementation of the DefaultValueFor transformation
CRDefine
CRDefineBase
CRDefinePerSample
CRFilter
CRFilterBase
CRFilterWithMissingValues	Implementation of FilterAvailable and FilterMissing operations
CRInferredType
CRJittedDefine	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
CRJittedFilter	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
CRLoopManager	The head node of a RDF computation graph
CRMergeableCount	Specialization of RMergeableValue for the Count action
CRMergeableFill	Specialization of RMergeableValue for histograms and statistics
CRMergeableMax
CRMergeableMean	Specialization of RMergeableValue for the Mean action
CRMergeableMin
CRMergeableStdDev	Specialization of RMergeableValue for the StdDev action
CRMergeableSum
CRMergeableValue	A result of an RDataFrame execution, that knows how to merge with other results of the same type
CRMergeableValueBase	Base class of RMergeableValue
CRMergeableVariations	A container for variation names and variation results that knows how to merge with others of the same type
CRMergeableVariationsBase	A container for variation names and variation results
CRNodeBase	Base class for non-leaf nodes of the computational graph
CRRange
CRRangeBase
►NVecOps
CRVecImpl	This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter
CCallableTraitsImpl	Extract types from the signature of a callable object. See CallableTraits
CCallableTraitsImpl< R(*)(Args...), false >
CCallableTraitsImpl< R(Args...), false >
CCallableTraitsImpl< R(T::*)(Args...) const, false >
CCallableTraitsImpl< R(T::*)(Args...), false >
CCallableTraitsImpl< T, true >
Cindices
Cis_array_class
Cmake_indices_
Cmake_indices_impl
Cmake_indices_next
Cmake_indices_next2
Cmake_indices_next2< indices< Indices... >, Next, Tail >
Cmake_indices_next< indices< Indices... >, Next >
CRFieldVisitor	Abstract base class for classes implementing the visitor design pattern
CRLogBuilder	Builds a diagnostic entry, emitted by the static RLogManager upon destruction of this builder, where - by definition - the RLogEntry has been completely built
CTBranchProxy	Base class for all the proxy object
►CTCollectionProxyInfo
CAddress
CEnviron	Small helper to save proxy environment in the event of recursive calls
CEnvironBase
CInsert	Small helper to encapsulate all necessary data accesses for containers like set, multiset etc
CIterators	Small helper to implement the function to create,access and destroy iterators
CIterators< Cont_t, true >
CIteratorValue	Small helper to encapsulate whether to return the value pointed to by the iterator or its address
CIteratorValue< Cont_t, value_ptr * >
CMapInsert	Small helper to encapsulate all necessary data accesses for containers like set, multiset etc
CPairHolder
CPushback	Small helper to encapsulate all necessary data accesses for containers like vector, list, deque
CPushback< Internal::TStdBitsetHelper< Bitset_t > >
CPushfront	Small helper to encapsulate all necessary data accesses for containers like forward_list
CSfinaeHelper
CType	Small helper to encapsulate basic data accesses for all STL continers
►CType< Internal::TStdBitsetHelper< Bitset_t > >
►CIterators
CPtrSize_t
►CTKeyMapIterable
CTIterator
CTKeyMapNode
CTRangeCast
►CTSchemaRuleSet
CTMatches
►CTStatusBitsChecker
►CRegistry
CInfo
►NDetails
CRWebWindowPlugin
►NExecutorUtils	This namespace contains pre-defined functions to be used in conjuction with TExecutor::Map and TExecutor::MapReduce
CReduceObjects	Merge collection of TObjects
►NExperimental
►NDetail
CRArgsMenuItem	Menu item which requires extra arguments for invoked class method
CRCheckedMenuItem	Menu item with check box
CRMenuArgument	Argument description for menu item which should invoke class method
CRMenuItem	Base class for menu items, shown on JS side
CRNTupleAtomicCounter	A thread-safe integral performance counter
CRNTupleCalcPerf	A metric element that computes its floating point value from other counters
CRNTupleMetrics	A collection of Counter objects with a name, a unit, and a description
CRNTuplePerfCounter	A performance counter with a name and a unit, which can be activated on demand
CRNTuplePlainCounter	A non thread-safe integral performance counter
CRNTupleTickCounter	A counter for CPU ticks
CRNTupleTimer	Record wall time and CPU time between construction and destruction
CRRawPtrWriteEntry	A container of const raw pointers, corresponding to a row in the data set
►NEveGlu
CTestTriangleHandler	TestTriangleHandler is just helper class to get access to protected members of TriangleCollector Hide static declarations, let use "native" GL types
CTriangleCollector
►NInternal
CRColumnMergeInfo
►CRDaosContainer	A RDaosContainer provides read/write access to objects in a given container
►CROidDkeyPair	A pair of <object ID, distribution key> that can be used to issue a fetch/update request for multiple attribute keys
CHash
CRWOperation	Describes a read/write operation on multiple attribute keys under the same object ID and distribution key, see the ReadV/WriteV functions
CRDaosEventQueue
CRDaosNTupleAnchor	Entry point for an RNTuple in a DAOS container
►CRDaosObject	Provides low-level access to DAOS objects in a container
CFetchUpdateArgs	Contains required information for a single fetch/update operation
CObjClassId	Wrap around a daos_oclass_id_t
CRAkeyRequest	Contains an attribute key and the associated IOVs for a single scatter-gather I/O request
CRDaosPool	A RDaosPool provides access to containers in a specific DAOS pool
CRIOShared
CRIOSharedBase
►CRNTupleExporter
CRFilter
CRPagesOptions
CRPagesResult
CRNTupleImtTaskScheduler
►CRNTupleJoinTable	Builds a join table on one or several fields of an RNTuple so it can be joined onto other RNTuples
►CREntryMapping	Provides a mapping from one or several join field values to an entry index
CRCombinedJoinFieldValue	Container for the combined hashes of join field values
CRCombinedJoinFieldValueHash	Hash combining the individual join field value hashes from RCombinedJoinFieldValue
CRNTupleMergeData
CRNTupleMergeOptions	Set of merging options to pass to RNTupleMerger
CRNTupleMerger	Given a set of RPageSources merge them into an RPagePersistentSink, optionally changing their compression
CRPageNullSink	Dummy sink that discards all pages
CRPageSinkDaos	Storage provider that writes ntuple pages to into a DAOS container
CRPageSourceDaos	Storage provider that reads ntuple pages from a DAOS container
CRSealedPageMergeData
►CRVirtualCanvasPainter	Abstract interface for painting a canvas
CGenerator
CTBulkBranchRead	Helper class for reading many branch entries at once to optimize throughput
CTTreeReaderValueFastBase
►NXRooFit	xRooFit is a high-level API for RooFit
CxRooBrowser	A version of the TBrowser that can be used to interact with RooFit models and datasets
►CxRooFit
CAsymptotics
CStoredFitResult
CTestStatistic
CxRooHypoSpace
►CxRooNLLVar	This xRooNLLVar object has several special methods, e.g
CxRooFitResult
CxRooHypoPoint
CxRooHypoSpace
CxValueWithError
►CxRooNode	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
CInteractiveObject
CxRooNodeIterator
CRAttrAggregation	Base class for attributes aggregations like lines or fill attributes
CRAttrAxis	All supported axes attributes for: line, ticks, labels, title, min/max, log, reverse, ..
CRAttrAxisLabels	Axis labels drawing attributes
CRAttrAxisTicks	Axis ticks attributes
CRAttrAxisTitle	Axis title and its drawing attributes
►CRAttrBase	Base class for all attributes, used with RDrawable
CRec_t
CVal_t
CRAttrBorder	Drawing line attributes for different objects
CRAttrFill	Drawing fill attributes for different objects
CRAttrFont	A font attributes, used together with text attributes
CRAttrLine	Drawing line attributes for different objects
CRAttrLineEnding	Attributes for line ending
►CRAttrMap
CBoolValue_t
CDoubleValue_t
CIntValue_t
CNoValue_t
CStringValue_t
CValue_t
CRAttrMargins	A margins attributes. Only relative and pixel coordinates are allowed
CRAttrMarker	A marker attributes
CRAttrText	A text attributes
►CRAttrValue	Template class to access single value from drawable or other attributes
CValueExtractor
CValueExtractor< Q, false >
CRAxisDrawable	Axis drawing
CRCanvas	A window's topmost RPad
CRCanvasDisplayItem	Class RCanvasDisplayItem
►CRCanvasPainter	Implementation of painter for ROOT::Experimental::RCanvas, using RWebWindow
CGeneratorImpl
CWebCommand
CWebConn
CWebUpdate
CRChangeAttrRequest
CRColor	The color class
CRDisplayItem	Base class for painting data for JS
►CRDrawable	Base class for drawable entities: objects that can be painted on a RPad
CRDisplayContext
CRDrawableDisplayItem	Generic display item for RDrawable, just reference drawable itself
CRDrawableExecRequest	Request execution of method of referenced drawable, no reply
CRDrawableMenuRequest	Request menu items for the drawable object
CRDrawableReply	Base class for replies on RDrawableRequest
CRDrawableRequest	Base class for requests which can be submitted from the clients
CREve3DProjection
CREveAunt
CREveAuntAsList
CREveBox
CREveBoxProjected
►CREveBoxSet
CBFreeBox_t
CInstanced_t
CInstancedScaled_t
CInstancedScaledRotated_t
CREveCalo2D
CREveCalo3D
►CREveCaloData
CCellData_t
CCellGeom_t
CCellId_t
CRebinData_t
CSliceInfo_t
CREveCaloDataHist
CREveCaloDataSelector
CREveCaloDataSliceSelector
CREveCaloDataVec
CREveCaloLego
CREveCaloViz
►CREveChunkManager
Citerator
CREveChunkVector
CREveClient
CREveCluster	REveCluster Reconstructed cluster (also used in VSD)
CREveCollectionCompound
CREveCompound
CREveCompoundProjected
CREveDataCollection
CREveDataColumn
CREveDataItem
►CREveDataItemList
CTTip
►CREveDataProxyBuilderBase
CProduct
►CREveDataSimpleProxyBuilder
CSPBProduct
CREveDataSimpleProxyBuilderTemplate
CREveDataTable
►CREveDigitSet
CDigitBase_t
CREveElement
CREveEllipsoid
CREveEllipsoidProjected
CREveException	REveException Exception-type thrown by Eve classes
CREveFrameBox
CREveGeoManagerHolder	REveGeoManagerHolder Exception-safe global variable holders
►CREveGeoPolyShape
CEdge_t
CREveGeoShape
CREveGeoShapeExtract
CREveGeoShapeProjected
CREveGeoTopNodeData
CREveGeoTopNodeViz
CREveHit	REveHit Monte Carlo hit (also used in VSD)
CREveJetCone
CREveJetConeProjected
CREveLine	REveLine An arbitrary polyline with fixed line and marker attributes
CREveLineProjected
CREveMagField	REveMagField Abstract interface to magnetic field
CREveMagFieldConst	REveMagFieldConst Interface to constant magnetic field
CREveMagFieldDuo	REveMagFieldDuo Interface to magnetic field with two different values depending on radius
►CREveManager
CChangeGuard
CConn
►CLogger
CHandler
CMIR
CRExceptionHandler
CServerState
CREveMCRecCrossRef	REveMCRecCrossRef Cross-reference of sim/rec data per particle (also used in VSD)
CREveMCTrack	REveMCTrack
CREvePathMarkT	Special-point on track:
CREvePointSelector	REvePointSelector TSelector for direct extraction of point-like data from a Tree
CREvePointSelectorConsumer
CREvePointSet
CREvePointSetArray
CREvePointSetProjected
►CREvePolygonSetProjected
CPolygon_t
CREveProjectable
CREveProjected
►CREveProjection	REveProjection Base for specific classes that implement non-linear projections
CPreScaleEntry_t
CREveProjectionManager	REveProjectionManager Manager class for steering of projections and managing projected objects
CREveRecCascade	REveRecCascade
CREveRecKink	REveRecKink Reconstructed kink (also used in VSD)
CREveRecTrackT	REveRecTrack Template for reconstructed track (also used in VSD)
CREveRecV0	REveRecV0
CREveRefBackPtr	REveRefBackPtr reference-count with back pointers
CREveRefCnt	REveRefCnt REveRefCnt base-class (interface)
CREveRenderData
CREveRGBAPalette
CREveRhoZProjection
CREveRPhiProjection
CREveScalableStraightLineSet
►CREveScene
CSceneCommand
CREveSceneInfo	REveSceneInfo Scene in a viewer
CREveSceneList
CREveSecondarySelectable
►CREveSelection	REveSelection Container for selected and highlighted elements
CDeviator
CRecord
CREveSelectorToEventList	REveSelectorToEventList TSelector that stores entry numbers of matching TTree entries into an event-list
CREveServerStatus
CREveShape
►CREveStraightLineSet	REveStraightLineSet Set of straight lines with optional markers along the lines
CLine_t
CMarker_t
CREveStraightLineSetProjected	REveStraightLineSetProjected Projected copy of a REveStraightLineSet
CREveTableEntry	REveTableEntry
CREveTableHandle	REveTableHandle
CREveTableProxyBuilder
CREveTableViewInfo	REveTableViewInfo
CREveText
CREveTrack	REveTrack Track with given vertex, momentum and optional referece-points (path-marks) along its path
CREveTrackList	REveTrackList A list of tracks supporting change of common attributes and selection based on track parameters
CREveTrackListProjected	REveTrackListProjected Specialization of REveTrackList for holding REveTrackProjected objects
CREveTrackProjected	REveTrackProjected Projected copy of a REveTrack
►CREveTrackPropagator	REveTrackPropagator Calculates path of a particle taking into account special path-marks and imposed boundaries
CHelix_t
CREveTrans
CREveUtil	REveUtil Standard utility functions for Reve
CREveVector2T	REveVector2T A two-vector template without TObject inheritance and virtual functions
CREveVector4T	REveVector4T A four-vector template without TObject inheritance and virtual functions
CREveVectorT	REveVectorT A three-vector template without TObject inheritance and virtual functions
CREveViewContext
CREveViewer	REveViewer Reve representation of TGLViewer
CREveViewerList	REveViewerList List of Viewers providing common operations on REveViewer collections
CREveVSD
CREveXZProjection
CREveYZProjection
CREveZXProjection
CREveZYProjection
►CRFitPanel
CFitRes
►CRFitPanelModel	Data structure for the fit panel
CRComboBoxItem	Generic item for ui5 ComboBox
CRFuncPar	Function parameter info, used in edit parameters dialog
CRFuncParsList	Class used to transfer functions parameters list from/to client
CRItemInfo	Basic function info, used in combo boxes
CRMethodInfo
CRMinimezerAlgorithm	Entry in minimizer algorithm combo
►CRFrame	Holds an area where drawing on user coordinate-system can be performed
CRUserRanges
CRZoomRequest
CRIndirectDisplayItem	Extract (reference) only basic attributes from drawable, but not drawable itself
CRMenuItems	List of items for object context menu
CRNTupleChainProcessor	Processor specialization for vertically combined (chained) RNTupleProcessors
CRNTupleFillContext	A context for filling entries (data) into clusters of an RNTuple
►CRNTupleImporter	Converts a TTree into an RNTuple
CRCStringTransformation	Transform a NULL terminated C string branch into an std::string field
CRImportBranch
CRImportField
CRImportGuard	When the schema is set up and the import started, it needs to be reset before the next Import() call can start
CRImportLeafCountCollection	Leaf count arrays require special treatment
CRImportTransformation	Base class to perform data transformations from TTree branches to RNTuple fields if necessary
CRProgressCallback	Used to report every ~100 MB (compressed), and at the end about the status of the import
►CRNTupleInspector	Inspect on-disk and storage-related information of an RNTuple
CRColumnInspector	Provides column-level storage information
CRFieldTreeInspector	Provides field-level storage information
CRNTupleJoinProcessor	Processor specialization for horizontally combined (joined) RNTuples
CRNTupleOpenSpec	Specification of the name and location of an RNTuple, used for creating a new RNTupleProcessor
CRNTupleParallelWriter	A writer to fill an RNTuple from multiple contexts
►CRNTupleProcessor	Interface for iterating over entries of RNTuples and vertically concatenated RNTuples (chains)
CRFieldContext	Manager for a field as part of the RNTupleProcessor
CRIterator	Iterator over the entries of an RNTuple, or vertical concatenation thereof
CRNTupleSingleProcessor	Processor specialization for processing a single RNTuple
CRNTupleWriteOptionsDaos	DAOS-specific user-tunable settings for storing ntuples
CROnFrameDrawable	Base class for drawable which can be drawn on frame or on pad
CRPad	Graphic container for RDrawable-s
CRPadBase	Base class for graphic containers for RDrawable-s
CRPadBaseDisplayItem	Class RPadBaseDisplayItem
CRPadDisplayItem	Class RPadDisplayItem
►CRPadExtent	An extent / size (horizontal and vertical) in a RPad
CScaleFactor	A scale factor (separate factors for horizontal and vertical) for scaling a RPadLength
►CRPadLength	A length in RPad
CCoordSysBase
CNormal	A normalized coordinate
CPixel	A pixel coordinate
CUser	A user coordinate
►CRPadPos	A position (horizontal and vertical) in a RPad
CScaleFactor	A scale factor (separate factors for horizontal and vertical) for scaling a RPadLength
►CRPalette	A set of colors
CDiscrete_t	Tag type used to signal that the palette's colors should not be interpolated
COrdinalAndColor	An ordinal value and its associated color
CRPaletteDrawable	A color palette draw near the frame
CRPave	Base class for paves with text, statistic, legends, placed relative to RFrame position and adjustable height
►CRStyle	A set of defaults for graphics attributes, e.g
CBlock_t
CTObjectDisplayItem	Display item for TObject with drawing options
CTObjectDrawable	Provides v7 drawing facilities for TObject types (TGraph, TH1, TH2, etc)
CTTaskGroup	A class to manage the asynchronous execution of work items
►CTTreeReaderFast
CIterator_t
CTTreeReaderValueFast
CTTreeReaderValueFast< bool >
CTTreeReaderValueFast< double >
CTTreeReaderValueFast< float >
CTTreeReaderValueFast< Int_t >
CTTreeReaderValueFast< UInt_t >
►NFit	Namespace for the fitting classes
►NFitUtil	Namespace defining utility free functions using in Fit for evaluating the various fit method functions (chi2, likelihood, etc..) given the data and the model function
CEvaluate
CIntegralEvaluator
CLikelihoodAux
CLikelihoodAux< double >
CParamDerivFunc
CSimpleGradientCalculator
CAreaComparer
CBasicFCN	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
CBinData	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:
CBox
CBoxContainer
CChi2FCN	Chi2FCN class for binned fits using the least square methods
CDataOptions	DataOptions : simple structure holding the options on how the data are filled
CDataRange	Class describing the range in the coordinates it supports multiple range in a coordinate
CFcnAdapter
CFitConfig	Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::ParameterSettings class
CFitData	Base class for all the fit data types: Stores the coordinates and the DataOptions
CFitResult	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
CFitter	Fitter class, entry point for performing all type of fits
CLogLikelihoodFCN	LogLikelihoodFCN class for likelihood fits
CObjFuncTrait
CObjFuncTrait< ROOT::Math::FitMethodFunction >
CObjFuncTrait< ROOT::Math::FitMethodGradFunction >
CParameterSettings	Class, describing value, limits and step size of the parameters Provides functionality also to set/retrieve values, step sizes, limits and fix the parameters
CPoissonLikelihoodFCN	Class evaluating the log likelihood for binned Poisson likelihood fits it is template to distinguish gradient and non-gradient case
CProxyListBox
CSparseData	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
CUnBinData	Class describing the un-binned data sets (just x coordinates values) of any dimensions
►NGeom
CVertex_t
►NInternal
►NExecutorUtils
CResultCaster
CResultCaster< TObject *, F >
►NRDF
►NGraphDrawing
CGraphCreatorHelper
CGraphNode	Class used to create the operation graph to be printed in the dot representation
CArrayPtrVisitor
CCallGuaranteedOrder	Struct to wrap the call to a function with a guaranteed order of execution of its arguments
CColumnType
CColumnType< ROOT::RVec< ROOT::RVec< T > >, false >
CColumnType< ROOT::RVec< T >, true >
CDisjunction
CDisjunction< B1 >
CDisjunction< B1, Bn... >
CDisplayHelper
CHasMakeNew
CIsDataContainer	Check for container traits
CIsDataContainer< ROOT::VecOps::RVec< bool > >
CIsVector_t	Detect whether a type is an instantiation of vector<T,A>
CPassAsVecHelper
CRAction	A RDataFrame node that produces a result
CRActionBase
CRArraySizeField	An artificial field that provides the size of a fixed-size array
CRCallback
CRColumnReadersInfo	This type aggregates some of the arguments passed to GetColumnReaders
CRColumnRegister	A binder for user-defined columns, variations and aliases
CRDefineReader	Column reader for defined columns
CRDefinesWithReaders	A helper type that keeps track of RDefine objects and their corresponding RDefineReaders
CRDisplayElement	Helper class to let Display print compact tabular representations of the events
CRDSColumnReader	Column reader type that deals with values read from RDataSources
CRDSRangeRAII
CRemoveFirstParameterIf	type is TypeList if MustRemove is false, otherwise it is a TypeList with the first type removed
CRemoveFirstParameterIf< true, TypeList >
CRemoveFirstTwoParametersIf
CRemoveFirstTwoParametersIf< true, TypeList >
CRJittedAction
CRJittedVariation	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
CRMetaDataJson
CRNewSampleFlag
CRNewSampleNotifier
CRNTupleColumnReader	Every RDF column is represented by exactly one RNTuple field
CROneTimeCallback
CRootConversionTraits
CRootConversionTraits< bool >
CRootConversionTraits< double >
CRootConversionTraits< float >
CRootConversionTraits< int16_t >
CRootConversionTraits< int32_t >
CRootConversionTraits< int8_t >
CRootConversionTraits< Long64_t >
CRootConversionTraits< uint16_t >
CRootConversionTraits< uint32_t >
CRootConversionTraits< uint8_t >
CRootConversionTraits< ULong64_t >
CRRDFCardinalityField	An artificial field that transforms an RNTuple column that contains the offset of collections into collection sizes
CRRootDS	This class is unused and it has only been implemented as a proof of concept
CRStringCache	A Thread-safe cache for strings
CRTreeOpaqueColumnReader
CRTreeUntypedArrayColumnReader	RTreeColumnReader specialization for TTree values read via TTreeReaderUntypedValue
CRTreeUntypedValueColumnReader	RTreeColumnReader specialization for TTree values read via TTreeReaderUntypedValue
CRTTreeDS
CRVariation
CRVariationBase	This type includes all parts of RVariation that do not depend on the callable signature
CRVariationReader	Column reader that reads the value for a specific column, variation and slot
CRVariationsWithReaders
CRVariedAction	Just like an RAction, but it has N action helpers and N previous nodes (N is the number of variations)
CRVecDS	A RDataSource implementation which takes a collection of RVecs, which are able to adopt data from Numpy arrays
CTValueGetter	Helper class which keeps track for each slot where to get the entry
CValueType
CValueType< ROOT::VecOps::RVec< T >, false >
CValueType< T, false >
►NRootCling
CDriverConfig
CTROOTSYSSetter
►NSHA256
Csha256_t
►NTDS
CTPointerHolder	Mother class of TTypedPointerHolder
CTTypedPointerHolder	Class to wrap a pointer and delete the memory associated to it correctly
►NTreeUtils	Namespace hosting functions and classes to retrieve tree information for internal use
CRNoCleanupNotifier
CRNoCleanupNotifierHelper
►NTThreadedObjectUtils
CCloner	Return a copy of the object or a "Clone" if the copy constructor is not implemented
CCloner< T, false >
CDetacher
CDetacher< T, true >
CDirCreator
CDirCreator< T, true >
►NVecOps
CIsRVec
CIsRVec< ROOT::VecOps::RVec< T > >
CRVecInlineStorageSize	The size of the inline storage of an RVec
CSmallVectorAlignmentAndSize	Used to figure out the offset of the first element of an RVec
CSmallVectorBase	This is all the stuff common to all SmallVectors
CSmallVectorStorage	Storage for the SmallVector elements
CSmallVectorStorage< 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
CSmallVectorTemplateBase	SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put method implementations that are designed to work with non-trivial T's
CSmallVectorTemplateBase< T, true >	SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put method implementations that are designed to work with trivially copyable T's
CSmallVectorTemplateCommon	This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD
CClassDefGenerateInitInstanceLocalInjector
►CDictSelectionReader
CTemplateInfo
CGetFunctorType	Internal class used by TF1 for obtaining the type from a functor out of the set of valid operator() signatures
CGetFunctorType< T(F::*)(const T *, const double *) const >
CGetFunctorType< T(F::*)(const T *, const double *)>
CGetFunctorType< T(F::*)(T *, double *) const >
CGetFunctorType< T(F::*)(T *, double *)>
CInterpreterMutexRegistrationRAII
►CParsingStateRAII	RAII used to store Parser, Sema, Preprocessor state for recursive parsing
CSemaExprCleanupsRAII
CSemaParsingInitForAutoVarsRAII
CRBaseType
►CRCluster	An in-memory subset of the packed and compressed pages of a cluster
CRKey	The identifiers that specifies the content of a (partial) cluster
CRClusterDescriptorBuilder	A helper class for piece-wise construction of an RClusterDescriptor
CRClusterGroupDescriptorBuilder	A helper class for piece-wise construction of an RClusterGroupDescriptor
►CRClusterPool	Managed a set of clusters containing compressed and packed pages
CRInFlightCluster	Clusters that are currently being processed by the pipeline
CRReadItem	Request to load a subset of the columns of a particular cluster
CRColumn	A column is a storage-backed array of a simple, fixed-size type, from which pages can be mapped into memory
CRColumnDescriptorBuilder	A helper class for piece-wise construction of an RColumnDescriptor
►CRColumnElementBase	A column element encapsulates the translation between basic C++ types and their column representation
CRIdentifier	Every concrete RColumnElement type is identified by its on-disk type (column type) and the in-memory C++ type, given by a type index
CRColumnIndex	The in-memory representation of a 32bit or 64bit on-disk index column
CRColumnSwitch	Holds the index and the tag of a kSwitch column
►CRConcurrentHashColl	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
CHashValue
CRDavixFileDes
CRecurseCounts
CRExtraTypeInfoDescriptorBuilder	A helper class for piece-wise construction of an RExtraTypeInfoDescriptor
CRFieldDescriptorBuilder	A helper class for piece-wise construction of an RFieldDescriptor
CRFieldRepresentationModifier
CRHashMap
CRIntegralTypeMap
CRIntegralTypeMap< int >
CRIntegralTypeMap< long >
CRIntegralTypeMap< long long >
CRIntegralTypeMap< short >
CRIntegralTypeMap< signed char >
CRIntegralTypeMap< unsigned char >
CRIntegralTypeMap< unsigned int >
CRIntegralTypeMap< unsigned long >
CRIntegralTypeMap< unsigned long long >
CRIntegralTypeMap< unsigned short >
►CRIoUring
CRReadEvent	Basic read event composed of IO data and a target file descriptor
CRKeyBlob	The RKeyBlob writes an invisible key into a TFile
CRMiniFileReader	Read RNTuple data blocks from a TFile container, provided by a RRawFile
CRNTupleCompressor	Helper class to compress data blocks in the ROOT compression frame format
CRNTupleDecompressor	Helper class to uncompress data blocks in the ROOT compression frame format
CRNTupleDescriptorBuilder	A helper class for piece-wise construction of an RNTupleDescriptor
►CRNTupleFileWriter	Write RNTuple data blocks in a TFile or a bare file container
CRFileProper
CRFileSimple
CRNTupleFormatter	Contains helper functions for RNTupleReader::PrintInfo() and RPrintSchemaVisitor::VisitField()
CRNTupleModelChangeset	The incremental changes to a RNTupleModel
CRNTupleReadOptionsManip
►CRNTupleSerializer	A helper class for serializing and deserialization of the RNTuple binary format
CRClusterGroup
CRClusterSummary
CRContext	The serialization context is used for the piecewise serialization of a descriptor
CREnvelopeLink
CRNTupleWriteOptionsManip
►CROnDiskPage	A page as being stored on disk, that is packed and compressed
CKey	On-disk pages within a page source are identified by the column and page number
CROnDiskPageMap	A memory region that contains packed and compressed pages
CROnDiskPageMapHeap	An ROnDiskPageMap that is used for an fMemory allocated as an array of unsigned char
►CRPage	A page is a slice of a column that is mapped into memory
CRClusterInfo	Stores information about the cluster in which this page resides
CRPageAllocator	Abstract interface to allocate and release pages
CRPageAllocatorHeap	Uses standard C++ memory allocation for the column data pages
►CRPagePersistentSink	Base class for a sink with a physical storage backend
CRCounters	Default I/O performance counters that get registered in fMetrics
CRFeatures	Set of optional features supported by the persistent sink
►CRPagePool	A thread-safe cache of pages loaded from the page source
CREntry	Every page in the page pool is annotated with a search key and a reference counter
CRKey
CRKeyHasher	Hash function to be used in the unordered map fLookupByKey
CRPagePosition	Used in fLookupByKey to store both the absolute and the cluster-local page index of the referenced page
CRPageRef	Reference to a page stored in the page pool
►CRPageSink	Abstract interface to write data into an ntuple
CRSealPageConfig	Parameters for the SealPage() method
CRSinkGuard	An RAII wrapper used to synchronize a page sink. See GetSinkGuard()
►CRStagedCluster	Cluster that was staged, but not yet logically appended to the RNTuple
CRColumnInfo
►CRPageSinkBuf	Wrapper sink that coalesces cluster column page writes
►CRColumnBuf	A buffered column
CRPageZipItem
CRCounters	I/O performance counters that get registered in fMetrics
►CRPageSinkFile	Storage provider that write ntuple pages into a file
CCommitBatch
►CRPageSource	Abstract interface to read data from an ntuple
►CRActivePhysicalColumns	Keeps track of the requested physical column IDs and their in-memory target type via a column element identifier
CRColumnInfo
CRClusterInfo	Summarizes cluster-level information that are necessary to load a certain page
CRCounters	Default I/O performance counters that get registered in fMetrics
CREntryRange	Used in SetEntryRange / GetEntryRange
CRExclDescriptorGuard	An RAII wrapper used for the writable access to RPageSource::fDescriptor. See GetSharedDescriptorGuard()
CRSharedDescriptorGuard	An RAII wrapper used for the read-only access to RPageSource::fDescriptor. See GetExclDescriptorGuard()`
►CRPageSourceFile	Storage provider that reads ntuple pages from a file
CRStructureBuffer	Holds the uncompressed header and footer
►CRPageStorage	Common functionality of an ntuple storage for both reading and writing
CRColumnHandle
CRSealedPage	A sealed page contains the bytes of a page as written to storage (packed & compressed)
CRSealedPageGroup	A range of sealed pages referring to the same column that can be used for vector commit
CRTaskScheduler	The interface of a task scheduler to schedule page (de)compression tasks
CRPrepareVisitor	Visitor used for a pre-processing run to collect information needed by another visitor class
CRPrintSchemaVisitor	Contains settings for printing and prints a summary of an RField instance
►CRPrintValueVisitor	Renders a JSON value corresponding to the field
CRPrintOptions
CRProjectedFields	Container for the projected fields of an RNTupleModel
►CRRawFile	The RRawFile provides read-only access to local and remote files
CRBlockBuffer
CRIOVec	Used for vector reads from multiple offsets into multiple buffers
CRIOVecLimits	Implementations may enforce limits on the use of vector reads
CROptions	On construction, an ROptions parameter can customize the RRawFile behavior
CRRawFileDavix	Read-only access to remote non-ROOT files
CRRawFileNetXNG	Read-only access to remote files using root/roots protocol
CRRawFileNetXNGImpl
CRRawFileTFile	The RRawFileTFile wraps an open TFile, but does not take ownership
CRRawFileUnix	Uses POSIX calls to read from a mounted file system
CRRawFileWin	Uses portable C I/O calls to read from a drive
►CRSlotStack	A thread-safe list of N indexes (0 to size - 1)
CAtomicWrapper
CRSlotStackRAII	A RAII object to pop and push slot numbers from a RSlotStack object
CRStl
►CRTaskArenaWrapper	Wrapper for tbb::task_arena
CAttach	Marker for attaching to an existing tbb::task_arena
CRTestFutureColumn
CRTFileControlBlock	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
►CRWritePageMemoryManager	Helper to maintain a memory budget for the write pages of a set of columns
CRColumnInfo
CTArrayCharProxy	Concrete Implementation of the branch proxy around the data members which are array of char
CTArrayProxy	Template for concrete implementation of proxy around array of T
CTArrayType	Helper template to be able to determine and use array dimensions
CTArrayType< T, 0 >	Helper class for proxy around multi dimension array
CTAtomicPointer	Helper class to manage atomic pointers
CTBranchCacheInfo
CTBranchDescriptor
CTBranchIMTHelper	A helper class for managing IMT work during TTree:Fill operations
CTBranchProxyClassDescriptor
CTBranchProxyDescriptor
CTBranchProxyDirector
CTBranchProxyHelper	String builder to be used in the constructors
CTCDGIILIBase
►CTCheckHashRecursiveRemoveConsistency
CValue
CTClaArrayProxy	Template of the Concrete Implementation of the branch proxy around an TClonesArray of array of T
CTClaImpProxy	Template of the Concrete Implementation of the branch proxy around TClonesArray of T
CTClaObjProxy
CTClaProxy	Base class for the proxy around object in TClonesArray
CTClassGetClassHelper
CTClonesArrayOwnershipRAII
CTDefaultInitBehavior
CTDirectoryAtomicAdapter	Internal class used in the implementation of gDirectory The objects of type TDirectoryAtomicAdapter should only be used inside the thread that created them
►CTExecutor	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
CMapRetType	Helper class to get the correct return type from the Map function, necessary to infer the ResolveExecutorAndMap function type
CMapRetType< F, unsigned >
CTF1Builder	Internal class used by TF1 for defining template specialization for different TF1 constructors
CTF1Builder< const char * >	TF1 building from a string used to build a TFormula based on a lambda function
CTF1Builder< Func * >
CTFriendProxy
CTFriendProxyDescriptor
CTGILRAII	Class to acquire and release the Python GIL where it applies, i.e
CTHashConsistencyHolder
CTHnBaseBinIter	Iterator over THnBase bins (internal implementation)
CTHnBaseBrowsable	TBrowser helper for THnBase
CTImpProxy	Template of the proxy around objects
CTInitBehavior
CTMultiArrayType	Helper class for proxy around multi dimension array
CTNamedBranchProxy
CTObjProxy
CTOperatorNewHelper
CTParBranchProcessingRAII
CTQObjectInitBehavior
CTROOTAllocator
CTSchemaHelper
CTSchemaRuleProcessor
CTSchemaType
CTSpinLockGuard	A spin mutex-as-code-guard class
CTStdBitsetHelper
CTStlArrayProxy	Template of the Concrete Implementation of the branch proxy around an stl container of array of T
CTStlImpProxy	Template of the Concrete Implementation of the branch proxy around an stl container of T
CTStlObjProxy
CTStlProxy	Base class for the proxy around STL containers
CTStlSimpleProxy
CTTreeGeneratorBase	Base class for code generators like TTreeProxyGenerator and TTreeReaderGenerator
CTTreeProxyGenerator
CTTreeReaderArrayBase	Base class of TTreeReaderArray
CTTreeReaderDescriptor
CTTreeReaderGenerator
CTTreeReaderOpaqueValue	Read a value in a branch without knowledge of its type
CTTreeReaderUntypedArray
CTTreeReaderUntypedValue
CTTreeReaderValueBase	Base class of TTreeReaderValue
CTTreeView
CTVirtualCollectionReader
CTypedIter
►CUniqueLockRecurseCount
CLocalCounts
CUpdate
►NMacOSX
►NDetails
CCocoaPrivate
►CFontCache
CFontList
CMacOSXSystem
►NUtil
CAutoreleasePool
CCFScopeGuard
CCFStrongReference
CNSScopeGuard
CNSStrongReference
CScopedArray
►NX11
CClearArea
►CColorParser
CRGB_t
CCommand
►CCommandBuffer
CWidgetRect
CCopyArea
CDeletePixmap
CDrawBoxXor
CDrawLine
CDrawLineXor
CDrawRectangle
CDrawSegments
CDrawString
CEventTranslator
CFillPolygon
CFillRectangle
CPoint
CRectangle
CUpdateWindow
CXLFDName
►NMath
►NCholeskyDecompHelpers	Helpers for CholeskyDecomp
C_decomposer	Struct to do a Cholesky decomposition
C_decomposer< F, 0, M >	Struct to do a Cholesky decomposition (specialized, N = 0)
C_decomposer< F, 1, M >	Struct to do a Cholesky decomposition (specialized, N = 1)
C_decomposer< F, 2, M >	Struct to do a Cholesky decomposition (specialized, N = 2)
C_decomposer< F, 3, M >	Struct to do a Cholesky decomposition (specialized, N = 3)
C_decomposer< F, 4, M >	Struct to do a Cholesky decomposition (specialized, N = 4)
C_decomposer< F, 5, M >	Struct to do a Cholesky decomposition (specialized, N = 5)
C_decomposer< F, 6, M >	Struct to do a Cholesky decomposition (specialized, N = 6)
C_decomposerGenDim	Struct to do a Cholesky decomposition (general dimensionality)
C_inverter	Struct to obtain the inverse from a Cholesky decomposition
C_inverter< F, 0, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 0)
C_inverter< F, 1, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 1)
C_inverter< F, 2, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 2)
C_inverter< F, 3, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 3)
C_inverter< F, 4, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 4)
C_inverter< F, 5, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 5)
C_inverter< F, 6, M >	Struct to obtain the inverse from a Cholesky decomposition (N = 6)
C_inverterGenDim	Struct to obtain the inverse from a Cholesky decomposition (general dimensionality)
C_solver	Struct to solve a linear system using its Cholesky decomposition
C_solver< F, 0, V >	Struct to solve a linear system using its Cholesky decomposition (N=0)
C_solver< F, 1, V >	Struct to solve a linear system using its Cholesky decomposition (N=1)
C_solver< F, 2, V >	Struct to solve a linear system using its Cholesky decomposition (N=2)
C_solver< F, 3, V >	Struct to solve a linear system using its Cholesky decomposition (N=3)
C_solver< F, 4, V >	Struct to solve a linear system using its Cholesky decomposition (N=4)
C_solver< F, 5, V >	Struct to solve a linear system using its Cholesky decomposition (N=5)
C_solver< F, 6, V >	Struct to solve a linear system using its Cholesky decomposition (N=6)
C_solverGenDim	Struct to solve a linear system using its Cholesky decomposition (generalised dimensionality)
CPackedArrayAdapter	Adapter for packed arrays (to SMatrix indexing conventions)
►Ndetail
Cmanipulator
►NGenVector_detail
►CBitReproducible
CDB8
CBitReproducibleException
►Ngv_detail
CERROR_This_Rotation_Conversion_is_NOT_Supported
►NImpl
CPlane3D	Class describing a geometrical plane in 3 dimensions
CTransform3D	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
CTranslation3D	Class describing a 3 dimensional translation
►NIntegOptionsUtil
COptionTrait
COptionTrait< IntegratorMultiDimOptions >
COptionTrait< IntegratorOneDimOptions >
►NRoots	Root-Finding Algorithms
CBisection	Roots::Bisection Bisection algorithm, simplest algorithm for bracketing the roots of a function, but slowest one
CBrent	Brent-Dekker algorithm which combines an interpolation strategy with the bisection algorithm See the GSL manual for more information
CFalsePos	False Position algorithm based on linear interpolation
CNewton	Newton algorithm, which computes the derivative at each iteration See the GSL manual for more information
CSecant	Secant algorithm, simplified version of Newton method, which does not require the derivative at every step
CSteffenson	Steffenson method, providing the fastes convergence
►NrowOffsetsUtils
Cindices
Cmake_indices
Cmake_indices_impl
Cmake_indices_impl< I, indices< Indices... >, N >
Cmake_indices_impl< N, indices< Indices... >, N >
►NUtil	Namespace defining Utility functions needed by mathcore
CTimingScope
CAdaptiveIntegratorMultiDim	Class for adaptive quadrature integration in multi-dimensions using rectangular regions
CAddOp	Addition Operation Class
CAddPolicy	Matrix addition policy
CAddPolicy< T, D1, D2, MatRepSym< T, D1 >, MatRepSym< T, D1 > >
CAssign	Structure to assign from an expression based to general matrix to general matrix
CAssign< 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
CAssign< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >	Structure to assign from an expression based to symmetric matrix to symmetric matrix
CAssignItr	Structure for assignment to a general matrix from iterator
CAssignItr< T, D1, D2, MatRepSym< T, D1 > >	Specialized structure for assignment to a symmetrix matrix from iterator
CAssignSym	Force Expression evaluation from general to symmetric
CAxisAngle	AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis
CBaseIntegratorOptions	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
CBasicFitMethodFunction	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)
CBasicMinimizer	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
CBinaryOp	BinaryOperation class A class representing binary operators in the parse tree
CBinaryOpCopyL	Binary Operation class with value storage for the left argument
CBinaryOpCopyR	Binary Operation class with value storage for the right argument
CBoost	Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix
CBoostX	Class representing a Lorentz Boost along the X axis, by beta
CBoostY	Class representing a Lorentz Boost along the Y axis, by beta
CBoostZ	Class representing a Lorentz Boost along the Z axis, by beta
CBrentMinimizer1D	User class for performing function minimization
CBrentRootFinder	Class for finding the root of a one dimensional function using the Brent algorithm
CCartesian2D	Class describing a 2D cartesian coordinate system (x, y coordinates)
CCartesian3D	Class describing a 3D cartesian coordinate system (x, y, z coordinates)
CCDFWrapper
CChebyshevApprox	Class describing a Chebyshev series which can be used to approximate a function in a defined range [a,b] using Chebyshev polynomials
CChebyshevPol
CCholeskyDecomp	Class to compute the Cholesky decomposition of a matrix
CCholeskyDecompGenDim	Class to compute the Cholesky decomposition of a matrix
CCholInverter
CCompileTimeChecker
CCompileTimeChecker< false >
CConstant	Constant expression class A class representing constant expressions (literals) in the parse tree
CCylindrical3D	Class describing a cylindrical coordinate system based on rho, z and phi
CCylindricalEta3D	Class describing a cylindrical coordinate system based on eta (pseudorapidity) instead of z
CDefaultCoordinateSystemTag	DefaultCoordinateSystemTag Default tag for identifying any coordinate system
►CDelaunay2D	Class to generate a Delaunay triangulation of a 2D set of points
CTriangle
CDerivator	Class for computing numerical derivative of a function
CDeterminant	Detrminant for a general squared matrix Function to compute the determinant from a square matrix ( \( \det(A)\)) of dimension idim and order n
CDisplacementVector2D	Class describing a generic displacement vector in 2 dimensions
CDisplacementVector3D	Class describing a generic displacement vector in 3 dimensions
CDistSampler	Interface class for generic sampling of a distribution, i.e
CDistSamplerOptions	DistSampler options class
CDivOp	Division (element-wise) Operation Class
CEulerAngles	EulerAngles class describing rotation as three angles (Euler Angles)
CEvaluatorOneDim
CEvaluatorOneDim< const ROOT::Math::IParamMultiFunction & >
CExpr
CFabs	Unary abs Operation Class
CFactory	Factory class holding static functions to create the interfaces like ROOT::Math::Minimizer via the Plugin Manager
CFastInverter	Fast Matrix Inverter class Class to specialize calls to Dinv
CFastInverter< 3 >	3x3 direct matrix inversion using Cramer Rule use only for FastInverter
CFastInverter< 4 >	4x4 matrix inversion using Cramers rule
CFastInverter< 5 >	5x5 Matrix inversion using Cramers rule
CFitTransformFunction	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
CFunctor	Documentation for class Functor class
CFunctor1D	Functor1D class for one-dimensional functions
CGaussIntegrator	User class for performing function integration
CGaussLegendreIntegrator	User class for performing function integration
CGenAlgoOptions	Class implementing generic options for a numerical algorithm Just store the options in a map of string-value pairs
CGeneralHessianCalc
CGeneralHessianCalc< double >
CGeneralLinearFunctionDerivation	Auxiliar class to bypass the (provisional) lack of vectorization in TFormula::EvalPar
CGeneralLinearFunctionDerivation< double >
CGeneticMinimizer	GeneticMinimizer
CGeneticMinimizerParameters
CGenVector_exception
CGlobalCoordinateSystemTag	Tag for identifying vectors based on a global coordinate system
CGoFTest	GoFTest class implementing the 1 sample and 2 sample goodness of fit tests for uni-variate distributions and data
CGradFunctor	GradFunctor class for Multidimensional gradient functions
CGradFunctor1D	GradFunctor1D class for one-dimensional gradient functions
CGSL1DMinimizerWrapper	Wrapper class for gsl_min_fminimizer structure
CGSLChebSeries	Wrapper class for C struct gsl_cheb_series
CGSLDerivator	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 )
CGSLError	Class to change GSL Error handler to use ROOT one
CGSLFunctionAdapter	Class for adapting any C++ functor class to C function pointers used by GSL
CGSLFunctionDerivWrapper	Class to wrap a gsl_function_fdf (with derivatives)
CGSLFunctionWrapper	Wrapper class to the gsl_function C structure
CGSLIntegrationWorkspace
CGSLIntegrator	Class for performing numerical integration of a function in one dimension
CGSLInterpolator	Interpolation class based on GSL interpolation functions
CGSLMCIntegrationWorkspace
CGSLMCIntegrator
CGSLMinimizer	GSLMinimizer class
CGSLMinimizer1D	Minimizer for arbitrary one dimensional functions
CGSLMiserIntegrationWorkspace	Workspace for MISER
CGSLMonteFunctionAdapter
CGSLMonteFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for Monte Carlo multi-dimensional integration algorithm
CGSLMultiFit	GSLMultiFit, internal class for implementing GSL non linear least square GSL fitting
CGSLMultiFit2	GSLMultiFit2, internal class for implementing GSL non linear least square GSL fitting New class implementing new GSL non linear fitting methods introduced in GSL 2.2
CGSLMultiFitFunctionAdapter	Class for adapting a C++ functor class to C function pointers used by GSL MultiFit Algorithm The templated C++ function class must implement:
CGSLMultiFitFunctionWrapper	Wrapper to a multi-dim function without derivatives for multi-dimensional minimization algorithm
CGSLMultiMinDerivFunctionWrapper	Wrapper for a multi-dimensional function with derivatives used in GSL multidim minimization algorithm
CGSLMultiMinFunctionAdapter	Class for adapting any multi-dimension C++ functor class to C function pointers used by GSL MultiMin algorithms
CGSLMultiMinFunctionWrapper	Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm
CGSLMultiMinimizer	GSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives
CGSLMultiRootBaseSolver	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)
CGSLMultiRootDerivFunctionWrapper	Wrapper to a multi-dim function with derivatives for multi roots algorithm
CGSLMultiRootDerivSolver	GSLMultiRootDerivSolver, internal class for implementing GSL multi-root finders using derivatives
CGSLMultiRootFinder	Class for Multidimensional root finding algorithms bassed on GSL
CGSLMultiRootFunctionAdapter	Class for adapting a C++ functor class to C function pointers used by GSL MultiRoot Algorithm The templated C++ function class must implement:
CGSLMultiRootFunctionWrapper	Wrapper to a multi-dim function without derivatives for multi roots algorithm
CGSLMultiRootSolver	GSLMultiRootSolver, internal class for implementing GSL multi-root finders not using derivatives
CGSLNLSMinimizer	GSLNLSMinimizer class for Non Linear Least Square fitting It Uses the Levemberg-Marquardt algorithm from GSL Non Linear Least Square fitting
CGSLPlainIntegrationWorkspace
CGSLQRngNiederreiter2	Niederreiter generator gsl_qrng_niederreiter_2 from here
CGSLQRngSobol	Sobol generator gsl_qrng_sobol from here
CGSLQRngWrapper	GSLQRngWrapper class to wrap gsl_qrng structure
CGSLQuasiRandomEngine	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
CGSLRandomEngine	GSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator
CGSLRngCMRG	Combined multiple recursive generator (L'Ecuyer) see here
CGSLRngGFSR4	Lagged Fibonacci generator by Ziff see here
CGSLRngMinStd	MINSTD generator (Park and Miller) see here
CGSLRngMixMax	MixMax generator based on ROOT::Math::MixMaxEngine of N=240
CGSLRngMRG	5-th order multiple recursive generator (L'Ecuyer, Blouin and Coutre) see here
CGSLRngMT	Mersenne-Twister generator gsl_rng_mt19937 from here
CGSLRngRand	BSD rand() generator gsl_rmg_rand from here
CGSLRngRanLux	Old Ranlux generator (James, Luscher) (default luxury level, p = 223) (This is eequivalent to TRandom1 with default luxury level) see here
CGSLRngRanLuxD1	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
CGSLRngRanLuxD2	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
CGSLRngRanLuxS1	Second generation of Ranlux generator for single precision with luxury level of 1 (It throws away 202 values for every 12 used) see here
CGSLRngRanLuxS2	Second generation of Ranlux generator for Single precision with luxury level of 2 (It throws away 397 value for every 12 used) see here
CGSLRngRanMar	RANMAR generator see here
CGSLRngROOTWrapper	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
CGSLRngTaus	Tausworthe generator by L'Ecuyer see here
CGSLRngWrapper	GSLRngWrapper class to wrap gsl_rng structure
CGSLRootFdFSolver	Root-Finder with derivatives implementation class using GSL
CGSLRootFinder	Base class for GSL Root-Finding algorithms for one dimensional functions which do not use function derivatives
CGSLRootFinderDeriv	Base class for GSL Root-Finding algorithms for one dimensional functions which use function derivatives
CGSLRootFSolver	Root-Finder implementation class using GSL
CGSLSimAnFunc	GSLSimAnFunc class description
CGSLSimAnMinimizer	GSLSimAnMinimizer class for minimization using simulated annealing using the algorithm from GSL
CGSLSimAnnealing	GSLSimAnnealing class for performing a simulated annealing search of a multidimensional function
CGSLSimAnParams	Structure holding the simulated annealing parameters
CGSLVegasIntegrationWorkspace	Workspace for VEGAS
CIBaseFunctionMultiDimTempl	Documentation for the abstract class IBaseFunctionMultiDim
CIBaseFunctionOneDim	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 )
CIBaseParam	Documentation for the abstract class IBaseParam
CIGradientFunctionMultiDimTempl	Interface (abstract class) for multi-dimensional functions providing a gradient calculation
CIGradientFunctionOneDim	Interface (abstract class) for one-dimensional functions providing a gradient calculation
CIGradientMultiDimTempl
CIMinimizer1D	Interface class for numerical methods for one-dimensional minimization
CIntegrandTransform	Auxiliary inner class for mapping infinite and semi-infinite integrals
CIntegratorMultiDim	User class for performing multidimensional integration
CIntegratorMultiDimOptions	Numerical multi dimensional integration options
CIntegratorOneDim	User Class for performing numerical integration of a function in one dimension
CIntegratorOneDimOptions	Numerical one dimensional integration options
CInterpolator	Class for performing function interpolation of points
CInverter	Matrix Inverter class Class to specialize calls to Dinv
CInverter< 0 >	Inverter<0>
CInverter< 1 >	1x1 matrix inversion \(a_{11} \to 1/a_{11}\)
CInverter< 2 >	2x2 matrix inversion using Cramers rule
CIOptions	Generic interface for defining configuration options of a numerical algorithm
CIParametricFunctionMultiDimTempl	IParamFunction interface (abstract class) describing multi-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam
CIParametricFunctionOneDim	Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam
CIParametricGradFunctionMultiDimTempl	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
CIParametricGradFunctionOneDim	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
CIRootFinderMethod	Interface for finding function roots of one-dimensional functions
CKahanSum	The Kahan summation is a compensated summation algorithm, which significantly reduces numerical errors when adding a sequence of finite-precision floating point numbers
►CKDTree
CBaseNode
CBinNode
CComparePoints
CCut
CHeadNode
Citerator
CSplitNode
CTerminalNode
CLCGEngine
CLocalCoordinateSystemTag	Tag for identifying vectors based on a local coordinate system
CLorentzRotation	Lorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix
CLorentzVector	Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part
CLSResidualFunc	LSResidualFunc class description
CMathMoreLib
CMatRepStd	Expression wrapper class for Matrix objects
CMatRepSym	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
CMatrixMulOp	Class for Matrix-Matrix multiplication
CMersenneTwisterEngine	Random number generator class based on M
Cmeta_col_dot
Cmeta_col_dot< 0 >
Cmeta_dot
Cmeta_dot< 0 >
Cmeta_mag
Cmeta_mag< 0 >
Cmeta_matrix_dot
Cmeta_matrix_dot< 0 >
Cmeta_row_dot
Cmeta_row_dot< 0 >
CMinimizer	Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2, Minuit, GSL, etc..) in ROOT
CMinimizerOptions	Minimizer options
CMinimizerVariableTransformation	Base class for MinimizerVariable transformations defining the functions to deal with bounded parameters
CMinimTransformFunction	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
CMinimTransformVariable	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
CMinOp	Subtraction Operation Class
CMinus	Unary Minus Operation Class
CMinusEquals	Evaluate the expression performing a -= operation Need to check whether creating a temporary object with the expression result (like in op: A -= A * B )
CMinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >	Specialization for symmetrix -= general : NOT Allowed operation
CMinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > >	Specialization for symmetric matrices
CMiserParameters	Structure collecting parameters for MISER multidimensional integration
CMixMaxEngine	MixMaxEngine is a wrapper class for the MIXMAX Random number generator
CMixMaxEngineImpl
CMixMaxEngineImpl< ROOT_MM_N >
CMulOp	Multiplication (element-wise) Operation Class
CMultiDimParamFunctionAdapter	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
CMultiDimParamGradFunctionAdapter	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
CMultiGenFunctionFitness
CMultiNumGradFunction	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)
CMultPolicy	Matrix-matrix multiplication policy
CNullTypeFunc1D
COneDimMultiFunctionAdapter	OneDimMultiFunctionAdapter class to wrap a multidimensional function in one dimensional one
COneDimParamFunctionAdapter	OneDimParamFunctionAdapter class to wrap a multi-dim parametric function in one dimensional one
CParamFunction	Base template class for all Parametric Functions
CParamFunctionBase	Class defining the signature for multi-dim parametric functions
►CParamFunctorHandler	ParamFunctor Handler class is responsible for wrapping any other functor and pointer to free C functions
CFuncEvaluator
CFuncEvaluator< F *, T >
CFuncEvaluator< F *const, T >
CParamFunctorTempl	Param Functor class for Multidimensional functions
►CParamMemFunHandler	ParamFunctor Handler to Wrap pointers to member functions
CMemFuncEvaluator
CPDFIntegral
CPlaceExpr
CPlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
CPlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
CPlaceMatrix	Structure to deal when a submatrix is placed in a matrix
CPlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
CPlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
CPlainParameters
CPlusEquals	Evaluate the expression performing a += operation Need to check whether creating a temporary object with the expression result (like in op: A += A * B )
CPlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > >	Specialization for symmetrix += general : NOT Allowed operation
CPlusEquals< 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 )
CPolar2D	Class describing a polar 2D coordinate system based on r and phi Phi is restricted to be in the range [-PI,PI)
CPolar3D	Class describing a polar coordinate system based on r, theta and phi Phi is restricted to be in the range [-PI,PI)
CPolynomial	Parametric Function class describing polynomials of order n
CPositionVector2D	Class describing a generic position vector (point) in 2 dimensions
CPositionVector3D	Class describing a generic position vector (point) in 3 dimensions
CPtEtaPhiE4D	Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and E (or rho, phi, eta , T) The metric used is (-,-,-,+)
CPtEtaPhiM4D	Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+)
CPxPyPzE4D	Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors stored as (Px, Py, Pz, E)
CPxPyPzM4D	Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M)
CQuasiRandom	User class for MathMore random numbers template on the Engine type
CQuaternion	Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k)
CRandom	Documentation for the Random class
CRandomFunctions
CRandomFunctions< EngineType, ROOT::Math::GSLRandomEngine >	Specialized implementation of the Random functions based on the GSL library
CRandomFunctionsImpl	Definition of the generic implementation class for the RandomFunctions
CRandomFunctionsImpl< 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
CRanluxppCompatEngineGslRanlxd	Compatibility engine for gsl_rng_ranlxd* from the GNU Scientific Library
CRanluxppCompatEngineGslRanlxs	Compatibility engine for gsl_rng_ranlxs* from the GNU Scientific Library
CRanluxppCompatEngineJames
CRanluxppCompatEngineLuescherImpl
CRanluxppCompatEngineLuescherRanlxd	Compatibility engine for Lüscher's ranlxd implementation written in C
CRanluxppCompatEngineLuescherRanlxs	Compatibility engine for Lüscher's ranlxs implementation written in C
CRanluxppCompatEngineStdRanlux24	Compatibility engine for std::ranlux24 from the C++ standard
CRanluxppCompatEngineStdRanlux48	Compatibility engine for std::ranlux48 from the C++ standard
CRanluxppEngine	Implementation of the RANLUX++ generator
CRanluxppEngineImpl
CRetrieveMatrix	Structure for getting sub matrices We have different cases according to the matrix representations
CRetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > >
CRetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > >
CRichardsonDerivator	User class for calculating the derivatives of a function
CRMinimizer	RMinimizer class
CRootFinder	User Class to find the Root of one dimensional functions
CRotation3D	Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix
CRotationX	Rotation class representing a 3D rotation about the X axis by the angle of rotation
CRotationY	Rotation class representing a 3D rotation about the Y axis by the angle of rotation
CRotationZ	Rotation class representing a 3D rotation about the Z axis by the angle of rotation
CRotationZYX	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
CRowOffsets	Static structure to keep the conversion from (i,j) to offsets in the storage data for a symmetric matrix
CSDeterminant	Dsfact
CSinVariableTransformation	Sin Transformation class for dealing with double bounded variables
CSInverter	Dsinv
CSkipFunction
CSkipFunction< 0 >
►CSMatrix	SMatrix: a generic fixed size D1 x D2 Matrix class
CSMatrixRow
CSMatrixRow_const
CSMatrixIdentity
CSMatrixNoInit
CSqr	Unary Square Operation Class
CSqrt	Unary Square Root Operation Class
CSqrtLowVariableTransformation	Sqrt Transformation class for dealing with lower bounded variables
CSqrtUpVariableTransformation	Sqrt Transformation class for dealing with upper bounded variables
CStdEngine	Class to wrap engines from the C++ standard random library in the ROOT Random interface
CStdEngineType
CStdRandomEngine
CSVector	SVector: a generic fixed size Vector class
CTDataPoint
CTDataPointN
CTensorMulOp	Class for Tensor Multiplication (outer product) of two vectors giving a matrix
CTRandomEngine
CTransposeOp	Class for Transpose Operations
CTranspPolicy	Matrix transpose policy
CTranspPolicy< T, D1, D2, MatRepSym< T, D1 > >
CUnaryOp	UnaryOperation class A class representing unary operators in the parse tree
CVavilov	Base class describing a Vavilov distribution
CVavilovAccurate	Class describing a Vavilov distribution
CVavilovAccurateCdf	Class describing the Vavilov cdf
CVavilovAccuratePdf	Class describing the Vavilov pdf
CVavilovAccurateQuantile	Class describing the Vavilov quantile function
CVavilovFast	Class describing a Vavilov distribution
CVecExpr	Expression wrapper class for Vector objects
CVectorMatrixColOp	Class for Vector-Matrix multiplication
CVectorMatrixRowOp
CVegasParameters	Structures collecting parameters for VEGAS multidimensional integration For implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h
CVirtualIntegrator	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
CVirtualIntegratorMultiDim	Interface (abstract) class for multi numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLMCIntegrator
CVirtualIntegratorOneDim	Interface (abstract) class for 1D numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLIntegrator
CWrappedFunction	Template class to wrap any C++ callable object which takes one argument i.e
CWrappedMemFunction	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;
CWrappedMemMultiFunction
CWrappedMultiFunction	Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-dimensional function interface
CWrappedMultiTF1Templ	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
CWrappedParamFunction	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
CWrappedParamFunctionGen	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
CWrappedTF1	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
►NMeta
►NSelection
CClassAttributes	Used to specify attributes of classes in the "DictSelection" syntax
CKeepFirstTemplateArguments	Used to specify the number of arguments to be kept
CMemberAttributes	Used to specify attributes of data members in the "DictSelection" syntax
CSelectNoInstance	Used to avoid to select all instances of a template
►NMinuit2
CABObj
CABProd
CABSum
CAnalyticalGradientCalculator
CBFGSErrorUpdator	Update of the covariance matrix for the Variable Metric minimizer (MIGRAD)
CBFGSMinimizerType
CCombinedMinimizer	Combined minimizer: combination of Migrad and Simplex
CCombinedMinimumBuilder
CContoursError
CDavidonErrorUpdator	Update of the covariance matrix for the Variable Metric minimizer (MIGRAD)
CDeleteAssignment
CDerivatorElement
CExternalInternalGradientCalculator	Similar to the AnalyticalGradientCalculator, the ExternalInternalGradientCalculator supplies Minuit with an externally calculated gradient
CFCNAdapter	Template wrapped class for adapting to FCNBase signature
CFCNBase	Interface (abstract class) defining the function to be minimized, which has to be implemented by the user
CFCNGradAdapter	Template wrapped class for adapting to FCNBase signature a IGradFunction
CFCNGradientBase	Extension of the FCNBase for providing the analytical Gradient of the function
CFumiliBuilder	Builds the FunctionMinimum using the Fumili method
CFumiliChi2FCN	Extension of the FCNBase for the Fumili method
CFumiliErrorUpdator	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
CFumiliFCNAdapter	Template wrapped class for adapting to FumiliFCNBase signature
CFumiliFCNBase	Extension of the FCNBase for the Fumili method
CFumiliGradientCalculator	Fumili gradient calculator using external gradient provided by FCN Note that the computed Hessian and G2 are an approximation valid for small residuals
CFumiliMaximumLikelihoodFCN	Extension of the FCNBase for the Fumili method
CFumiliMinimizer	Instantiates the seed generator and Minimum builder for the Fumili minimization method
CFumiliStandardChi2FCN	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
CFumiliStandardMaximumLikelihoodFCN	Class implementing the Elements member function for the standard maximum likelihood method
►CFunctionGradient
CData
►CFunctionMinimum	Class holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum
CData
CGradientCalculator	Interface class for gradient calculators
CHessianGradientCalculator	HessianGradientCalculator: class to calculate Gradient for Hessian
CInitialGradientCalculator	Class to calculate an initial estimate of the gradient
CLASquareMatrix
CLASymMatrix	Class describing a symmetric matrix of size n
CLAVector
CMatrixInverse
CMatrixInverse< vec, M, T >
CMinimumBuilder
►CMinimumError	MinimumError keeps the inv
CData
CMinimumErrorUpdator
►CMinimumParameters
CData
►CMinimumSeed
CData
CMinimumSeedGenerator	Base class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization;
►CMinimumState	MinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder)
CData
CMinosError	Class holding the result of Minos (lower and upper values) for a specific parameter
CMinuit2Minimizer	Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for Minuit2 minimization algorithm
CMinuitParameter	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;
CMnApplication	Application interface class for minimizers (migrad, simplex, Minimize, Scan) User normally instantiates the derived class like ROOT::Minuit2::MnMigrad for using Migrad for minimization
CMnContours	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;
CMnCovarianceSqueeze	Class to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index
►CMnCross
CCrossFcnLimit
CCrossNewMin
CCrossParLimit
CMnEigen	API class for calculating the eigenvalues of symmetric matrix
CMnFcn	Wrapper class to FCNBase interface used internally by Minuit
CMnFcnCaller
CMnFumiliMinimize	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;
CMnFunctionCross	MnFunctionCross
CMnGlobalCorrelationCoeff	Class for global correlation coefficient
CMnHesse	API class for calculating the numerical covariance matrix (== 2x Inverse Hessian == 2x Inverse 2nd derivative); can be used by the user or Minuit itself
CMnLineSearch	Implements a 1-dimensional minimization along a given direction (i.e
CMnMachinePrecision	Sets the relative floating point (double) arithmetic precision
CMnMigrad	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;
CMnMinimize	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;
CMnMinos	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;
CMnParabola	This class defines a parabola of the form a*x*x + b*x + c
CMnParabolaFactory
CMnParabolaPoint	A point of a parabola
CMnParameterScan	Scans the values of FCN as a function of one Parameter and retains the best function and Parameter values found
CMnParStr
CMnPlot	MnPlot produces a text-screen graphical output of (x,y) points, e.g
CMnPosDef	Force the covariance matrix to be positive defined by adding extra terms in the diagonal
►CMnPrint
COneline
CMnScan	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.;
CMnSeedGenerator	Concrete implementation of the MinimumSeedGenerator interface; used within ModularFunctionMinimizer;
CMnSimplex	API class for minimization using the Simplex method, which does not need and use the derivatives of the function, but only function values
CMnStrategy	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)
CMnTiny
CMnTraceObject
CMnUserCovariance	Class containing the covariance matrix data represented as a vector of size n*(n+1)/2 Used to hide internal matrix representation to user
CMnUserParameters	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)
CMnUserParameterState	Class which holds the external user and/or internal Minuit representation of the parameters and errors; transformation internal <-> external on demand;
CMnUserTransformation	Class dealing with the transformation between user specified parameters (external) and internal parameters used for minimization
CModularFunctionMinimizer	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
CMPIProcess
CMPITerminate
CNegativeG2LineSearch	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
CNumerical2PGradientCalculator	Class performing the numerical gradient calculation
CNumericalDerivator
CParametricFunction	Function which has parameters
CPrefixStack
CScanBuilder	Performs a minimization using the simplex method of Nelder and Mead (ref
CScanMinimizer	Class implementing the required methods for a minimization using SCAN API is provided in the upper ROOT::Minuit2::ModularFunctionMinimizer class
CSimplexBuilder	Performs a minimization using the simplex method of Nelder and Mead (ref
CSimplexMinimizer	Class implementing the required methods for a minimization using Simplex
CSimplexParameters	Class describing the simplex set of points (f(x), x ) which evolve during the minimization iteration process
CSimplexSeedGenerator	Generate Simplex starting point (state)
CSinParameterTransformation	Class for the transformation for double-limited parameter Using a sin function one goes from a double-limited parameter range to an unlimited one
CSqrtLowParameterTransformation	Transformation from external to internal Parameter based on sqrt(1 + x**2)
CSqrtUpParameterTransformation	Transformation from external to internal Parameter based on sqrt(1 + x**2)
CStackAllocator	StackAllocator controls the memory allocation/deallocation of Minuit
CStackAllocatorHolder
CStackError
CStackOverflow	Define stack allocator symbol
Csym
CVariableMetricBuilder	Build (find) function minimum using the Variable Metric method (MIGRAD) Two possible error updators can be chosen
CVariableMetricEDMEstimator
►CVariableMetricMinimizer	Instantiates the SeedGenerator and MinimumBuilder for Variable Metric Minimization method
CBFGSType
Cvec
CVectorOuterProduct
►Noption	The namespace of The Lean Mean C++ Option Parser
CArg	Functions for checking the validity of option arguments
CDescriptor	Describes an option, its help text (usage) and how it should be parsed
CFullArg
COption	A parsed option from the command line together with its argument if it has one
►CParser	Checks argument vectors for validity and parses them into data structures that are easier to work with
CAction
CStoreOptionAction
►CPrintUsageImplementation
CFunctionWriter
CIStringWriter
CLinePartIterator
CLineWrapper
COStreamWriter
CStreamWriter
CSyscallWriter
CTemporaryWriter
►CStats	Determines the minimum lengths of the buffer and options arrays used for Parser
CCountOptionsAction
►NQuartz
CCGAAStateGuard
CCGStateGuard
CTextLine
►NR	Namespace associated R package for ROOT
Cclass_
►CTRDataFrame	This is a class to create DataFrames from ROOT to R
CBinding
CTRFunctionExport	This is a class to pass functions from ROOT to R
CTRFunctionImport	This is a class to pass functions from ROOT to R
►CTRInterface	ROOT R was implemented using the R Project library and the modules Rcpp and RInside
CBinding
CTRObject	This is a class to get ROOT's objects from R's objects
►NRDF
►NExperimental
CProgressBarAction
CProgressHelper	RDF progress helper
►CRDatasetSpec	The dataset specification for RDataFrame
CREntryRange
CRMetaData	Class behaving as a heterogenuous dictionary to store the metadata of a dataset
CRResultMap
CRSample	Class representing a sample which is a grouping of trees and their fileglobs, and, optionally, the sample's metadata information via the RMetaData object
►NInternal
CRSqliteDSDataSet	The state of an open dataset in terms of the sqlite3 C library
CRArrowDS	RDataFrame data source class to interface with Apache Arrow
►CRCsvDS	RDataFrame data source class for reading CSV files
CROptions	Options that control how the CSV file is parsed
CRCutFlowReport
CRDataSource	RDataSource defines an API that RDataFrame can use to read arbitrary data formats
CRDFDescription	A DFDescription contains useful information about a given RDataFrame computation graph
CRDFTypeNameGetter	Helper to get the contents of a given column
►CRDisplay	This class is the textual representation of the content of a columnar dataset
CRPrintOptions
CRInterface	The public interface to the RDataFrame federation of classes
CRInterfaceBase
CRLazyDS	A RDataSource implementation which is built on top of result proxies
►CRNTupleDS	The RDataSource implementation for RNTuple
CREntryRangeDS	The PrepareNextRanges() method populates the fNextRanges list with REntryRangeDS records
CRFieldInfo	Holds useful information about fields added to the RNTupleDS
CRResultHandle	A type-erased version of RResultPtr and RResultMap
CRResultPtr	Smart pointer for the return type of actions
CRSampleInfo	This type represents a sample identifier, to be used in conjunction with RDataFrame features such as DefinePerSample() and per-sample callbacks
CRSnapshotOptions	A collection of options to steer the creation of the dataset on file
►CRSqliteDS	RSqliteDS is an RDF data source implementation for SQL result sets from sqlite3 files
CValue_t	Used to hold a single "cell" of the SELECT query's result table. Can be changed to std::variant once available
CRTrivialDS	A simple data-source implementation, for demo purposes
CRVariationsDescription	A descriptor for the systematic variations known to a given RDataFrame node
CTCutInfo
CTH1DModel	A struct which stores the parameters of a TH1D
CTH2DModel	A struct which stores the parameters of a TH2D
CTH3DModel	A struct which stores the parameters of a TH3D
CTHnDModel	A struct which stores the parameters of a THnD
CTProfile1DModel	A struct which stores the parameters of a TProfile
CTProfile2DModel	A struct which stores the parameters of a TProfile2D
CVerifyValidColumnType	Helper to determine if a given Column is a supported type
►NTestSupport
►CCheckDiagsRAII	Install a ROOT diagnostic handler to analyse diagnostics
CDiag_t
CFilterDiagsRAII	Allows a user function to catch and filter/analyse ROOT and cling diagnostics, e.g
CForbidDiagnostics	Error handler for gtests that generates failures for every received diagnostic > kInfo when this file is linked to
►NTF1Helper
CTGradientParFunction	Function class representing the derivative with respect a parameter of a given TF1
►NTMetaUtils
►CAnnotatedRecordDecl
CCompareByName
CRConstructorType
CTClingLookupHelper
CTNormalizedCtxt
CTNormalizedCtxtImpl
►NTreeUtils
CInvalidTupleType
CInvalidTupleType< TNtuple >
CInvalidTupleType< TNtupleD >
CRFriendInfo	Information about friend trees of a certain TTree or TChain object
►NTypeTraits	ROOT type_traits extensions
CHasBeginAndEnd
CIsSignedNumeral	Checks for signed integers types that are not characters
CIsSmartOrDumbPtr
CIsUnsignedNumeral	Checks for unsigned integer types that are not characters
CRemoveFirst
CRemoveFirstParameter	Remove first of possibly many template parameters
CRemoveFirstParameter< U< T, Rest... > >
CTakeFirstParameter	Return first of possibly many template parameters
CTakeFirstParameter< Template< T, Rest... > >
CTakeFirstType
CTypeList	Lightweight storage for a collection of types
►Nv5
CTF1Data
CTFormula	The FORMULA class (ROOT version 5)
CTFormulaPrimitive	The Formula Primitive class
CTOperOffset
►NVecOps
CRVec	A "std::vector"-like collection of values implementing handy operation to analyse them
CRVecN
CHasCollectionProxyMemberType	Template specializations for classes with collection proxies
CIsCollectionProxy	Helper type trait for marking classes as a collection proxy
CRArrayAsRVecField	Additional classes related to sequence containers
►CRArrayField	Template specializations for C++ std::array and C-style arrays
CRArrayDeleter
CRAtomicField	Template specializations for C++ std::atomic
CRBitsetField	Template specializations for C++ std::bitset
CRBrowser	Web-based ROOT files and objects browser
CRBrowserCatchedWidget
CRBrowserData	Way to browse (hopefully) everything in ROOT
CRBrowserDataCleanup
CRBrowserEditorWidget
CRBrowserInfoWidget
CRBrowserReply	Reply on browser request
CRBrowserRequest	Request send from client to get content of path element
CRBrowserTimer
CRBrowserWidget	Abstract Web-based widget, which can be used in the RBrowser Used to embed canvas, geometry viewer and potentially any other widgets
CRBrowserWidgetProvider
CRCardinalityField	An artificial field that transforms an RNTuple column that contains the offset of collections into collection sizes
►CRClassField	The field for a class with dictionary
CRClassDeleter
CRStagingItem
CRSubFieldInfo
►CRClusterDescriptor	Metadata for RNTuple clusters
CRColumnRange	The window of element indexes of a particular column in a particular cluster
►CRColumnRangeIterable
CRIterator
CRPageInfo	Information about a single page in the context of a cluster's page range
CRPageInfoExtended	Additional information about a page in an in-memory RPageRange
CRPageRange	Records the partition of data into pages for a particular column in a particular cluster
CRClusterGroupDescriptor	Clusters are bundled in cluster groups
►CRColumnDescriptor	Metadata stored for every column of an RNTuple
CRValueRange
►CRCompressionSetting	The global settings depend on a global variable named R__ZipMode which can be modified by a global function named R__SetZipMode
CEAlgorithm
CEDefaults
CELevel
CRCreateFieldOptions
CRDataFrame	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
CREntry	The REntry is a collection of values in an RNTuple corresponding to a complete row in the data set
CREnumField	The field for an unscoped or scoped enum with dictionary
►CRError	Captures diagnostics related to a ROOT runtime error
CRLocation
CRException	Base class for all ROOT issued exceptions
CRExtraTypeInfoDescriptor	Field specific extra type information from the header / extenstion header
CRField	Classes with dictionaries that can be inspected by TClass
CRField< bool >
CRField< char >
CRField< double >
CRField< float >
CRField< ItemT[N]>
CRField< RNTupleCardinality< SizeT > >
CRField< ROOT::VecOps::RVec< ItemT > >
CRField< TObject >	TObject requires special handling of the fBits and fUniqueID members
CRField< void >	Template specializations for concrete C++ fundamental types
►CRFieldBase	A field translates read and write calls from/to underlying columns to/from tree values
CRBulkSpec	Input parameter to RFieldBase::ReadBulk() and RFieldBase::ReadBulkImpl()
CRBulkValues	Points to an array of objects with RNTuple I/O support, used for bulk reading
CRCheckResult	Used in the return value of the Check() method
CRColumnRepresentations	The list of column representations a field can have
CRCreateObjectDeleter
CRCreateObjectDeleter< void >
CRDeleter	A functor to release the memory acquired by CreateValue() (memory and constructor)
►CRSchemaIteratorTemplate	Iterates over the subtree of fields in depth-first search order
CPosition
CRSharedPtrDeleter
CRTypedDeleter	A deleter for templated RFieldBase descendents where the value type is known
CRValue	Points to an object with RNTuple I/O support and keeps a pointer to the corresponding field
CRFieldDescriptor	Metadata stored for every field of an RNTuple
CRFieldToken	A field token identifies a (sub)field in an entry
CRFieldZero	The container field for an ntuple model, which itself has no physical representation
CRFileDialog	Web-based FileDialog
CRGeoItem	Representation of single item in the geometry browser
CRGeomBrowserIter	Iterator of hierarchical geometry structures
CRGeomConfig	Configuration parameters which can be configured on the client Send as is to-from client
►CRGeomDescription
CShapeDescr
CRGeomDrawing	Object with full description for drawing geometry It includes list of visible items and list of nodes required to build them
CRGeomHierarchy	Web-based ROOT geometry hierarchy viewer
CRGeomNode	Full node description including matrices and other attributes
CRGeomNodeBase	Base description of geometry node, required only to build hierarchy
CRGeomNodeInfo	Node information including rendering data
CRGeomNodeVisibility	Custom settings for physical Node visibility
CRGeomRawRenderInfo	Render info with raw data
CRGeomRenderInfo	Base class for render info block
CRGeomShapeRenderInfo	Render info with shape itself - client can produce shape better
CRGeomViewer	Web-based ROOT geometry viewer
CRGeomVisible	RGeomVisible contains description of visible node It is path to the node plus reference to shape rendering data
CRGeoPainter
CRIntegralField
CRInvalidField	Used in RFieldBase::Check() to record field creation failures
CRLogChannel	A log configuration for a channel, e.g
CRLogDiagCount	Keep track of emitted errors and warnings
CRLogEntry	A diagnostic that can be emitted by the RLogManager
CRLogHandler	Abstract RLogHandler base class
CRLogLocation	A diagnostic location, part of an RLogEntry
CRLogManager	A RLogHandler that multiplexes diagnostics to different client RLogHandlers and keeps track of the sum of RLogDiagCounts for all channels
CRLogScopedDiagCount	Object to count the number of warnings and errors emitted by a section of code, after construction of this type
CRLogScopedVerbosity	Change the verbosity level (global or specific to the RLogChannel passed to the constructor) for the lifetime of this object
CRMapField	Template specializations for C++ std::[unordered_][multi]map
CRNTuple	Representation of an RNTuple data set in a ROOT file
CRNTupleCardinality	Helper types to present an offset column as array of collection sizes
CRNTupleCollectionView	A view for a collection, that can itself generate new ntuple views for its nested fields
►CRNTupleDescriptor	The on-storage metadata of an RNTuple
►CRClusterDescriptorIterable	Used to loop over all the clusters of an RNTuple (in unspecified order)
CRIterator
►CRClusterGroupDescriptorIterable	Used to loop over all the cluster groups of an RNTuple (in unspecified order)
CRIterator
►CRColumnDescriptorIterable	Used to loop over a field's associated columns
CRIterator
CRCreateModelOptions	Modifiers passed to CreateModel()
►CRExtraTypeInfoDescriptorIterable	Used to loop over all the extra type info record of an RNTuple (in unspecified order)
CRIterator
►CRFieldDescriptorIterable	Used to loop over a field's child fields
CRIterator
CRHeaderExtension	Summarizes information about fields and the corresponding columns that were added after the header has been serialized
CRNTupleDirectAccessView	A view variant that provides direct access to the I/O buffers
CRNTupleFillStatus	A status object after filling an entry
►CRNTupleGlobalRange	Used to loop over indexes (entries or collections) between start and end
CRIterator
CRNTupleLocalIndex	Addresses a column element or field item relative to a particular cluster, instead of a global NTupleSize_t index
►CRNTupleLocalRange	Used to loop over entries of collections in a single cluster
CRIterator
CRNTupleLocator	Generic information about the physical location of data
CRNTupleLocatorObject64	RNTupleLocator payload that is common for object stores using 64bit location information
►CRNTupleModel	The RNTupleModel encapulates the schema of an RNTuple
CRUpdater	A model is usually immutable after passing it to an RNTupleWriter
►CRNTupleReader	Reads RNTuple data from storage
CRIterator
CRNTupleReadOptions	Common user-tunable settings for reading RNTuples
CRNTupleView	An RNTupleView for a known type
CRNTupleView< void >
CRNTupleViewBase	An RNTupleView provides read-only access to a single field of an RNTuple
CRNTupleWriteOptions	Common user-tunable settings for storing RNTuples
CRNTupleWriter	An RNTuple that gets filled with entries (data) and writes them to storage
CRNullableField	Template specializations for C++ std::optional and std::unique_ptr
CROpaqueTaskArena
►CROptionalField
CROptionalDeleter
CRPairField	Template specializations for C++ std::pair
►CRProxiedCollectionField	The field for a class representing a collection of elements via TVirtualCollectionProxy
►CRCollectionIterableOnce	Allows for iterating over the elements of a proxied collection
CRIterator
CRIteratorFuncs
CRProxiedCollectionDeleter
CRRangeCast	Wraps any collection that can be used in range-based loops and applies static_cast<T> or dynamic_cast<T> to each element
CRRealField
►CRRecordField	The field for an untyped record
CRRecordDeleter
CRResult	The class is used as a return type for operations that can fail; wraps a value of type T or an RError
CRResult< void >	RResult<void> has no data member and no Inspect() method but instead a Success() factory method
CRResultBase	Common handling of the error case for RResult<T> (T != void) and RResult<void>
CRRulesList
►CRRVecField	Template specializations for ROOT's RVec
CRRVecDeleter
CRSetField	Template specializations for C++ std::[unordered_][multi]set
CRSimpleField
►CRStreamerField	The field for a class using ROOT standard streaming
CRStreamerFieldDeleter
CRTreeDrawInvokeTimer
CRTreeDrawMonitoring
►CRTreeViewer	Web-based ROOT TTree viewer
CRBranchInfo
CRConfig
CRTupleField	Template specializations for C++ std::tuple
►CRUniquePtrField
CRUniquePtrDeleter
►CRVariantField	Template specializations for C++ std::variant
CRVariantDeleter
►CRVectorField	Template specializations for C++ std::vector
CRVectorDeleter
CRWebBrowserHandle	Specialized handle to hold information about running browser process Used to correctly cleanup all processes and temporary directories
CRWebBrowserImp
CRWebDisplayArgs	Holds different arguments for starting browser with RWebDisplayHandle::Display() method
►CRWebDisplayHandle	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
CBrowserCreator
CChromeCreator
CCreator	!< page content
CFirefoxCreator
CSafariCreator
►CRWebWindow	Represents web window, which can be shown in web browser or any other supported environment
CMasterConn
CQueueEntry
CQueueItem
CWebConn
CRWebWindowsManager	Central instance to create and show web-based windows like Canvas or FitPanel
CRWebWindowWSHandler	Just wrapper to deliver websockets call-backs to the RWebWindow class
CTBufferMerger	TBufferMerger is a class to facilitate writing data in parallel from multiple threads, while writing to a single output file
CTBufferMergerFile	A TBufferMergerFile is similar to a TMemFile, but when data is written to it, it is appended to the TBufferMerger queue
CTClassAlt
CTClassRec
CTExecutorCRTP	This class defines an interface to execute the same task multiple times, possibly in parallel and with different arguments every time
CTForNamespace
CTIOFeatures	TIOFeatures provides the end-user with the ability to change the IO behavior of data written via a TTree
CTMapDeclIdToTClass
CTMapTypeToClassRec
CTMapTypeToTClass
CTModuleGenerator
CTNumSlots	Defines the number of threads in some of ROOT's interfaces
CTProcessExecutor	This class provides a simple interface to execute the same task multiple times in parallel, possibly with different arguments every time
CTReadLockGuard
CTReentrantRWLock
CTRWMutexImp
CTRWSpinLock
CTRWSpinLockReadGuard
CTRWSpinLockWriteGuard
►CTSchemaRule
CTSources
►CTSeq	A pseudo container class which is a generator of indices
Citerator
CTSequentialExecutor
CTSpinMutex	A spin mutex class which respects the STL interface for mutexes
CTThreadedObject	A wrapper to make object instances thread private, lazily
CTThreadExecutor	This class provides a simple interface to execute the same task multiple times in parallel threads, possibly with different arguments every time
CTTreeProcessorMP	This class provides an interface to process a TTree dataset in parallel with multi-process technology
CTTreeProcessorMT	A class to process the entries of a TTree in parallel
►CTVirtualRWMutex
CState	Earlier lock state as returned by GetState() that can be passed to Restore()
CStateAndRecurseCount
CStateDelta	State as returned by GetStateDelta() that can be passed to Restore()
CTWriteLockGuard
►NROOTwriter
CROOTwriter
►NTClassEdit
CAtomicTypeNameHandlerRAII	A RAII helper to remove and readd enclosing _Atomic() It expects no spaces at the beginning or end of the string
CFunctionSplitInfo	Result of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters)
CTInterpreterLookupHelper
CTSplitType
►NTMath	TMath
CLimits
►NTMVA	Create variable transformations
►NDNN
►NCNN
CTCNNDescriptors
CTCNNWorkspace
CTConvLayer
CTConvParams
CTMaxPoolLayer	Generic Max Pooling Layer class
►NRNN
CTBasicGRULayer
CTBasicLSTMLayer
CTBasicRNNLayer
CTRNNDescriptors
CTRNNWorkspace
CBatch	Encapsulates one mini-batch
CClassificationSettings	Settings for classificationused to distinguish between different function signatures
CCudaActivationDescriptor
CCudaConvolutionBwdDataAlgo
CCudaConvolutionBwdFilterAlgo
CCudaConvolutionDescriptor
CCudaConvolutionFwdAlgo
CCudaDataType
CCudaDropoutDescriptor
CCudaEmptyDescriptor
CCudaFilterDescriptor
CCudaPoolingDescriptor
CDummyConvolutionBwdDataAlgo
CDummyConvolutionBwdFilterAlgo
CDummyConvolutionDescriptor
CDummyConvolutionFwdAlgo
CDummyCudaDataType
CDummyDataType
CDummyDescriptor
CDummyDropoutDescriptor
CDummyEmptyDescriptor
CDummyFilterDescriptor
CDummyPoolingDescriptor
CLayer	Layer defines the layout of a layer
CLayerData	LayerData holds the data of one layer
CMeanVariance
CNet	Neural net
CSettings	Settings for the training of the neural net
CSteepest	Steepest Gradient Descent algorithm (SGD)
CTAdadelta	Adadelta Optimizer class
CTAdagrad	Adagrad Optimizer class
CTAdam	Adam Optimizer class
CTBatch	TBatch
CTBatchIterator	TBatchIterator
CTBatchNormLayer	Layer implementing Batch Normalization
CTCpu	The TCpu architecture class
►CTCpuBuffer	TCpuBuffer
CFakeIteratorBegin
CTDestructor
CTCpuMatrix	The TCpuMatrix class
CTCpuTensor
CTCuda	The TCuda architecture class
►CTCudaDeviceBuffer	TCudaDeviceBuffer
CTDestructor
CTCudaDeviceReference	TCudaDeviceReference
►CTCudaHostBuffer	TCudaHostBuffer
CTDestructor
CTCudaMatrix	TCudaMatrix Class
►CTCudaTensor	TCudaTensor Class
CTensorDescriptor
CTDataLoader	TDataLoader
CTDataLoader< AData, TReference< AReal > >
CTDeepNet	Generic Deep Neural Network class
CTDenseLayer	Generic layer class
CTDescriptors
CTDevice	TDevice
CTDLGradientDescent
CTDNNGenDescriptors
CTGradientDescent
CTLayer	Generic layer class
CTNet	Generic neural network class
CTReference	The reference architecture class
CTReshapeLayer
CTRMSProp	RMSProp Optimizer class
CTSGD	Stochastic Batch Gradient Descent Optimizer class
CTSharedLayer	Layer class width shared weight and bias layers
CTTensorBatch	TTensorBatch
CTTensorBatchIterator	TTensorBatchIterator
CTTensorDataLoader	TTensorDataLoader
CTTensorDataLoader< AData, TReference< AReal > >
CTWorkspace
CVGeneralLayer	Generic General Layer class
CVOptimizer	Generic Optimizer class
►NExperimental
►NInternal
Cand_types	Type checking for all types of a parameter pack, e.g., used in combination with std::is_convertible
Cand_types< T0, Ts... >
CComputeHelper	Compute helper
CRBatchGenerator
CRBatchLoader
CRChunkLoader
CRChunkLoaderFilters
CRChunkLoaderFunctor
CRChunkLoaderFunctorFilters
CXMLConfig	Container for information extracted from TMVA XML config
►NSOFIE
CBinaryOperatorTrait
CBinaryOperatorTrait< T, Add >
CBinaryOperatorTrait< T, Div >
CBinaryOperatorTrait< T, Mul >
CBinaryOperatorTrait< T, Pow >
CBinaryOperatorTrait< T, Sub >
CComparisionTrait
CComparisionTrait< T, Eq >
CComparisionTrait< T, Greater >
CComparisionTrait< T, GreaterEq >
CComparisionTrait< T, Less >
CComparisionTrait< T, LessEq >
CDim
CDynamicTensorInfo
CExtractDataFromTP
CExtractDataFromTP< double >
CExtractDataFromTP< float >
CExtractDataFromTP< int32_t >
CExtractDataFromTP< int64_t >
CGNN_Data
CGNN_Init
CGraphIndependent_Init
CInitializedTensor
CInputTensorInfo
CMemoryPoolInfo
CNaryOperatorTraits
CNaryOperatorTraits< float, EBasicNaryOperator::Mean >
CNaryOperatorTraits< T, EBasicNaryOperator::Max >
CNaryOperatorTraits< T, EBasicNaryOperator::Mean >
CNaryOperatorTraits< T, EBasicNaryOperator::Min >
CNaryOperatorTraits< T, EBasicNaryOperator::Sum >
CRAttributes_Pool
CRFunction
CRFunction_Aggregate
CRFunction_Mean
CRFunction_MLP
CRFunction_Sum
CRFunction_Update
CRModel
CRModel_Base
CRModel_GNN
CRModel_GNNBase
CRModel_GraphIndependent
►CRModelParser_ONNX
COperatorsMapImpl
CROperator
CROperator_BasicBinary
CROperator_BasicNary
CROperator_BasicUnary
CROperator_BatchNormalization
CROperator_Cast
CROperator_Comparision
CROperator_Concat
CROperator_Constant
CROperator_Conv
CROperator_ConvTranspose	Transposed Convolution operator
CROperator_Custom
CROperator_Einsum
CROperator_Elu
CROperator_Erf
CROperator_Expand
CROperator_EyeLike
CROperator_Gather
CROperator_Gemm
CROperator_GRU	Gated Recurrent Unit operator
CROperator_Identity
CROperator_If
CROperator_LayerNormalization
CROperator_LeakyRelu
CROperator_LSTM	Long Short-Term Memory operator
CROperator_Pad
CROperator_Pool
CROperator_Random
CROperator_Range
CROperator_Reduce
CROperator_Relu
CROperator_Reshape
CROperator_RNN	Recurrent Neural Network operator
CROperator_ScatterElements
CROperator_Selu
CROperator_Shape
CROperator_Sigmoid
CROperator_Slice
CROperator_Softmax
CROperator_Split
CROperator_Swish
CROperator_Tanh
CROperator_Tile
CROperator_TopK
CROperator_Transpose
CROperator_Where
CTensorInfo
CTensorMemoryInfo
CTensorType
CTensorType< double >
CTensorType< float >
CTensorType< int32_t >
CTensorType< int64_t >
CTensorType< uint32_t >
CTensorType< uint64_t >
CUnaryOpTraits
CUnaryOpTraits< T, EBasicUnaryOperator::kAbs >
CUnaryOpTraits< T, EBasicUnaryOperator::kCos >
CUnaryOpTraits< T, EBasicUnaryOperator::kExp >
CUnaryOpTraits< T, EBasicUnaryOperator::kLog >
CUnaryOpTraits< T, EBasicUnaryOperator::kNeg >
CUnaryOpTraits< T, EBasicUnaryOperator::kReciprocal >
CUnaryOpTraits< T, EBasicUnaryOperator::kSin >
CUnaryOpTraits< T, EBasicUnaryOperator::kSqrt >
CClassification
CClassificationResult
CRBDT
CRReader	A replacement for the TMVA::Reader legacy interface
►CRSofieReader	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
CCustomOperatorData
CRStandardScaler
►CRTensor	RTensor is a container with contiguous memory and shape information
CIterator
CSofieFunctorHelper	Helper class used by SOFIEFunctor to wrap the infer signature interface to RDataFrame
►NInternal
CPyGILRAII
►NkNN
CEvent
CModulekNN
CNode	This file contains binary tree and global function template that searches tree for k-nearest neigbors
CAbsoluteDeviationLossFunction	Absolute Deviation Loss Function
CAbsoluteDeviationLossFunctionBDT	Absolute Deviation BDT Loss Function
CAbsValue
CBDTEventWrapper
CBinarySearchTree	A simple Binary search tree including a volume search method
CBinarySearchTreeNode	Node for the BinarySearch or Decision Trees
CBinaryTree	Base class for BinarySearch and Decision Trees
CCCPruner	A helper class to prune a decision tree using the Cost Complexity method (see Classification and Regression Trees by Leo Breiman et al)
►CCCTreeWrapper
CCCTreeNode
CClassifierFactory	This is the MVA factory
CClassInfo	Class that contains all the information of a class
►CConfig	Singleton class for global configuration settings used by TMVA
CIONames
CVariablePlotting
CConfigurable
CConvergenceTest	Check for convergence
CCostComplexityPruneTool	A class to prune a decision tree using the Cost Complexity method
CCrossEntropy	Implementation of the CrossEntropy as separation criterion
CCrossValidation	Class to perform cross validation, splitting the dataloader into folds
CCrossValidationFoldResult
CCrossValidationResult	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
CCvSplit
CCvSplitKFolds
CCvSplitKFoldsExpr
CDataInputHandler	Class that contains all the data information
CDataLoader
CDataSet	Class that contains all the data information
►CDataSetFactory	Class that contains all the data information
CEventStats
CDataSetInfo	Class that contains all the data information
CDataSetManager	Class that contains all the data information
CDecisionTree	Implementation of a Decision Tree
CDecisionTreeNode
CDeleteFunctor_t
CDTNodeTrainingInfo
CEnvelope	Abstract base class for all high level ml algorithms, you can book ml methods like BDT, MLP
CEvent
CExecutor	Base Executor class
CExpectedErrorPruneTool	A helper class to prune a decision tree using the expected error (C4.5) method
CFactory	This is the main MVA steering class
CFitterBase	Base class for TMVA fitters
CGeneticAlgorithm	Base definition for genetic algorithm
CGeneticFitter	Fitter using a Genetic Algorithm
CGeneticGenes	Cut optimisation interface class for genetic algorithm
CGeneticPopulation	Population definition for genetic algorithm
CGeneticRange	Range definition for genetic algorithm
CGiniIndex	Implementation of the GiniIndex as separation criterion
CGiniIndexWithLaplace	Implementation of the GiniIndex With Laplace correction as separation criterion
CHuberLossFunction	Huber Loss Function
CHuberLossFunctionBDT	Huber BDT Loss Function
CHyperParameterOptimisation
CHyperParameterOptimisationResult
CIFitterTarget	Interface for a fitter 'target'
CIMethod	Interface for all concrete MVA method implementations
CIncrement
CInterval	The TMVA::Interval Class
CIPruneTool	IPruneTool - a helper interface class to prune a decision tree
CIPythonInteractive	This class is needed by JsMVA, and it's a helper class for tracking errors during the training in Jupyter notebook
CKDEKernel	KDE Kernel for "smoothing" the PDFs
CLDA
CLeastSquaresLossFunction	Least Squares Loss Function
CLeastSquaresLossFunctionBDT	Least Squares BDT Loss Function
CLogInterval	The TMVA::Interval Class
CLossFunction
CLossFunctionBDT
CLossFunctionEventInfo
CMCFitter	Fitter using Monte Carlo sampling of parameters
CMethodANNBase	Base class for all TMVA methods using artificial neural networks
CMethodBase	Virtual base Class for all MVA method
CMethodBayesClassifier	Description of bayesian classifiers
CMethodBDT	Analysis of Boosted Decision Trees
CMethodBoost	Class for boosting a TMVA method
CMethodC50
CMethodCategory	Class for categorizing the phase space
CMethodCFMlpANN	Interface to Clermond-Ferrand artificial neural network
►CMethodCFMlpANN_Utils	Implementation of Clermond-Ferrand artificial neural network
CVARn2
CMethodCompositeBase	Virtual base class for combining several TMVA method
CMethodCrossValidation
CMethodCuts	Multivariate optimisation of signal efficiency for given background efficiency, applying rectangular minimum and maximum requirements
CMethodDL
►CMethodDNN	Deep Neural Network Implementation
CTTrainingSettings
CMethodDT	Analysis of Boosted Decision Trees
CMethodFDA	Function discriminant analysis (FDA)
CMethodFisher	Fisher and Mahalanobis Discriminants (Linear Discriminant Analysis)
CMethodHMatrix	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
CMethodInfo
CMethodKNN	Analysis of k-nearest neighbor
CMethodLD	Linear Discriminant
CMethodLikelihood	Likelihood analysis ("non-parametric approach")
CMethodMLP	Multilayer Perceptron class built off of MethodANNBase
CMethodPDEFoam	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
CMethodPDERS	This is a generalization of the above Likelihood methods to \( N_{var} \) dimensions, where \( N_{var} \) is the number of input variables used in the MVA
CMethodPyAdaBoost
CMethodPyGTB
CMethodPyKeras
CMethodPyRandomForest
CMethodPyTorch
CMethodRSNNS
CMethodRSVM
CMethodRuleFit	J Friedman's RuleFit method
CMethodRXGB
CMethodSVM	SMO Platt's SVM classifier with Keerthi & Shavade improvements
CMethodTMlpANN	This is the TMVA TMultiLayerPerceptron interface class
CMinuitFitter	/Fitter using MINUIT
CMinuitWrapper	Wrapper around MINUIT
CMisClassificationError	Implementation of the MisClassificationError as separation criterion
CMonitoring
CMsgLogger	Ostringstream derivative to redirect and format output
CNode	Node for the BinarySearch or Decision Trees
Cnull_t
COptimizeConfigParameters
COption
COption< T * >
COptionBase	Class for TMVA-option handling
►COptionMap	Class to storage options for the differents methods
CBinding
CPDEFoam	Implementation of PDEFoam
CPDEFoamCell
CPDEFoamDecisionTree	This PDEFoam variant acts like a decision tree and stores in every cell the discriminant
CPDEFoamDecisionTreeDensity	This is a concrete implementation of PDEFoam
CPDEFoamDensityBase	This is an abstract class, which provides an interface for a PDEFoam density estimator
CPDEFoamDiscriminant	This PDEFoam variant stores in every cell the discriminant
CPDEFoamDiscriminantDensity	This is a concrete implementation of PDEFoam
CPDEFoamEvent	This PDEFoam variant stores in every cell the sum of event weights and the sum of the squared event weights
CPDEFoamEventDensity	This is a concrete implementation of PDEFoam
CPDEFoamKernelBase	This class is the abstract kernel interface for PDEFoam
CPDEFoamKernelGauss	This PDEFoam kernel estimates a cell value for a given event by weighting all cell values with a gauss function
CPDEFoamKernelLinN	This PDEFoam kernel estimates a cell value for a given event by weighting with cell values of the nearest neighbor cells
CPDEFoamKernelTrivial	This class is a trivial PDEFoam kernel estimator
CPDEFoamMultiTarget	This PDEFoam variant is used to estimate multiple targets by creating an event density foam (PDEFoamEvent), which has dimension:
CPDEFoamTarget	This PDEFoam variant stores in every cell the average target fTarget (see the Constructor) as well as the statistical error on the target fTarget
CPDEFoamTargetDensity	This is a concrete implementation of PDEFoam
CPDEFoamVect
CPDF	PDF wrapper for histograms; uses user-defined spline interpolation
CPruningInfo
CPyMethodBase	Virtual base class for all TMVA method based on Python
►CQuickMVAProbEstimator
CEventInfo
CRandomGenerator
CRank
CRanking	Ranking for variables in method (implementation)
CReader	Serves to use the MVAs in a specific analysis context
CRegressionVariance	Calculate the "SeparationGain" for Regression analysis separation criteria used in various training algorithms
CResults	Class that is the base-class for a vector of result
CResultsClassification	Class that is the base-class for a vector of result
CResultsMulticlass	Class which takes the results of a multiclass classification
CResultsRegression	Class that is the base-class for a vector of result
CRMethodBase
CROCCalc
CROCCurve
CRootFinder	Root finding using Brents algorithm (translated from CERNLIB function RZERO)
CRule	Implementation of a rule
CRuleCut	A class describing a 'rule cut'
CRuleEnsemble
CRuleFit	A class implementing various fits of rule ensembles
►CRuleFitAPI	J Friedman's RuleFit method
CIntParms
CRealParms
CRuleFitParams	A class doing the actual fitting of a linear model using rules as base functions
CSdivSqrtSplusB	Implementation of the SdivSqrtSplusB as separation criterion
CSeparationBase	An interface to calculate the "SeparationGain" for different separation criteria used in various training algorithms
CSimulatedAnnealing	Base implementation of simulated annealing fitting procedure
CSimulatedAnnealingFitter	Fitter using a Simulated Annealing Algorithm
CStatDialogBDT
CStatDialogBDTReg
CStatDialogMVAEffs
CSVEvent	Event class for Support Vector Machine
CSVKernelFunction	Kernel for Support Vector Machine
CSVKernelMatrix	Kernel matrix for Support Vector Machine
CSVWorkingSet	Working class for Support Vector Machine
CTActivation	Interface for TNeuron activation function classes
CTActivationChooser	Class for easily choosing activation functions
CTActivationIdentity	Identity activation function for TNeuron
CTActivationRadial	Radial basis activation function for ANN
CTActivationReLU	Rectified Linear Unit activation function for TNeuron
CTActivationSigmoid	Sigmoid activation function for TNeuron
CTActivationTanh	Tanh activation function for ANN
CTimer	Timing information for training and evaluation of MVA methods
CTMVAGaussPair
CTMVAGUI
CTNeuron	Neuron class used by TMVA artificial neural network methods
CTNeuronInput	Interface for TNeuron input calculation classes
CTNeuronInputAbs	TNeuron input calculator – calculates the sum of the absolute values of the weighted inputs
CTNeuronInputChooser	Class for easily choosing neuron input functions
CTNeuronInputSqSum	TNeuron input calculator – calculates the squared weighted sum of inputs
CTNeuronInputSum	TNeuron input calculator – calculates the weighted sum of inputs
CTools	Global auxiliary applications and data treatment routines
CTrainingHistory	Tracking data from training
►CTransformationHandler	Class that contains all the data information
CVariableStat
CTreeInfo
CTSpline1	Linear interpolation of TGraph
CTSpline2	Quadratic interpolation of TGraph
CTSynapse	Synapse class used by TMVA artificial neural network methods
CTTrainingSettings	All of the options that can be specified in the training string
CTypes	Singleton class for Global types used by TMVA
CVariableDecorrTransform	Linear interpolation class
CVariableGaussTransform	Gaussian Transformation of input variables
CVariableIdentityTransform	Linear interpolation class
CVariableImportance
CVariableImportanceResult
CVariableInfo	Class for type info of MVA input variable
CVariableNormalizeTransform	Linear interpolation class
CVariablePCATransform	Linear interpolation class
CVariableRearrangeTransform	Rearrangement of input variables
CVariableTransformBase	Linear interpolation class
CVarTransformHandler
CVolume	Volume for BinarySearchTree
►NTStreamerInfoActions
►CAssociativeLooper
CConvertCollectionBasicType
CConvertRead
CConvertRead< NoFactorMarker< From >, To >
CConvertRead< WithFactorMarker< From >, To >
CWriteConvertCollectionBasicType
CWriteConvertCollectionBasicType< Memory, NoFactorMarker< Onfile > >
CWriteConvertCollectionBasicType< Memory, WithFactorMarker< Onfile > >
CBitsMarker
►CCollectionLooper
CReadStreamerLoop
CWriteStreamerLoop
CConvertBasicType
CConvertBasicType< BitsMarker, To >
CConvertBasicType< NoFactorMarker< From >, To >
CConvertBasicType< WithFactorMarker< From >, To >
►CGenericLooper
CConvertBasicType
CConvertBasicType< BitsMarker, To, Generic >
CConvertBasicType< NoFactorMarker< From >, To, Converter >
CConvertBasicType< WithFactorMarker< From >, To, Converter >
CConvertCollectionBasicType
CGeneric
CNumeric
CWrite_WithoutFastArray_ConvertBasicType
CWriteConvertBasicType
CWriteConvertBasicType< NoFactorMarker< Onfile >, Memory, Converter >
CWriteConvertBasicType< WithFactorMarker< Onfile >, Memory, Converter >
CWriteConvertCollectionBasicType
CNoFactorMarker
CScalarLooper
►CTActionSequence
CSequencePtr
CTAssocLoopConfig
CTBitsConfiguration
CTConfigSTL
CTConfiguration	Base class of the Configurations
CTConfigurationPushDataCache
CTConfigurationUseCache
CTConfiguredAction
CTConfNoFactor
CTConfObject
CTConfSTLNoFactor
CTConfSTLWithFactor
CTConfStreamerLoop
CTConfSubSequence
CTConfWithFactor
CTGenericConfiguration
CTGenericLoopConfig
CTIDNode
CTLoopConfiguration	Base class of the Configurations for the member wise looping routines
CTNestedIDs
CTVectorLoopConfig
►CVectorLooper
CConvertBasicType
CConvertBasicType< BitsMarker, To >
CConvertBasicType< NoFactorMarker< From >, To >
CConvertBasicType< WithFactorMarker< From >, To >
CConvertCollectionBasicType
CConvertCollectionBasicType< NoFactorMarker< From >, To >
CWriteConvertBasicType
CWriteConvertBasicType< NoFactorMarker< Onfile >, Memory >
CWriteConvertBasicType< WithFactorMarker< Onfile >, Memory >
CWriteConvertCollectionBasicType
►CVectorPtrLooper
CConvertBasicType
CConvertBasicType< BitsMarker, To >
CConvertBasicType< NoFactorMarker< From >, To >
CConvertBasicType< WithFactorMarker< From >, To >
CWriteConvertBasicType
CWriteConvertBasicType< NoFactorMarker< To >, From >
CWriteConvertBasicType< WithFactorMarker< To >, From >
CWithFactorMarker
CWriteConvertBasicType
►Nwriter
Cwriter
►NZMQ
►NDetail
Cis_trivial
CMoreException
Cppoll_error_t
CTimeOutException
C__argb32__
C_EdgeTableEntry
C_PROCESS_MEMORY_COUNTERS
C_root_std_complex
C_ScanLineList
C_ScanLineListBlock
C_x3d_data_
C_x3d_sizeof_
Cah
CAlternateTupleIntDoubleAsc
CAlternateTupleIntDoubleDes
CAnyCollectionProxy
CAnyCollectionStreamer
CAutoloadLibraryGenerator
CAutoRestorer
CAxis2
CB1
CBase_t
CBaseClass
CBaseCounterT
CBaseSelectionRule
CBasicGRULayer	Generic implementation
CBasicLSTMLayer	Generic implementation
CBasicRNNLayer	Generic implementation
CBasisFunction
CBatch
CBatches	These classes encapsulate the necessary data for the computations
CBeta_interval_length
CBinaryOpPolicy
CBinningRestorer
CBinomialNeymanInterval	Implement noncentral binomial confidence intervals using the Neyman construction
CBinomialProbHelper	Helper class impelementing the binomial probability and the likelihood ratio used for ordering the interval in the FeldmanCousins interval class
CBoolNameTable_t
CBRESINFO
CBuildNodeInfo
CCaloTowerProxyBuilder
CCanvasPainterGenerator	Creates RCanvasPainter objects
CCellData_t	Cell data inner structure
CCellGeom_t	Cell geometry inner structure
Ccgi_environment
CChangeGuard	RAII guard for locking Eve manager (ctor) and processing changes (dtor)
CChangeOperModeRAII	Struct to temporarily change the operation mode of a RooAbsArg until it goes out of scope
CCHAR64LONG16
CCheckModuleBuildClient	Custom diag client for clang that verifies that each implicitly build module is a system module
CClassification	Class to perform two class classification
CClassificationResult	Class to save the results of the classifier
CClassSelectionRule
Cclnt_HS_t
CCollectionManager
CColorStruct_t
CCompareAsc
CcompareBAasc
CcompareBAdesc
CCompareDataHistBins
CCompareDesc
CCompareSparseHistBins
CCompareVectorIndices
CContDist	Free functions adapter needed by UNURAN for onedimensional continuous distributions
Ccout_redirect
CCPPYY_G__p2p
CCPPYY_G__value
CCpuInfo_t
CCPyCppyy_tagCDataObject
CCPyCppyy_tagPyCArgObject
CCreateMethodPlugins	Plugins analysis
CCrossValidation
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
CDataKey	To use as a key type for RooFit data maps and containers
CDataloader
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
CDefaultIcon_t
CdField	Struct used by ShowGuidelines to store the distance Field between objects in the canvas
Cdir_scan_data
CDisableCachingRAII	Disable all caches for sub-branches in an expression tree
CDiscrDist	Free functions adapter needed by UNURAN for one-dimensional discrete distribution
CDoWork
CEdgeTable
CEfficiencyPlotWrapper	Note: This file assumes a certain structure on the input file
CEmptyCall
CENTupleColumnType	The available trivial, native content types of a column
CEvent
CEvent_t	Event structure
CEventManager
CExceptionContext_t
Cextrapolation_table
CFactory
CFakeCrossingEvent
CFeldmanCousinsBinomialInterval
CFeldmanCousinsSorter
CfileDesc
CFileStat_t
CFindFileData_t	Struct used to pass information between OpenDirectory and GetDirEntry in a thread safe way (each thread creates a new instance of it)
CFlagConvResult
CFMFunc
CFoamDistribution
CFoamIntegrandFunction
CFontAttributes_t
CFontMetrics_t
CFontStateMap_t
CFoo
CFoption_t
Cfuncptr_and_voidptr_t
CFWSelectionDeviator
CGcCache_t
CGCValues_t	Graphics context structure
CGenericRooFIter	Interface for RooFIter-compatible iterators
CGFunc
CGifColorType
CGInverseFunc
CGInverseFuncNdim
CGraphCreatorHelper	Helper class that provides the operation graph nodes
Cgroup
Cgsl_function_struct
Cgsl_integration_workspace
Ch1analysis
Ch1analysisTreeReader
CHAddArgs
CHelperOps
CHEPEVT_DEF	HEPEVT common block
CHit
CHoption_t	Histograms' drawing options structure
CHparam_t	Histogram parameters structure
CHypoTestWrapper
Cil_params
CIndexSortComparator
CIPFType
Cis_specialization
Cis_specialization< Ref< Args... >, Ref >
Citerplugin
Ciu_params
CJet
CJetEvent
CJetProxyBuilder
CJupyROOTExecutorHandler
CKeySymbolMap_t
CkNN	KNN::Event describes point in input variable vector-space, with additional functionality like distance between points
CLayoutChunk_t
CLikeFunction1
►CLinkdefReader
COptions
CLinkdefReaderPragmaHandler
CLsTreeEntry_t
CMarkerDescription_t
Cmd5_state_s
CMD5Mod_t
CMemInfo_t
CMemory_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
CMIR_TL_Data_t
Cmodule_state
CMultiDist	Free functions adapter needed by UNURAN for multidimensional cont distribution
CMWMHintsProperty_t
CmyDetectorData
CMyFunctor
CMYSQL_BIND
CMYSQL_STMT
CNameCleanerForIO	An helper class to dismount the name and remount it changed whenever necessary
Cnan_value_t
CNewColorMapType
C<NSApplicationDelegate>
CNSEvent
CNSObject
CNSView
CNSWindow
C<NSWindowDelegate>
CNumericalDerivator	Original version created on: Aug 14, 2013 Authors: L
Cobject
COverloadedCall
CPadRefresher
CPaltFunction
►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):
CCacheElem
CNumBins
CPassiveKeyGrab
Cpasswd
CPattern
CPCREPriv_t
CPdfWrapper
CPgSQL_Stmt_t
CPictureAttributes_t
►CPiecewiseInterpolation	The PiecewiseInterpolation is a class that can morph distributions into each other, which is useful to estimate systematic uncertainties
CCacheElem
CPoint_t	Point structure (maps to the X11 XPoint structure)
CPragmaCreateCollector
CPragmaExtraInclude
CPragmaIoReadInclude
CPragmaLinkCollector
Cprocess_control_data
CProcInfo_t
CProgressMonitor
Cpthread_cond_t
CQuad
CQuantizedColorType
CQuartzImage
CQuartzPixmap
CQuartzView
CQuartzWindow
CQuartzWindowProperty
CR__rsa_KEY
CR__rsa_KEY_export
CR__rsa_NUMBER
CRbcClass	This file contains the code for cuda computations using the RooBatchCompute library
CRBrowserGeomProvider
CRBrowserGeomWidget
CRBrowserRCanvasProvider
CRBrowserRCanvasWidget
CRBrowserTCanvasProvider
CRBrowserTCanvasWidget
CRBrowserTreeProvider
CRBrowserTreeWidget
CRByteSwap	Helper templated class for swapping bytes; specializations for N={2,4,8} are provided below
CRByteSwap< 2 >
CRByteSwap< 4 >
CRByteSwap< 8 >
CRCaloTower
CRColumnReaderBase	Pure virtual base class for all column reader types
CRDefaultProvider
Cread_auth_file_struct
CRealInfo_t
CRecHit
►CRecHitProxyBuilder
CFWBoxSet
CRectangle_t	Rectangle structure (maps to the X11 XRectangle structure)
CRedirectHandle_t
CREve3DProjection	3D scaling projection
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
CREveCaloDataVec	Calo data for universal cell geometry
CREveCaloLego	Visualization of calorimeter data as eta/phi histogram
CREveCaloTowerSliceSelector
CREveCaloViz	Base class for calorimeter data visualization
CREveChunkManager	Vector-like container with chunked memory allocation
CREveCompound	Description of REveCompound
CREveCompoundProjected	Description of REveCompoundProjected
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
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
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
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
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
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
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
CREveProjected	Abstract base class for classes that hold results of a non-linear projection transformation
CREveProjection	Base-class for non-linear projections
CREveProjectionManager	Manager class for steering of projections and managing projected objects
CREveRefBackPtr	Base-class for reference-counted objects with reverse references to REveElement objects
CREveRefCnt	Base-class for reference-counted objects
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
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
CREveShape	Abstract base-class for 2D/3D shapes
CREveStraightLineSetProjected	Projected replica of a REveStraightLineSet
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
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
CRFieldElement	Browsing element representing of RField
CRFieldHolder
►CRFieldProvider	Base class for provider of RNTuple drawing
CRDrawVisitor
CRFieldsIterator	Iterator over RNTuple fields
CRFitPanel	Web-based FitPanel prototype
CRGroupIter
CRInterfaceBase	The public interface to the RDataFrame federation of classes
Crng_state_st
CRNTupleBrowseProvider	Provider for browsing RNTuple classes
CRNTupleDraw6Provider	Provider for RNTuple drawing on TCanvas
CRNTupleDraw7Provider	Provider for RNTuple drawing on RCanvas
CRNTupleElement	Browsing element representing of RNTuple
CRoo1DTable	One-dimensional table
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
CCacheElem
►CRooAbsArg	Common abstract base class for objects that represent a value and a "shape" in RooFit
CProxyListCache
CRooAbsBinning	Abstract base class for RooRealVar binning definitions
CRooAbsCache	Abstract base class for data members of RooAbsArgs that cache other (composite) RooAbsArg expressions
►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
CAnaIntConfig
CPdfCacheElem
►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
CFuncCacheElem
CRooAbsCacheElement	Abstract base class for objects to be stored in RooAbsCache cache manager objects
CRooAbsCategory	A space to attach TBranches
CRooAbsCategoryLegacyIterator
CRooAbsCategoryLValue	Abstract base class for objects that represent a discrete value that can be set from the outside, i.e
►CRooAbsCollection	Abstract container object that can hold multiple RooAbsArg objects
CRooAbsArgPtrOrDouble
►CRooAbsData	Abstract base class for binned and unbinned datasets
CPlotOpt
CRooAbsDataHelper	This is a helper for an RDataFrame action, which fills RooFit data classes
CRooAbsDataStore	Abstract base class for a data collection
CRooAbsFunc	Abstract interface for evaluating a real-valued function of one real variable and performing numerical algorithms on it
CRooAbsGenContext	Abstract base class for generator contexts of RooAbsPdf objects
CRooAbsHiddenReal	Base class for objects that want to hide their return value from interactive use, e.g
CRooAbsIntegrator	Abstract interface for integrators of real-valued functions that implement the RooAbsFunc interface
CRooAbsLValue	Abstract base class for objects that are lvalues, i.e
CRooAbsMCStudyModule	Base class for add-on modules to RooMCStudy that can perform additional calculations on each generate+fit cycle managed by RooMCStudy
CRooAbsMinimizerFcn
CRooAbsMoment
►CRooAbsPdf	Abstract interface for all probability density functions
CCacheElem	Normalization set with for above integral
CGenSpec
CRooAbsProxy	Abstract interface for proxy classes
►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
CEvalError
CEvalErrorContext	Context to temporarily change the error logging mode as long as the context is alive
CGlobalSelectComponentRAII
CPlotOpt
CRef	A RooAbsReal::Ref can be constructed from a RooAbsReal& or a double that will be implicitly converted to a RooConstVar&
CRooAbsRealLValue	Abstract base class for objects that represent a real value that may appear on the left hand side of an equation ('lvalue')
CRooAbsSelfCached	Abstract base class for functions whose output is cached in terms of a histogram in all observables between getVal() and evaluate()
CRooAbsStudy	Abstract base class for RooStudyManager modules
CRooAdaptiveGaussKronrodIntegrator1D	Implements the Gauss-Kronrod integration algorithm
CRooAddGenContext	Efficient implementation of the generator context specific for RooAddPdf PDFs
►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
CCacheElem
►CRooAddModel	RooAddModel is an efficient implementation of a sum of PDFs of the form
CIntCacheElem
CRooAddPdf	Efficient implementation of a sum of PDFs of the form
CRooAICRegistry	Utility class for operator p.d.f classes that keeps track of analytical integration codes and associated normalization and integration sets
CRooArgList	RooArgList is a container object that can hold multiple RooAbsArg objects
CRooArgProxy	Abstract interface for RooAbsArg proxy classes
CRooArgSet	RooArgSet is a container object that can hold multiple RooAbsArg objects
CRooArgusBG	RooArgusBG is a RooAbsPdf implementation describing the ARGUS background shape
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
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
CRooBinnedGenContext	Efficient implementation of the generator context specific for binned pdfs
CRooBinnedL	Implements a -log(likelihood) calculation from a dataset (assumed to be binned) and a PDF
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
CRooBinningCategory	Provides a real-to-category mapping defined by a series of thresholds
CRooBinSamplingPdf	The RooBinSamplingPdf is supposed to be used as an adapter between a continuous PDF and a binned distribution
CRooBinWidthFunction	Returns the bin width (or volume) given a RooHistFunc
CRooBlindTools
CRooBMixDecay	Class RooBMixDecay is a RooAbsAnaConvPdf implementation that describes the decay of B mesons with the effects of B0/B0bar mixing
CRooBreitWigner	Class RooBreitWigner is a RooAbsPdf implementation that models a non-relativistic Breit-Wigner shape
CRooBrentRootFinder	Implement the abstract 1-dimensional root finding interface using the Brent-Decker method
CRooBukinPdf	The RooBukinPdf implements the NovosibirskA function
CRooCachedPdf	Implementation of RooAbsCachedPdf that can cache any external RooAbsPdf input function provided in the constructor
CRooCachedReal	Implementation of RooAbsCachedReal that can cache any external RooAbsReal input function provided in the constructor
CRooCacheManager	Manages the storage of any type of data indexed on the choice of normalization and optionally the set of integrated observables
CRooCategory	Object to represent discrete states
CRooCatType	RooCatType is an auxiliary class for RooAbsCategory and defines a a single category state
CRooCBShape	PDF implementing the Crystal Ball line shape
CRooCFunction1Binding	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
CRooCFunction1Map
CRooCFunction1PdfBinding
CRooCFunction1Ref
CRooCFunction2Binding	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
CRooCFunction2Map
CRooCFunction2PdfBinding
CRooCFunction2Ref
CRooCFunction3Binding	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
CRooCFunction3Map
CRooCFunction3PdfBinding
CRooCFunction3Ref
CRooCFunction4Binding	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
CRooCFunction4Map
CRooCFunction4PdfBinding
CRooCFunction4Ref
CRooChangeTracker	Meta object that tracks value changes in a given set of RooAbsArgs by registering itself as value client of these objects
CRooChebychev	Chebychev polynomial p.d.f
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
CRooChi2Var
CRooChiSquarePdf	The PDF of the Chi Square distribution for n degrees of freedom
CRooClassFactory	Similar to TTree::MakeClass(), generates skeleton code for RooAbsPdf and RooAbsReal functions given a list of input parameter names
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
►CRooCmdConfig	Configurable parser for RooCmdArg named arguments
CVar
CRooCollection_t
CRooCollectionProxy	Concrete proxy for RooArgSet or RooArgList objects
CRooCompositeDataStore	Combines several disjunct datasets into one
CRooConstraintSum	Calculates the sum of the -(log) likelihoods of a set of RooAbsPfs that represent constraint functions
CRooConstVar	Represents a constant real-valued object
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
CRooConvGenContext	Efficient implementation of the generator context specific for RooAbsAnaConvPdf objects
CRooCrystalBall	PDF implementing the generalized Asymmetrical Double-Sided Crystall Ball line shape
CRooCurve	One-dimensional graphical representation of a real-valued function
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)
►CRooDataHist	Container class to hold N-dimensional binned data
CVarInfo	Structure to cache information on the histogram variable that is frequently used for histogram weights retrieval
CRooDataHistSliceIter	Iterates over all bins in a RooDataHist that occur in a slice defined by the bin coordinates of the input sliceSet
CRooDataProjBinding	Adaptor that projects a real function via summation of states provided in a dataset
CRooDataSet	Container class to hold unbinned data
CRooDecay	Single or double sided decay function that can be analytically convolved with any RooResolutionModel implementation
CRooDerivative	Represents the first, second, or third order derivative of any RooAbsReal as calculated (numerically) by the MathCore Richardson derivator class
CRooDirItem	Utility base class for RooFit objects that are to be attached to ROOT directories
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)
CRooDouble	Minimal implementation of a TObject holding a double value
CRooDstD0BG	Special p.d.f shape that can be used to model the background of D*-D0 mass difference distributions
CRooEffGenContext	Specialized generator context for p.d.fs represented by class RooEffProd, which are p.d.fs multiplied with an efficiency function
CRooEfficiency	A PDF helper class to fit efficiencies parameterized by a supplied function F
CRooEffProd	The class RooEffProd implements the product of a PDF with an efficiency function
CRooEllipse	Two-dimensional ellipse that can be used to represent an error contour
CRooErrorHandler
CRooErrorVar	Auxiliary class that represents the error of a RooRealVar as a separate object
►CRooExpensiveObjectCache	Singleton class that serves as repository for objects that are expensive to calculate
CExpensiveObject
CRooExponential	Exponential PDF
CRooExtendedBinding
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
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:
►CRooFactoryWSTool	Implementation detail of the RooWorkspace
CIFace
CSpecialsIFace
►CRooFFTConvPdf	PDF for the numerical (FFT) convolution of two PDFs
CFFTCacheElem
CRooFirstMoment
CRooFIter	A one-time forward iterator working on RooLinkedList or RooAbsCollection
CRooFIterForLinkedList	Implementation of the GenericRooFIter interface for the RooLinkedList
CRooFitMoreLib
CRooFitResult	RooFitResult is a container class to hold the input and output of a PDF fit to a dataset
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)
CRooFunctor	Lightweight interface adaptor that exports a RooAbsPdf as a functor
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
CRooFunctor1DPdfBinding
CRooFunctorBinding	RooFunctorBinding makes math functions from ROOT usable in RooFit
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
CRooGaussKronrodIntegrator1D	Implements the Gauss-Kronrod integration algorithm
CRooGaussModel	Class RooGaussModel implements a RooResolutionModel that models a Gaussian distribution
CRooGenContext	Implements a universal generator context for all RooAbsPdf classes that do not have or need a specialized generator context
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
CRooGenFitStudy	Abstract base class for RooStudyManager modules
CRooGExpModel	The RooGExpModel is a RooResolutionModel implementation that models a resolution function that is the convolution of a Gaussian with a one-sided exponential
CRooGlobalFunc
CRooHist	Graphical representation of binned data based on the TGraphAsymmErrors class
CRooHistConstraint	The RooHistConstraint implements constraint terms for a binned PDF with statistical uncertainties
►CRooHistError	Singleton class used to calculate the error bars for each bin of a RooHist object
CBinomialSumAsym
CBinomialSumEff
CPoissonSum
CRooHistFunc	A real-valued function sampled from a multidimensional histogram
CRooHistPdf	A probability 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
►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
CMorphCacheElem
CRooInvTransform	Lightweight function binding that returns the inverse of an input function binding
►CRooJeffreysPrior	Implementation of Jeffrey's prior
CCacheElem
CRooJohnson	Johnson's \( S_{U} \) distribution
►CRooJSONFactoryWSTool	When using RooFit, statistical models can be conveniently handled and stored as a RooWorkspace
CCombinedData
CDependencyMissingError
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
►CRooLagrangianMorphFunc	Class RooLagrangianMorphing is a implementation of the method of Effective Lagrangian Morphing, described in ATL-PHYS-PUB-2015-047
CCacheElem
CConfig
CRooLandau	Landau distribution p.d.f
CRooLegacyExpPoly	RooLegacyExpPoly implements a polynomial PDF of the form
CRooLinearCombination	RooLinearCombination is a class that helps perform linear combination of floating point numbers and permits handling them as multiprecision
CRooLinearVar	RooLinearVar is the most general form of a derived real-valued object that can be used by RooRealIntegral to integrate over
CRooLinkedList	Collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list
CRooLinkedListElem	Link element for the RooLinkedList class
CRooLinkedListIter	A wrapper around TIterator derivatives
CRooLinkedListIterImpl	Implementation of the actual iterator on RooLinkedLists
CRooLinTransBinning	Special binning implementation for RooLinearVar that transforms the binning of the RooLinearVar input variable in the same way that RooLinearVar does
CRooLognormal	RooFit Lognormal PDF
►CRooMappedCategory	RooMappedCategory provides a category-to-category mapping defined by pattern matching on their state labels
CEntry
CRooMappedCategoryCache
CRooMath
CRooMathCoreReg
CRooMathMoreReg
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
►CRooMinimizer	Wrapper class around ROOT::Math::Minimizer that provides a seamless interface between the minimizer functionality and the native RooFit interface
CConfig	Config argument to RooMinimizer constructor
CFitResult
CFitterInterface
CRooMoment
►CRooMomentMorph
CCacheElem
►CRooMomentMorphFunc
CCacheElem
►CRooMomentMorphFuncND
CCacheElem
CGrid2
►CRooMsgService	Singleton class that organizes messages generated in RooFit
CStreamConfig
CRooMultiBinomial	RooMultiBinomial is an efficiency function which makes all combinations of efficiencies given as input different efficiency functions for different categories
CRooMultiCategory	Connects several RooAbsCategory objects into a single category
►CRooMultiVarGaussian	Multivariate Gaussian p.d.f
CAnaIntData
CBitBlock
CGenData
CRooNameReg	Registry for const char* names
CRooNaNPacker	Little struct that can pack a float into the unused bits of the mantissa of a NaN double
►CRooNDKeysPdf	Generic N-dimensional implementation of a kernel estimation p.d.f
CBoxInfo
CRooNLLVar
CRooNonCentralChiSquare	The PDF of the Non-Central Chi Square distribution for n degrees of freedom
CRooNonCPEigenDecay	Time-dependent RooAbsAnaConvPdf for CP violating decays to Non-CP eigenstates (eg, \( B_0 \rightarrow \rho^\pm \pi^\mp\))
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
CRooNovosibirsk	RooNovosibirsk implements the Novosibirsk function
CRooNumber	Provides numeric constants used in RooFit
CRooNumCdf	Implementation of RooNumRunningInt that calculates cumulative distribution functions from p.d.f.s
CRooNumConvolution	Numeric 1-dimensional convolution operator PDF
CRooNumConvPdf	Numeric 1-dimensional convolution operator PDF
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
►CRooNumIntFactory	Factory to instantiate numeric integrators from a given function binding and a given configuration
CPluginInfo
►CRooNumRunningInt	Implementation of RooAbsCachedReal that represents a running integral
CRICacheElem
CRooObjCacheManager	Implementation of a RooCacheManager<RooAbsCacheElement> that specializes in the storage of cache elements that contain RooAbsArg objects
CRooParamBinning	Implementation of RooAbsBinning that constructs a binning with a range definition that depends on external RooAbsReal objects
CRooParametricStepFunction	The Parametric Step Function PDF is a binned distribution whose parameters are the heights of each bin
CRooParamHistFunc	A histogram function that assigns scale parameters to every bin
►CRooPlot	Plot frame and a container for graphics objects within that frame
CDrawOpt
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
CRooPoisson	Poisson pdf
CRooPolyFunc	RooPolyFunc implements a polynomial function in multi-variables
CRooPolynomial	RooPolynomial implements a polynomial p.d.f of the form
CRooPolyVar	A RooAbsReal implementing a polynomial in terms of a list of RooAbsReal coefficients
CRooPowerSum	RooPowerSum implements a power law PDF of the form
CRooPrintable	A 'mix-in' base class that define the standard RooFit plotting and printing methods
CRooProdGenContext	Efficient implementation of the generator context specific for RooProdPdf PDFs
►CRooProdPdf	Efficient implementation of a product of PDFs of the form
CCacheElem
CFactorized
CProcessProductTermOutput
►CRooProduct	Represents the product of a given set of RooAbsReal objects
CCacheElem
CProdMap
CRooProfileLL	Implements the profile likelihood estimator for a given likelihood and set of parameters of interest
►CRooProjectedPdf	A RooAbsPdf implementation that represent a projection of a given input p.d.f and the object returned by RooAbsPdf::createProjection
CCacheElem
CRooPullVar	Represents the pull of a measurement w.r.t
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
CGuard
►CRooRandomizeParamMCSModule	Add-on module to RooMCStudy that allows you to randomize input generation parameters
CGausParam
CGausParamSet
CUniParam
CUniParamSet
CRooRangeBinning	Binning/range definition that only defines a range but no binning
CRooRangeBoolean	Returns 1.0 if variable is within given a range and 0.0 otherwise
CRooRatio	Represents the ratio of two RooAbsReal objects
CRooRealBinding	Lightweight interface adaptor that binds a RooAbsReal object to a subset of its servers and present it as a simple array oriented interface
CRooRealConstant	Provides static functions to create and keep track of RooRealVar constants
CRooRealIntegral	Performs hybrid numerical/analytical integrals of RooAbsReal objects
CRooRealSumFunc
►CRooRealSumPdf	Implements a PDF constructed from a sum of functions:
CCacheElem
CRooRealVar	Variable that can be changed from the outside
CRooRealVarSharedProperties	Implementation of RooSharedProperties that stores the properties of a RooRealVar that are shared among clones
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 \( {a_i} \), it returns \( a_n * \prod_{i=0}^{n-1} (1 - a_i) \)
CRooRefArray
CRooResolutionModel	RooResolutionModel is the base class for PDFs that represent a resolution model that can be convoluted with a physics model of the form
CRooSecondMoment
►CRooSharedProperties	Class RooSharedProperties is the base class for shared properties that can be stored in RooSharedPropertiesList
CUUID
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
►CRooSimultaneous	Facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset
CCacheElem
CInitializationOutput	Internal struct used for initialization
►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
CBuildConfig
CMultiBuildConfig
CObjBuildConfig
CObjSplitRule
CSplitRule
CRooSpHarmonic	Implementation of the so-called real spherical harmonics, using the orthonormal normalization, which are related to spherical harmonics as:
CRooSpline	A RooFit class for creating spline functions
CRooStepFunction	The Step Function is a binned function whose parameters are the heights of each bin
CRooStreamParser
CRooStringVar	A RooAbsArg implementing string values
CRooStringView	The RooStringView is a wrapper around a C-style string that can also be constructed from a std::string or a TString
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
CRooSubsidiaryL	Calculates the sum of the -(log) likelihoods of a set of RooAbsPdf objects that represent subsidiary or constraint functions
CRooSuperCategory	Joins several RooAbsCategoryLValue objects into a single category
CRooTable	Abstract interface for table objects
CROOTApplicationDelegate
CRooTemplateProxy
CRooTFnBinding	Use TF1, TF2, TF3 functions as RooFit objects
CRooTFnPdfBinding
CRooThresholdCategory	A real-to-category mapping defined by a series of thresholds
CRooTMathReg
CROOTOpenGLView
CRooTrace	Controls the memory tracing hooks in all RooFit objects
CRooTreeData
CRooTreeDataStore	TTree-backed data storage
CRooTruthModel	Implements a RooResolution model that corresponds to a delta function
CRooUnbinnedL	A -log(likelihood) calculation from a dataset (assumed to be unbinned) and a PDF
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
CRooUniform	Flat p.d.f
CRooUniformBinning	Implementation of RooAbsBinning that provides a uniform binning in 'n' bins between the range end points
►CRooVectorDataStore	Uses std::vector to store data columns
►CArraysStruct	Output struct for the RooVectorDataStore::getArrays() helper function
CArrayInfo
CCatVector
CRealFullVector
CRealVector
CRooVoigtian	RooVoigtian is an efficient implementation of the convolution of a Breit-Wigner with a Gaussian, making use of the complex error function
►CRooWorkspace	Persistable container for RooFit projects
►CCodeRepo
CClassFiles
CClassRelInfo
CExtraHeader
CWSDir
CRooWorkspaceHandle	An interface to set and retrieve a workspace
CRooWrapperPdf	The RooWrapperPdf is a class that can be used to convert a function into a PDF
CRotatedTextItemTemplate_t
Crsa_KEY
Crsa_KEY_export
Crsa_NUMBER
►CRScanner
CAnnotatedNamespaceDecl
CDelayedAnnotatedRecordDeclInfo
CRShared< T >	Holder of with shared_ptr<T> instance
CRTFileProvider	Provides access to ROOT files with extension "root" Other extensions can be registered
CRTObjectProvider	Provider for all known TObject-based classes
CRUnique< T >	Holder of with unique_ptr<T> instance
CRunStopper
CRVisual
CRXColor
CRXGCValues
CRXImage
CRXpmAttributes
CRXPoint
CRXSetWindowAttributes
CRXVisualInfo
CSegment_t	Used for drawing line segments (maps to the X11 XSegments structure)
CSelectionRules	The class representing the collection of selection rules
CSetFreeIfTMapFile_t	Set ROOT::Internal::gFreeIfTMapFile on library load
CSetWindowAttributes_t	Attributes that can be used when creating or changing a window
CSgEsc_t
CSHA_CTX
CSharedOffset
CSHtmlExtensions_t
CSHtmlIndex_t
CSHtmlMargin_t
CSHtmlStyle_t
CSHtmlStyleStack_t
CSHtmlTokenMap_t
CSignalmap_t
Csocket
CSOFIE_GNN
CSQLite3_Stmt_t
Csrv_HS_t
Cssl_func
CStyleTemplate_t
CSXmlAttr_t
CSXmlDoc_t
CSXmlNode_t
CSysInfo_t
CSYSTEM_BASIC_INFORMATION
CSYSTEM_PERFORMANCE_INFORMATION
CTA
CTAdvancedGraphicsDialog	Allows to create advanced graphics from the last fit made in the fitpanel
CTakeAValue
CTAnnotation	An annotation is a TLatex which can be drawn in a 2D or 3D space
CTApplication	This class creates the ROOT Application Environment that interfaces to the windowing system eventloop and eventhandlers
CTApplicationImp	ABC describing GUI independent application implementation protocol
►CTApplicationRemote
CTARFileStat
CTApplicationServer
CTArc	Create an Arc
CTArcBall	Implements the arc-ball rotation manipulator
CTArchiveFile	Class describing an archive file containing multiple sub-files, like a ZIP or TAR archive
CTArchiveMember
CTARInterruptHandler
CTArray	Abstract array base class
CTArrayC	Array of chars or bytes (8 bits per element)
CTArrayD	Array of doubles (64 bits per element)
CTArrayF	Array of floats (32 bits per element)
CTArrayI	Array of integers (32 bits per element)
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
CTArrayL	Array of longs (32 or 64 bits per element)
CTArrayL64	Array of long64s (64 bits per element)
CTArrayS	Array of shorts (16 bits per element)
CTArrow	Draw all kinds of Arrows
CTArrowEditor	Implements user interface for editing of arrow attributes: shape, size, angle
CTASImage	Image class
CTASImagePlugin
CTASInputHandler
CTASInterruptHandler
CTASLogHandler
CTASLogHandlerGuard
►CTASPaletteEditor	This is a GUI window to edit a color palette
CLimitLine
CPaintPalette
CTASPluginGS	Allows to read PS/EPS/PDF files via GhostScript
CTASPngWriter	C++ wrapper over simple writer of PNG files for standard GL memory formats: LUMINANCE, LUMINANCE_ALPHA, RGB, and RGBA
CTASSigPipeHandler
CTAsyncOpenHandler
CTAsyncReadvHandler
►CTAtomicCount
CLockGuard
CTAtt3D	Use this attribute class when an object should have 3D capabilities
CTAttAxis	Manages histogram axis attributes
CTAttBBox	Helper for management of bounding-box information
CTAttBBox2D	Abstract base class for elements drawn in the editor
CTAttCanvas	Manages canvas attributes
CTAttFill	Fill Area Attributes class
CTAttFillEditor	Implements GUI for editing fill attributes
CTAttImage	TImage attributes
CTAttLine	Line Attributes class
CTAttLineEditor	Implements GUI for editing line attributes
CTAttMarker	Marker Attributes class
CTAttMarkerEditor	Implements GUI for editing marker attributes
CTAttPad	Manages default Pad attributes
CTAttParticle	Particle definition, partly based on GEANT3 particle definition
CTAttText	Text Attributes class
CTAttTextEditor	Implements GUI for editing text attributes
CTAuthenticate
CTAutoBinVal
CTAutoInspector
CTAxis	Class to manage histogram axis
CTAxis3D	The 3D axis painter class
CTAxisEditor	Implements GUI for axis attributes
CTAxisModLab	TAxis helper class used to store the modified labels
CTBackCompFitter	Backward compatible implementation of TVirtualFitter
CTBase64	This code implements the Base64 encoding and decoding
CTBaseClass	Each class (see TClass) has a linked list of its base class(es)
CTBasket	Manages buffers for branches of a Tree
CTBasketSQL	Implement TBasket for a SQL backend
CTBenchmark	This class is a ROOT utility to help benchmarking applications
CTBinIterator
CTBinomialEfficiencyFitter	Binomial fitter for the division of two histograms
►CTBits	Container of bits
CTReference
CTBlinkTimer
CTBox	Create a Box
CTBranch	A TTree is a list of TBranches
CTBranchBrowseProvider
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
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
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
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
CElementBranchHelper_t
CTBrBrowsableElement	Representing TVirtualBranchBrowsable in browsables
CTBreakLineCom
CTBrElement	Representing TBranch in browsables
CTBRIK	A box with faces perpendicular to the axes
CTBrLeafElement	Representing TLeaf in browsables
CTBrowser	Using a TBrowser one can browse all ROOT objects
CTBrowserImp	ABC describing GUI independent browser implementation protocol
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)
CTBrowserTimer	Called whenever timer times out
CTBtInnerNode	Inner node of a TBtree
CTBtItem	Item stored in inner nodes of a TBtree
CTBtLeafNode	Leaf node of a TBtree
CTBtNode	Abstract base class (ABC) of a TBtree node
CTBtree	B-tree class
CTBtreeIter	Iterator of btree
CTBuffer	Buffer base class used for serializing objects
CTBuffer3D	Generic 3D primitive description class
CTBuffer3DCutTube	Cut tube segment description class - see TBuffer3DTypes for producer classes
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
CTBuffer3DTypes
CTBufferFile	The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket
CTBufferIO	Direct subclass of TBuffer, implements common methods for TBufferFile and TBufferText classes
CTBufferJSON	Class for serializing object to and from JavaScript Object Notation (JSON) format
CTBufferSQL	Implement TBuffer for a SQL backend
CTBufferSQL2	Converts data to SQL statements or read data from SQL tables
CTBufferText	Base class for text-based streamers like TBufferJSON or TBufferXML Special actions list will use methods, introduced in this class
CTBufferXML	Class for serializing/deserializing object to/from xml
CTBuildRealData
CTButton	A TButton object is a user interface object
CTCandle	The candle plot painter class
CTCanvas	The Canvas class
CTCanvasImp	ABC describing GUI independent main window (with menubar, scrollbars and a drawing area)
CTCanvasInit
CTCanvasWebSnapshot
CTChain	A chain is a collection of files containing TTree objects
CTChainElement	A TChainElement describes a component of a TChain
►CTChainIndex	A Chain Index
CTChainIndexEntry	Holds a description of indices of trees in the chain
CTCivetweb	THttpEngine implementation, based on civetweb embedded server
CTCivetwebWSEngine	TCivetwebWSEngine
►CTClass	TClass instances represent classes, structs and namespaces in the ROOT type system
CInsertTClassInRegistryRAII
CObjectPtr
CTDeclNameRegistry
CTClass__GetCallingNewRAII
CTClassGenerator	Objects following this interface can be passed onto the TROOT object to implement a user customized way to create the TClass objects
CTClassMenuItem	Describes one element of the context menu associated to a class The menu item may describe
CTClassRef	TClassRef is used to implement a permanent reference to a TClass object
CTClassStreamer
►CTClassTable	This class registers for all classes their name, id and dictionary function in a hash table
CNormalizeThenLock
CTClassTree	Draw inheritance tree and their relations for a list of classes
►CTCling	This class defines an interface to the cling C++ interpreter
CCharPtrCmp_t
CMutexStateAndRecurseCount
CMutexStateAndRecurseCountDelta
CSuspendAutoLoadingRAII
CTUniqueString
CTClingBaseClassInfo	Emulation of the CINT BaseClassInfo class
CTClingCallbacks
CTClingCallFunc	Emulation of the CINT CallFunc class
CTClingClassInfo	Emulation of the CINT ClassInfo class
►CTClingCXXRecMethIter	Iterate over FunctionDecl and UsingShadowDecls of FunctionDecl, within a scope, recursing through "transparent" scopes (see DCIter::HandleInlineDeclContext())
CSpecFuncIter
CTClingDataMemberInfo	Emulation of the CINT DataMemberInfo class
CTClingDataMemberIter	Iterate over VarDecl, FieldDecl, EnumConstantDecl, IndirectFieldDecl, and UsingShadowDecls thereof, within a scope, recursing through "transparent" scopes (see DCIter::HandleInlineDeclContext())
CTClingDeclInfo
CTClingDelegateDiagnosticPrinter	Uses clang::TextDiagnosticPrinter to format diagnostics, which are then passed to a user-specified function
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
CTClingMethodArgInfo	Emulation of the CINT MethodInfo class
CTClingMethodInfo	Emulation of the CINT MethodInfo class
►CTClingRdictModuleFileExtension	A module file extension used for testing purposes
CReader
CWriter
CTClingTypedefInfo	Emulation of the CINT TypedefInfo class
CTClingTypeInfo	Emulation of the CINT TypeInfo class
►CTClingValue	Bridge between cling::Value and ROOT
CHasTheSameSizeAsClingValue
CTClonesArray	An array of clone (identical) objects
CTCollection	Collection abstract base class
CTCollectionClassStreamer	Class streamer object to implement TClassStreamer functionality for I/O emulation
CTCollectionElement	Browsable element for TCollection
CTCollectionIter	Iterator over elements in TCollection
CTCollectionMemberStreamer	Class streamer object to implement TMemberStreamer functionality for I/O emulation
CTCollectionMethodBrowsable	TCollectionMethodBrowsable extends TCollectionPropertyBrowsable by showing all methods of the collection itself
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
CTCollectionProxyFactory	TCollectionProxyFactory Interface to collection proxy and streamer generator
CTCollectionStreamer	Class streamer object to implement TClassStreamer functionality for I/O emulation
CTColor	The color creation and management class
CTColorElement	Element representing TColor
►CTColorGradient	TColorGradient extends basic TColor
CPoint
CTColorNumber
CTColorWheel	Draw the ROOT Color Wheel
CTComplex
CTCondition
CTConditionImp
CTCondor
CTCondorSlave
CTCONE	A conical tube
CTConfidenceLevel	Class to compute 95% CL limits
CTCONS	A segment of a conical tube
CTContextMenu	This class provides an interface to context sensitive popup menus
CTContextMenuImp	This class provides an interface to GUI independent context sensitive popup menus
CTControlBar	A Control Bar is a fully user configurable tool which provides fast access to frequently used operations
CTControlBarButton	This class defines the control bar buttons
CTControlBarImp	ABC describing GUI independent control bar
CTConvertClonesArrayToProxy	Small helper to read a TBuffer containing a TClonesArray into any valid collection
CTConvertMapToProxy
CTCreatePrimitives	Creates new primitives
CTCrown	To draw a Crown
CTCTUB	A cut tube with 11 parameters
CTCurlyArc	Implements curly or wavy arcs used to draw Feynman diagrams
CTCurlyArcEditor	Implements GUI for editing CurlyArc attributes: radius, phi1, phi2
CTCurlyLine	Implements curly or wavy polylines used to draw Feynman diagrams
CTCurlyLineEditor	Implements GUI for editing CurlyLine attributes: shape, size, angle
CTCursorSwitcher	Helper class used to change the cursor in a method and restore the original one when going out of the method scope
CTCut	A specialized string object used for TTree selections
CTCutG	Graphical cut class
CTCylinderMesh
CTCylinderSegMesh
CTDatabasePDG	Particle database manager class
CTDataMember	All ROOT classes may have RTTI (run time type identification) support added
CTDataSetManager
CTDataSetManagerFile
CTDataType	Basic data type descriptor (datatype information is obtained from CINT)
CTDatime	This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130 124559)
CTDavixFile
CTDavixFileInternal
CTDavixSystem
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/
CTDCacheSystem
CTDecayChannel	Description of the decay channel
CTDecompBase	Decomposition Base class
CTDecompBK	The Bunch-Kaufman diagonal pivoting method decomposes a real symmetric matrix A using
CTDecompChol	Cholesky Decomposition class
CTDecompLU	LU Decomposition class
CTDecompQRH	QR Decomposition class
CTDecompSparse	Sparse Symmetric Decomposition class
CTDecompSVD	Single Value Decomposition class
CTDefHistImagePalette
CTDelCharCom
CTDelTextCom
CTDialogCanvas	A canvas specialized to set attributes
CTDiamond	Draw a Diamond
CTDictAttributeMap	The ROOT object has a list of properties which are stored and retrieved using TDictAttributeMap
CTDictionary	This class defines an abstract interface that must be implemented by all classes that contain dictionary information
CTDimensionInfo	A small helper class to help in keeping track of the array dimensions encountered in the analysis of the expression
►CTDirectory	Describe directory structure in memory
CTContext	TDirectory::TContext keeps track and restore the current directory
CTDirectoryElement	Element representing TDirectory
CTDirectoryFile	A ROOT file is structured in Directories (like a file system)
CTDirectoryLevelIter	Iterator over keys in TDirectory
CTDispatchTimer
CTDNDData	Drag and drop data container
CTDomParser	DOM stands for the Document Object Model; this is an API for accessing XML or HTML structured documents
CTDOMParser
CTDrawFeedback	Utility class to draw objects in the feedback list during queries
CTDSet	This class implements a data set to be used for PROOF processing
CTDSetElement	Manages an element of a TDSet
CTDSetProxy
CTDumpMembers
CTEditQueryFrame
CTEfficiency	Class to handle efficiency histograms
CTElementActionT
CTElementPosActionT
CTEllipse	Draw Ellipses
CTELTU	A cylinder with an elliptical section
CtempFileNamesCatalog	Little helper class to bookkeep the files names which we want to make temporary
CTEmulatedCollectionProxy	Streamer around an arbitrary STL like container, which implements basic container functionality
CTEmulatedMapProxy	Streamer around a map container
CTEngineHolder
CTEntryList	A List of entry numbers in a TTree or TChain
CTEntryListArray	A list of entries and subentries in a TTree or TChain
CTEntryListBlock	Used by TEntryList to store the entry numbers
CTEntryListFromFile	Manages entry lists from different files, when they are not loaded in memory at the same time
CTEnum	Implements the enum type
CTEnumConstant	Implements the constants of the enum type
CTEnv	Reads config files, by default named .rootrc
CTEnvParser	TEnv Parser
CTEnvRec
CTEve3DProjection	3D scaling projection
CTEveArrow	Class used for display of a thick arrow
CTEveArrowEditor	GUI editor for TEveArrow
CTEveArrowGL	OpenGL renderer class for TEveArrow
CTEveBox	3D box with arbitrary vertices (cuboid)
CTEveBoxGL	OpenGL renderer class for TEveBox
CTEveBoxProjected	Projection of TEveBox
CTEveBoxProjectedGL	OpenGL renderer class for TEveBoxProjected
►CTEveBoxSet	Collection of 3D primitives (fixed-size boxes, boxes of different sizes, or arbitrary sexto-epipeds, cones)
CBAABox_t
CBAABoxFixedDim_t
CBCone_t
CBEllipticCone_t
CBFreeBox_t
CBHex_t
CBOrigin_t
CTEveBoxSetGL	A GL rendering class for TEveBoxSet
CTEveBrowser	Specialization of TRootBrowser for Eve
CTEveCalo2D	Visualization of a calorimeter event data in 2D
CTEveCalo2DGL	OpenGL renderer class for TEveCalo2D
CTEveCalo3D	Visualization of a calorimeter event data in 3D
CTEveCalo3DEditor	GUI editor for TEveCalo3D
CTEveCalo3DGL	OpenGL renderer class for TEveCalo3D
►CTEveCaloData	A central manager for calorimeter event data
CCellData_t	Cell data inner structure
CCellGeom_t	Cell geometry inner structure
CCellId_t
CRebinData_t
CSliceInfo_t
CTEveCaloDataHist	A central manager for calorimeter data of an event written in TH2F
CTEveCaloDataVec	Calo data for universal cell geometry
CTEveCaloLego	Visualization of calorimeter data as eta/phi histogram
CTEveCaloLegoEditor	GUI editor for TEveCaloLego
►CTEveCaloLegoGL	OpenGL renderer class for TEveCaloLego
CCell2D_t
CTEveCaloLegoOverlay	GL-overlay control GUI for TEveCaloLego
CTEveCaloViz	Base class for calorimeter data visualization
CTEveCaloVizEditor	GUI editor for TEveCaloEditor
►CTEveChunkManager	Vector-like container with chunked memory allocation
Citerator
CTEveChunkVector
CTEveCluster
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
CTEveCompound	Description of TEveCompound
CTEveCompoundProjected	Description of TEveCompoundProjected
CTEveContextMenu	Specialization of TContext menu
►CTEveDigitSet	Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox)
CDigitBase_t
CTEveDigitSetEditor	Editor for TEveDigitSet class
CTEveDigitSetGL	OpenGL renderer class for TEveDigitSet
►CTEveElement	Base class for TEveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management
CTEveListTreeInfo	Structure holding information about TGListTree and TGListTreeItem that represents given TEveElement
CTEveElementEditor	Editor for TEveElement class
CTEveElementList	A list of TEveElements
CTEveElementListProjected	A projected element list – required for proper propagation of render state to projected views
CTEveEventManager	Base class for event management and navigation
CTEveException	Exception class thrown by TEve classes and macros
CTEveFrameBox	Description of a 2D or 3D frame that can be used to visually group a set of objects
CTEveFrameBoxGL	A class encapsulating GL rendering of TEveFrameBox via a static member function
CTEveGDoubleValuator	Composite GUI element for selection of range (label, two number-entries and double-slider)
CTEveGedEditor	Specialization of TGedEditor for proper update propagation to TEveManager
CTEveGedNameFrame	Specialization of TGedNameFrame used in EVE
CTEveGedNameTextButton	Specialization of TGTextButton for EVE name frame
CTEveGeoManagerHolder	Exception safe wrapper for setting gGeoManager
CTEveGeoNode	Wrapper for TGeoNode that allows it to be shown in GUI and controlled as a TEveElement
CTEveGeoNodeEditor	Editor for TEveGeoNode class
►CTEveGeoPolyShape	Description of TEveGeoPolyShape
CEdge_t
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)
CTEveGeoShapeExtract	Globally positioned TGeoShape with rendering attributes and an optional list of daughter shape-extracts
CTEveGeoShapeProjected	A 3D projected TEveGeoShape
CTEveGeoTopNode	A wrapper over a TGeoNode, possibly displaced with a global trasformation stored in TEveElement
CTEveGeoTopNodeEditor	Editor for TEveGeoTopNode class
CTEveGListTreeEditorFrame	Composite GUI frame for parallel display of a TGListTree and TEveGedEditor
CTEveGridStepper	Provide discrete position coordinates for placement of objects on regular grids
CTEveGridStepperEditor	Editor for TEveGridStepper class
CTEveGridStepperSubEditor	Sub-editor for TEveGridStepper class
CTEveGTriVecValuator	Composite GUI element for setting three numerical values (label, three number-entries)
CTEveGValuator	Composite GUI element for single value selection (supports label, number-entry and slider)
CTEveGValuatorBase	Base class for composite GUI elements for setting of numeric values
CTEveHit
CTEveJetCone	Draws a jet cone with leading particle is specified in (eta,phi) and cone radius is given
CTEveJetConeEditor	GUI editor for TEveJetCone
CTEveJetConeGL	OpenGL renderer class for TEveJetCone
CTEveJetConeProjected	Projection of TEveJetCone
CTEveJetConeProjectedGL	OpenGL renderer class for TEveJetConeProjected
CTEveLegoEventHandler	A base class of TGLEventHandler
CTEveLine	An arbitrary polyline with fixed line and marker attributes
CTEveLineEditor	Editor for TEveLine class
CTEveLineGL	GL-renderer for TEveLine class
CTEveLineProjected	Projected copy of a TEveLine
CTEveListTreeItem	Special list-tree-item for Eve
CTEveMacro	Sub-class of TMacro, overriding Exec to unload the previous version and cleanup after the execution
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
CTExceptionHandler	Exception handler for Eve exceptions
CTRedrawDisabler
CTEveMCRecCrossRef
CTEveMCTrack
CTEventIter	Special iterator class used in TProofPlayer to iterate over events or objects in the packets
CTEventIterObj
►CTEventIterTree
CTFileTree
CTEventIterUnit
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.
CTEvePad	This was intended as a TPad wrapper to allow smart updates of groups of pads
CTEvePadHolder	Exception safe wrapper for setting gPad
►CTEveParamList	Collection of named parameters
CBoolConfig_t
CFloatConfig_t
CIntConfig_t
CTEveParamListEditor	GUI editor for TEveParamList
CTEvePathMarkT	Special-point on track:
CTEvePlot3D	Description of TEvePlot3D
CTEvePlot3DGL	OpenGL renderer class for TEvePlot3D
CTEvePointSelector	TEvePointSelector is a sub-class of TSelectorDraw for direct extraction of point-like data from a Tree
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
CTEvePointSetArrayEditor	Editor for TEvePointSetArray class
CTEvePointSetProjected	Projected copy of a TEvePointSet
►CTEvePolygonSetProjected	A set of projected polygons
CPolygon_t
►CTEvePolygonSetProjectedGL	GL-renderer for TEvePolygonSetProjected class
CEdge_t
CTEveProjectable	Abstract base-class for non-linear projectable objects
CTEveProjected	Abstract base class for classes that hold results of a non-linear projection transformation
►CTEveProjection	Base-class for non-linear projections
CPreScaleEntry_t
CTEveProjectionAxes	Axes for non-linear projections
CTEveProjectionAxesEditor	GUI editor for TEveProjectionAxes
CTEveProjectionAxesGL	OpenGL renderer class for TEveProjectionAxes
CTEveProjectionManager	Manager class for steering of projections and managing projected objects
CTEveProjectionManagerEditor	GUI editor for TEveProjectionManager class
►CTEveQuadSet	Supports various internal formats that result in rendering of a set of planar (lines, rectangles, hexagons with shared normal) objects
CQFreeQuad_t
CQHex_t
CQLineFixC_t
CQOrigin_t
CQRect_t
CQRectFixC_t
CQRectFixDim_t
CQRectFixDimC_t
CTEveQuadSetGL	GL-renderer for TEveQuadSet class
CTEveRecCascade
CTEveRecKink
CTEveRecTrackT
CTEveRecV0
CTEveRefBackPtr	Base-class for reference-counted objects with reverse references to TEveElement objects
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
CTEveRGBAPaletteEditor	Editor for TEveRGBAPalette class
CTEveRGBAPaletteOverlay	Description of TEveRGBAPaletteOverlay
CTEveRGBAPaletteSubEditor	Sub-editor for TEveRGBAPalette class
CTEveRhoZProjection	Transformation from 3D to 2D
CTEveRPhiProjection	XY projection with distortion around given center
CTEveScalableStraightLineSet	Straight-line-set with extra scaling, useful for projectables that need to be scaled in accordance with an external object
CTEveScene	Eve representation of TGLScene
CTEveSceneInfo	TEveUtil representation of TGLSceneInfo
CTEveSceneList	List of Scenes providing common operations on TEveScene collections
CTEveSecondarySelectable	Semi-abstract interface for classes supporting secondary-selection
CTEveSelection	Make sure there is a SINGLE running TEveSelection for each selection type (select/highlight)
CTEveSelectorToEventList	TSelector that stores entry numbers of matching TTree entries into an event-list
CTEveShape	Abstract base-class for 2D/3D shapes
CTEveShapeEditor	GUI editor for TEveShape
►CTEveStraightLineSet	Set of straight lines with optional markers along the lines
CLine_t
CMarker_t
CTEveStraightLineSetEditor	Editor for TEveStraightLineSet class
CTEveStraightLineSetGL	GL-renderer for TEveStraightLineSet class
CTEveStraightLineSetProjected	Projected replica of a TEveStraightLineSet
CTEveText	TEveElement class used for displaying FreeType GL fonts
CTEveTextEditor	GUI editor for TEveText
CTEveTextGL	OpenGL renderer class for TEveText
CTEveTrack	Visual representation of a track
CTEveTrackEditor	Editor for TEveTrack class
CTEveTrackGL	GL-renderer for TEveTrack class
CTEveTrackList	A list of tracks supporting change of common attributes and selection based on track parameters
CTEveTrackListEditor	Editor for TEveTrackList class
CTEveTrackListProjected	Specialization of TEveTrackList for holding TEveTrackProjected objects
CTEveTrackProjected	Projected copy of a TEveTrack
CTEveTrackProjectedGL	GL-renderer for TEveTrackProjected class
►CTEveTrackPropagator	Holding structure for a number of track rendering parameters
CHelix_t
CTEveTrackPropagatorEditor	GUI editor for TEveTrackPropagator
CTEveTrackPropagatorSubEditor	Sub-editor for TEveTrackPropagator class
CTEveTrans	TEveTrans is a 4x4 transformation matrix for homogeneous coordinates stored internally in a column-major order to allow direct usage by GL
CTEveTransEditor	Editor for TEveTrans class
CTEveTransSubEditor	Sub-editor for TEveTrans class
CTEveTriangleSet	Made from a list of vertices and a list of triangles (triplets of vertex indices)
CTEveTriangleSetEditor	Editor for TEveTriangleSet class
CTEveTriangleSetGL	GL-renderer for TEveTriangleSet class
CTEveUtil	Standard utility functions for Eve
CTEveVector2T	Minimal, templated two-vector
CTEveVector4T	Minimal, templated four-vector
CTEveVectorT	Minimal, templated three-vector
CTEveViewer	Eve representation of TGLViewer
CTEveViewerList	List of Viewers providing common operations on TEveViewer collections
CTEveViewerListEditor	GUI editor for TEveViewerList
CTEveVSD	Visualization Summary Data - a collection of trees holding standard event data in experiment independent format
CTEveWindow	Abstract base-class for representing eve-windows
CTEveWindowEditor	GUI editor for TEveWindow
CTEveWindowFrame	Encapsulates TGFrame into an eve-window
CTEveWindowManager	Manager for EVE windows
CTEveWindowPack	Encapsulates TGPack into an eve-window
CTEveWindowSlot	Description of TEveWindowSlot
CTEveWindowTab	Encapsulates TGTab into an eve-window
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
CTExceptionHandler
CTExec	TExec is a utility class that can be used to execute a C++ command when some event happens in a pad
►CTExMap	This class stores a (key,value) pair using an external hash
CAssoc_t
CTExMapIter
►CTF1	1-Dim function class
CTF1FunctorPointer
CTF1FunctorPointerImpl
CTF12	A projection of a TF2 along X or Y
CTF1_EvalWrapper
CTF1AbsComposition
CTF1Convolution	Class wrapping convolution of two functions
CTF1Convolution_EvalWrapper
CTF1Editor	GUI for TF1 attributes and parameters
CTF1NormSum	Class adding two functions: c1*f1+c2*f2
CTF1Parameters	TF1 Parameters class
CTF2	A 2-Dim function with parameters
CTF2GL	GL renderer for TF2
CTF3	A 3-Dim function with parameters
CTFastCgi	THttpEngine implementation, based on fastcgi package
CTFastCgiCallArg
CTFdSet
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.
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
►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
CInfoListRet	Simple struct of the return value of GetStreamerInfoListImpl
CTFileCacheRead	A cache when reading files over the network
CTFileCacheWrite	A cache when writing files over the network
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
CTFileHandler
CTFileInfo	Class describing a generic file including meta information
CTFileInfoMeta
CTFileMergeInfo
CTFileMerger	This class provides file copy and merging services
CTFileOpenHandle	Class holding info about the file being opened
CTFilePrefetch	The prefetching mechanism uses two classes (TFilePrefetch and TFPBlock) to prefetch in advance a block of tree entries
CTFileStager
►CTFitEditor	Allows to perform, explore and compare various fits
CFuncParamData_t
CTFitParametersDialog	Create a dialog for fit function parameter settings
CTFitResult	Extends the ROOT::Fit::Result class with a TNamed inheritance providing easy possibility for I/O
CTFitResultPtr	Provides an indirection to the TFitResult class and with a semantics identical to a TFitResult pointer, i.e
►CTFITSHDU	FITS file interface class
CCell
CColumn
CHDURecord
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.
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
CTFoamMaxwt	Small auxiliary class for controlling MC weight
CTFoamSampler	Class implementing the ROOT::Math::DistSampler interface using FOAM for sampling arbitrary distributions
CTFoamVect	Auxiliary class TFoamVect of n-dimensional vector, with dynamic allocation used for the cartesian geometry of the TFoam cells
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.
CTFolderElement	Browsable element for TFolder
►CTFormLeafInfo	This class is a small helper class to implement reading a data member on an object stored in a TTree
CGetValueHelper
CGetValueHelper< Long64_t >
CGetValueHelper< LongDouble_t >
CGetValueHelper< ULong64_t >
CReadValueHelper
CReadValueHelper< Long64_t >
CReadValueHelper< LongDouble_t >
CReadValueHelper< ULong64_t >
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
CTFormula	The Formula class
CTFormulaFunction	Helper class for TFormula
CTFormulaParamOrder	Functor defining the parameter order
CTFormulaVariable	Another helper class for TFormula
CTFPBlock	This class represents the encapsulation of a block request
CTFractionFitter	Fits MC fractions to data histogram
CTFrame	Define a Frame
CTFrameEditor	Editor of frame objects
CTFree	Service class for TFile
CTFriendElement	A TFriendElement TF describes a TTree object TF in a file
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
CTFTP
CTFumili
CTFumiliMinimizer	TFumiliMinimizer class: minimizer implementation based on TFumili
CTFunction	Global functions class (global functions are obtained from CINT)
CTFunctionParametersDialog	This class is used for function parameter settings
CTFunctionTemplate	Dictionary for function template This class describes one single function template
CTG16ColorSelector	A composite frame with 16 TGColorFrames
CTGApplication	This class initialize the ROOT GUI toolkit
CTGAroundFrame
CTGaxis	The axis painter class
CTGButton	A button abstract base class
CTGButtonGroup	Organizes TGButton widgets in a group
CTGCanvas	A frame containing two scrollbars (a horizontal and a vertical) and a viewport
CTGCheckButton	Selects different options
CTGClient	Window client
CTGClientInit
CTGCocoa	This class implements TVirtualX interface for MacOS X, using Cocoa and Quartz 2D
CTGColorDialog	A full featured color selection dialog
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
CTGColorPopup	A popup containing a TG16ColorSelector and a "More..." button which popups up a TGColorDialog allowing custom color selection
CTGColorSelect	Like a checkbutton but instead of the check mark there is color area with a little down arrow
CTGColumnLayout	The following layout manager do not make use of TGLayoutHints
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
CTGCommandPlugin	Class used to redirect the command line input/output
CTGCompositeFrame	The base class for composite widgets (menu bars, list boxes, etc.)
CTGContainer	Manages a content area
CTGContainerKeyboardTimer
CTGContainerScrollTimer
CTGCursorWindow
CTGDimension
CTGDMAssignmentHelper
CTGDMLBaseTGDMMapHelper
CTGDMLMatrix	This class is used in the process of reading and writing the GDML "matrix" tag
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
CNameLst
CStructLst
CXyz
CTGDMMapHelper
CTGDNDManager
CTGDockableFrame	A frame with handles that allow it to be undocked (i.e
CTGDockButton
CTGDockHideButton
CTGDoubleHSlider	Dragging the slider will generate the event:
CTGDoubleSlider	DoubleSlider widgets allow easy selection of a min and a max value out of a range
CTGDoubleVSlider	Dragging the slider will generate the event:
CTGDragWindow	Window used as drag icon during drag and drop operations
CTGedEditor
►CTGedFrame	Base frame for implementing GUI - a service class
CTGedSubFrame
CTGedMarkerPopup	The TGedMarkerPopup is a popup containing buttons to select marker style
CTGedMarkerSelect	Button showing selected marker and a little down arrow
CTGedNameFrame
CTGedPatternFrame	The TGedPatternFrame is a small frame with border showing a specific pattern (fill style
CTGedPatternPopup	The TGedPatternPopup is a popup containing a TGedPatternSelector
CTGedPatternSelect	Button with pattern area with a little down arrow
CTGedPatternSelector	The TGedPatternSelector is a composite frame with TGedPatternFrames of all diferent styles
CTGedPopup	Popup window
CTGedSelect	Button that shows popup window when clicked
CTGedTabInfo
CTGenBitsetProxy
►CTGenCollectionProxy	Proxy around an arbitrary container, which implements basic functionality and iteration
CMethod	Small helper to execute (compiler) generated function for the access to STL or other containers
CMethod0
CStreamHelper	Helper class to facilitate I/O
CTStaging	Small helper to stage the content of an associative container when reading and before inserting it in the actual collection
CValue	Small helper to describe the Value_type or the key_type of an STL container
CTGenCollectionProxy__SlowIterator
CTGenCollectionStreamer
CTGenerator	The interface to various event generators
►CTGenericCollectionIterator
CRegularIterator
CVectorIterator
CTGenListProxy
CTGenMapProxy	Localoptimization class
CTGenPhaseSpace	Phase Space Generator, based on the GENBOD routine of CERNLIB
CTGenSetProxy	Localoptimization class
CTGenVectorBoolProxy	Local optimization class
CTGenVectorProxy	Local optimization class
CTGeoArb8	An arbitrary trapezoid with less than 8 vertices standing on two parallel planes perpendicular to Z axis
CTGeoAtt	Visualization and tracking attributes for volumes and nodes
►CTGeoBatemanSol	Class representing the Bateman solution for a decay branch
CBtCoef_t
CTGeoBBox	Box class
CTGeoBBoxEditor	Editor for a TGeoBBox
►CTGeoBoolNode	Base class for Boolean operations between two shapes
CThreadData_t
CTGeoBorderSurface
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
CTGeoCombiTrans	Class describing rotation + translation
CTGeoCombiTransEditor	Editor for a TGeoCombiTrans
CTGeoCompositeShape	Composite shapes are Boolean combinations of two or more shape components
CTGeoCone	The cones are defined by 5 parameters:
CTGeoConeEditor	Editor for a TGeoCone
CTGeoConeSeg	A cone segment is a cone having a range in phi
CTGeoConeSegEditor	Editor for a cone segment
CTGeoCtub	The cut tubes constructor has the form:
CTGeoCtubEditor	Editor for a TGeoCtub
CTGeoDecayChannel	Decay channel utility class
CTGeoElement	Base class for chemical elements
CTGeoElementRN	Radionuclide
CTGeoElementTable	Table of elements
CTGeoElemIter	Iterator for decay chains
CTGeoEltu	An elliptical tube is defined by the two semi-axes A and B
CTGeoEltuEditor	Editor for a TGeoEltu
CTGeoExtension	ABC for user objects attached to TGeoVolume or TGeoNode
CTGeoFacet
CTGeoGedFrame	Common base class for geombuilder editors
CTGeoGenTrans	Most general transformation, holding a translation, a rotation and a scale
CTGeoGlobalMagField	Global magnetic field manager
CTGeoGtra	A twisted trapezoid
CTGeoGtraEditor	Editor for a TGeoGtra
CTGeoHalfSpace	A half space is limited just by a plane, defined by a point and the normal direction
CTGeoHelix	Class representing a helix curve
CTGeoHMatrix	Matrix class used for computing global transformations Should NOT be used for node definition
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)
CTGeoHypeEditor	Editor for a TGeoHype
CTGeoIdentity	An identity transformation
CTGeoIntersection	Boolean node representing an intersection between two components
CTGeoIsotope	Isotope defined by the atomic number, number of nucleons and atomic weight (g/mole)
CTGeoIterator	A geometry iterator
CTGeoIteratorPlugin
CTGeoManager	The manager class for any TGeo geometry
CTGeoManagerEditor	Editor for TGeoManager class
CTGeoMaterial	Base class describing materials
CTGeoMaterialDialog
CTGeoMaterialEditor	Editors for materials
CTGeoMatrix	Geometrical transformation package
CTGeoMatrixDialog
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)
CTGeoMediumDialog
CTGeoMediumEditor	Editor class for TGeo tracking media
CTGeometry	TGeometry description
CTGeoMixture	Mixtures of elements
CTGeoMixtureEditor	Editors for mixtures
CTGeoNavigator	Class providing navigation API for TGeo geometries
CTGeoNavigatorArray
CTGeoNode	A node represent a volume positioned inside another.They store links to both volumes and to the TGeoMatrix representing the relative positioning
CTGeoNodeCache	Special pool of reusable nodes
CTGeoNodeEditor	Editor class for TGeoNode objects
CTGeoNodeMatrix	A node containing local transformation
CTGeoNodeOffset	Node containing an offset
CTGeoOpticalSurface	This is a wrapper class to G4OpticalSurface
CTGeoOverlap	Base class describing geometry overlaps
CTGeoPainter	Class implementing all draw interfaces for a generic 3D viewer using TBuffer3D mechanism
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
CTGeoParaEditor	Editor for a TGeoPara
►CTGeoParallelWorld	Base class for a flat parallel geometry
CSafetyVoxelInfo
CTGeoPatternCylPhi	Cylindrical phi divison pattern
CTGeoPatternCylR	Cylindrical R divison pattern
►CTGeoPatternFinder	Base finder class for patterns. A pattern is specifying a division type
CThreadData_t
CTGeoPatternHoneycomb	Divison pattern specialized for honeycombs
CTGeoPatternParaX	X axis divison pattern for PARA shapes
CTGeoPatternParaY	Y axis divison pattern for PARA shapes
CTGeoPatternParaZ	Z axis divison pattern for PARA shapes
CTGeoPatternSphPhi	Spherical phi divison pattern
CTGeoPatternSphR	Spherical R divison pattern
CTGeoPatternSphTheta	Spherical theta divison pattern
CTGeoPatternTrapZ	Z axis divison pattern for TRAP or GTRA shapes
CTGeoPatternX
CTGeoPatternY	Y axis divison pattern
CTGeoPatternZ	Z axis divison pattern
CTGeoPcon	A polycone is represented by a sequence of tubes/cones, glued together at defined Z planes
CTGeoPconEditor	Editor for a TGeoPcon
CTGeoPconSection	Utility frame used by TGeoPcon editor
►CTGeoPgon	Polygons are defined in the same way as polycones, the difference being just that the segments between consecutive Z planes are regular polygons
CThreadData_t
CTGeoPgonEditor	Editor for a TGeoPgon
CTGeoPhysicalNode	Physical nodes are the actual 'touchable' objects in the geometry, representing a path of positioned volumes starting with the top node: path=/TOP/A_1/B_4/C_3 , where A, B, C represent names of volumes
CTGeoPNEntry	The knowledge of the path to the objects that need to be misaligned is essential since there is no other way of identifying them
CTGeoPolygon	An arbitrary polygon defined by vertices
CTGeoRCExtension	Reference counted extension which has a pointer to and owns a user defined TObject
CTGeoRCPtr	A reference counting-managed pointer for classes derived from TGeoExtension which can be used as C pointer
CTGeoRegion	Regions are groups of volumes having a common set of user tracking cuts
CTGeoRegionCut
CTGeoRotation	Class describing rotations
CTGeoRotationEditor	Editor for a TGeoRotation
CTGeoScale	Class describing scale transformations
CTGeoScaledShape	A shape scaled by a TGeoScale transformation
CTGeoShape	Base abstract class for all shapes
CTGeoShapeAssembly	The shape encapsulating an assembly (union) of volumes
CTGeoShapeDialog
CTGeoSkinSurface
CTGeoSphere	TGeoSphere are not just balls having internal and external radii, but sectors of a sphere having defined theta and phi ranges
CTGeoSphereEditor	Editor for a TGeoSphere
CTGeoStateInfo	Statefull info for the current geometry level
CTGeoSubtraction	Boolean node representing a subtraction
CTGeoTabManager	Manager for all editor tabs
CTGeoTessellated	Tessellated solid class
CTGeoTorus	The torus is defined by its axial radius, its inner and outer radius
CTGeoTorusEditor	Editor for a TGeoTorus
CTGeoTrack
CTGeoTransientPanel
CTGeoTranslation	Class describing translations
CTGeoTranslationEditor	Editor for a TGeoTranslation
CTGeoTrap	A general trapezoid
CTGeoTrapEditor	Editor for a TGeoTrap
CTGeoTrd1	A trapezoid with only X varying with Z
CTGeoTrd1Editor	Editor for a TGeoTrd1
CTGeoTrd2	A trapezoid with only X varying with Z
CTGeoTrd2Editor	Editor for a TGeoTrd2
CTGeoTreeDialog
CTGeoTube	Cylindrical tube class
CTGeoTubeEditor	Editor for a TGeoTube
CTGeoTubeSeg	A tube segment is a tube having a range in phi
CTGeoTubeSegEditor	Editor for a TGeoTubeSeg
CTGeoUniformMagField	Implementation for uniform magnetic field
CTGeoUnion	Boolean node representing a union between two components
CTGeoVector3	Simple 3-vector representation
CTGeoVGConverter	Geometry converter to VecGeom
CTGeoVGShape	Bridge class for using a VecGeom solid as TGeoShape
CTGeoVolume	TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes
►CTGeoVolumeAssembly	Volume assemblies
CThreadData_t
CTGeoVolumeDialog
CTGeoVolumeEditor	Editor for geometry volumes and assemblies of volumes
CTGeoVolumeMulti	Volume families
CTGeoVoxelFinder	Finder class handling voxels
CTGeoVoxelGrid	A finite 3D grid structure, mapping/binning arbitrary 3D cartesian points onto discrete "voxels"
CTGeoVoxelGridIndex
►CTGeoXtru	A TGeoXtru shape is represented by the extrusion of an arbitrary polygon with fixed outline between several Z sections
CThreadData_t
CTGEventHandler
CTGFileBrowser	System file browser, used as TRootBrowser plug-in
CTGFileContainer
CTGFileDialog	This class creates a file selection dialog
CTGFileEntry	Utility class used by the file selection dialog (TGFSDialog)
CTGFileIcon	Utility class used by the file selection dialog (TGFSDialog)
CTGFileInfo
CTGFileItem
CTGFont	Encapsulate fonts used in the GUI system
►CTGFontDialog	Font selection dialog, allowing to select one in the list of available fonts in the system
CFontProp_t
CTGFontPool	Provides a pool of fonts
CTGFontTypeComboBox	The TGFontTypeComboBox is user callable and it creates a combobox for selecting the font
CTGFrame	A subclasses of TGWindow, and is used as base class for some simple widgets (buttons, labels, etc.)
CTGFrameElement
CTGFrameElementPack
►CTGFSComboBox	This is a combo box that is used in the File Selection dialog box
CLbc_t
CTGFSContainer	Utility class used by the file selection dialog (TGFSDialog)
CTGFSFrameElement
CTGGC	Encapsulate a graphics context used in the low level graphics
CTGGCPool
CTGGotoDialog
CTGGrabRect
CTGGroupFrame	A composite frame with a border and a title
CTGHButtonGroup	Organizes TGButton widgets in a group with one horizontal row
CTGHeaderFrame	Horizontal Frame used to contain header buttons and splitters in a list view
CTGHorizontal3DLine	A horizontal 3D line is a line that typically separates a toolbar from the menubar
CTGHorizontalFrame	A composite frame that layout their children in horizontal way
CTGHorizontalLayout
CTGHotString	TGHotString is a string with a "hot" character underlined
CTGHProgressBar
CTGHScrollBar	The TGHScrollBar will generate the following event messages: kC_HSCROLL, kSB_SLIDERPOS, position, 0 kC_HSCROLL, kSB_SLIDERTRACK, position, 0
CTGHSlider	Concrete class for horizontal slider
CTGHSplitter
CTGHtml	The ROOT HTML widget
CTGHtmlAnchor
CTGHtmlBlock
CTGHtmlBrowser	A very simple HTML browser
CTGHtmlCell
CTGHtmlElement
CTGHtmlForm
CTGHtmlHr
CTGHtmlImage
CTGHtmlImageMarkup
CTGHtmlInput
CTGHtmlLayoutContext
CTGHtmlLBEntry
CTGHtmlLi
CTGHtmlListStart
CTGHtmlMapArea
CTGHtmlMarkupElement
CTGHtmlRef
CTGHtmlScript
CTGHtmlSpaceElement
CTGHtmlTable
CTGHtmlTextElement
CTGHtmlUri
CTGIcon	This class handles GUI icons
CTGIconLBEntry	Icon + text listbox entry
CTGIdleHandler	Handle idle events, i.e
CTGImageMap	(with TGRegion and TGRegionWithId help classes)
CTGInputDialog	Input Dialog Widget
CTGInputHandler
CTGInsets
CTGItemContext	Empty object used as context menu support for TGLVTreeEntries
CTGL2DArray
CTGL5DDataSet
►CTGL5DDataSetEditor	GUI editor for OpenGL 5D Painter
CTGL5DEditorPrivate
►CTGL5DPainter	TGL5DPainter implements "gl5d" option for TTree::Draw
CSurf_t
CTGLabel	This class handles GUI labels
CTGLAdapter	Allow plot-painters to be used for gl-inpad and gl-viewer
CTGLAnnotation	GL-overlay annotation
CTGLAutoRotator	Automatically rotates GL camera
CTGLAxis	GL Axis
CTGLAxisPainter	Utility class to paint axis in GL
CTGLAxisPainterBox	Painter class for axes encompassing a 3D box
CTGLayoutHints	This class describes layout hints used by the layout classes
CTGLayoutManager	Frame layout manager
CTGLBContainer	A Composite frame that contains a list of TGLBEnties
CTGLBEntry	Basic listbox entries
CTGLBFrameElement
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
CTGLBoxPainter	Paints TH3 histograms by rendering variable-sized boxes matching the bin contents
CTGLCamera	Abstract base camera class - concrete classes for orthographic and perspective cameras derive from it
CTGLCameraGuide	Draws arrows showing camera orientation in the overlay
CTGLCameraOverlay	A GL overlay element which displays camera furstum
CTGLCapabilityEnabler
CTGLCapabilitySwitch
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
CTGLClipSet	A collection of concrete TGLClip objects to be selected from
CTGLClipSetEditor	GUI editor for TGLClipSet
CTGLClipSetSubEditor	GUI sub-editor for TGLClipSet
CTGLColor	Class encapsulating color information in preferred GL format - an array of four unsigned bytes
CTGLColorSet	Class encapsulating a set of colors used throughout standard rendering
CTGLContext	This class encapsulates window-system specific information about a GL-context and alows their proper management in ROOT
CTGLContextIdentity	Identifier of a shared GL-context
CTGLContextPrivate
CTGLCylinder	Implements a native ROOT-GL cylinder that can be rendered at different levels of detail
CTGLDisableGuard
CTGLEmbeddedViewer	Minimal GL-viewer that can be embedded in a standard ROOT frames
CTGLEnableGuard
CTGLEventHandler	Base-class and default implementation of event-handler for TGLViewer
CTGLFaceSet	Implements a native ROOT-GL representation of an arbitrary set of polygons
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
CTGLH2PolyPainter	Paint TH2Poly
►CTGLHistPainter	The histogram painter class using OpenGL
CPlotOption_t
CTGLineLBEntry	Line style and width listbox entries
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
CTGLIsoPainter	"gliso" option for TH3
CTGListBox	A listbox is a box, possibly with scrollbar, containing entries
CTGListDetailsLayout	This is a layout manager for the TGListView widget
CTGListLayout	This is a layout manager for the TGListView widget
CTGListTree	A list tree is a widget that can contain a number of items arranged in a tree structure
CTGListTreeItem
CTGListTreeItemStd
CTGListView	A list view is a widget that can contain a number of items arranged in a grid or list
CTGLLegoPainter	Plot-painter implementing LEGO rendering of TH2 histograms in cartesian, polar, cylindrical and spherical coordinates
CTGLLevelPalette
CTGLLightSet	Encapsulates a set of lights for OpenGL
CTGLLightSetEditor
CTGLLightSetSubEditor	Sub-editor for TGLLightSet
CTGLLine3	3D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex'
►CTGLLockable	Simple locking interface used by viewer and scene
CTUnlocker
CTGLLogicalShape	Abstract logical shape - a GL 'drawable' - base for all shapes - faceset sphere etc
CTGLManager
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
CTGLManipSet	Combine all available manipulators in a collection
CTGLMatrix	16 component (4x4) transform matrix - column MAJOR as per GL
CTGLMesh
CTGlobal	Global variables class (global variables are obtained from CINT)
CTGlobalMappedFunction
CTGLObject	Base-class for direct OpenGL renderers
CTGLongPosition
CTGLOrthoCamera	Orthographic projection camera
CTGLOutput	Wrapper class for GL capture & output routines
CTGLOverlayButton	GL-overlay button
CTGLOverlayElement	An overlay element
CTGLOverlayList	Manage a collection of overlay elements
CTGLOvlSelectRecord	Selection record for overlay objects
CTGLPadPainter	"Delegating" part of TGLPadPainter
CTGLPaintDevice
CTGLParametricEquation	A parametric surface is a surface defined by a parametric equation, involving two parameters (u, v):
CTGLParametricEquationGL	GL-renderer wrapper for TGLParametricEquation
►CTGLParametricPlot
CVertex_t
CTGLPerspectiveCamera	Perspective projection camera - with characteristic foreshortening
CTGLPhysicalShape	Concrete physical shape - a GL drawable
CTGLPlane	3D plane class - of format Ax + By + Cz + D = 0
CTGLPlot3D	Description of TGLPlot3D
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
CTGLPlotPainter	Base class for plot-painters that provide GL rendering of various 2D and 3D histograms, functions and parametric surfaces
CTGLPolyLine	To draw a 3D polyline in a GL window
CTGLPolyMarker	To draw a 3D polymarker in a GL window
CTGLPShapeObj	Wrap TGLPysicalShape into TObject so that it can be edited using GED
CTGLPShapeObjEditor	GUI editor for TGLPShapeObj
CTGLPShapeRef	Base class for references to TGLPysicalShape that need to be notified when the shape is destroyed
CTGLQuadric	Wrapper class for GLU quadric shape drawing object
CTGLRect	Viewport (pixel base) 2D rectangle class
CTGLRedrawTimer
CTGLRnrCtx	Aggregates data for a given redering context as needed by various parts of the ROOT's OpenGL infrastructure
CTGLRotateManip	Rotate manipulator - attaches to physical shape and draws local axes widgets - rings drawn from attached physical center, in plane defined by axis
CTGLSAFrame	Standalone GL Viewer GUI main frame
CTGLSAViewer	The top level standalone GL-viewer - created via plugin manager
CTGLScaleManip	Scale manipulator - attaches to physical shape and draws local axes widgets with box heads
►CTGLScene	TGLScene provides management and rendering of ROOT's default 3D /object representation as logical and physical shapes
CDrawElement_t
CTSceneInfo
CTGLSceneBase	Scene base-class – provides basic interface expected by the TGLViewer or its sub-classes:
CTGLSceneInfo	Base class for extended scene context
CTGLScenePad	Implements VirtualViewer3D interface and fills the base-class visualization structures from pad contents
CTGLSdfFontMaker	Helper class for generation of Signed Distance Field (SDF) fonts for REve
CTGLSelectBuffer	Encapsulates OpenGL select buffer
CTGLSelectionBuffer
CTGLSelectRecord	Standard selection record including information about containing scene and details ob out selected object (TGLPhysicalShape*, TObject* or simply a void* for foreign scenes)
CTGLSelectRecordBase	Base class for select records
CTGLSphere	Implements a native ROOT-GL sphere that can be rendered at different levels of detail
CTGLStopwatch	Stopwatch object for timing GL work
►CTGLSurfacePainter	Implements painting of TH2 with "SURF" option
CProjection_t
CTGLText	GL Text
CTGLTF3Painter	Plot-painter for TF3 functions
CTGLTH3Composition
CTGLTH3CompositionPainter
CTGLTH3Slice	A slice of a TH3
CTGLTransManip	Translation manipulator - attaches to physical shape and draws local axes widgets with arrow heads
►CTGLUtil	Wrapper class for various misc static functions - error checking, draw helpers etc
CTColorLocker
CTDrawQualityModifier
CTDrawQualityScaler
CTGLVContainer
CTGLVector3	3 component (x/y/z) vector class
CTGLVEntry
CTGLVertex3	3 component (x/y/z) vertex class
CTGLViewer	Base GL viewer object - used by both standalone and embedded (in pad) GL
CTGLViewerBase	Base class for GL viewers
CTGLViewerEditor	GUI editor for TGLViewer
CTGLVoxelPainter	Paint TH3 histograms as "voxels" - colored boxes, transparent if transfer function was specified
CTGLWidget	GL window with context
►CTGMainFrame	Defines top level windows that interact with the system Window Manager
CTGMapKey
CTGMatrixLayout	This layout managers does not make use of TGLayoutHints
CTGMdiButtons
CTGMdiContainer
CTGMdiCornerWinResizer
CTGMdiDecorFrame	This file contains all different MDI frame decoration classes
CTGMdiFrame	This file contains the TGMdiFrame class
CTGMdiFrameList
CTGMdiGeometry
CTGMdiHorizontalWinResizer
CTGMdiMainFrame	This file contains the TGMdiMainFrame class
CTGMdiMenu	This file contains the TGMdiMenuBar class
CTGMdiMenuBar
CTGMdiTitleBar
CTGMdiTitleIcon
CTGMdiVerticalWinResizer
CTGMdiWinResizer
CTGMenuBar	The TGMenu.h header contains all different menu classes
CTGMenuEntry	This class contains all information about a menu entry
CTGMenuTitle	This class creates a menu title
CTGMime	TGMime is internally used by TGMimeTypes
CTGMimeTypes	This class handles mime types, used by browsers to map file types to applications and icons
CTGMsgBox
CTGNumberEntry	TGNumberEntry is a number entry input widget with up/down buttons
CTGNumberEntryField
CTGNumberEntryLayout
CTGNumberFormat
CTGObject	This class is the baseclass for all ROOT GUI widgets
CTGondzioSolver	Derived class of TQpSolverBase implementing Gondzio-correction version of Mehrotra's original predictor-corrector algorithm
CTGOSXGLManager
CTGPack	Stack of frames in horizontal (default) or vertical stack
CTGPasswdDialog	Graphic dialog to enter passwords
CTGPicture	Implements pictures and icons used in the different GUI elements and widgets
CTGPictureButton	Yield an action as soon as it is clicked
CTGPicturePool
CTGPopupMenu	This class creates a popup menu object
CTGPosition
CTGPrintDialog
CTGProgressBar	The classes in this file implement progress bars
CTGQuartz	This is non-GUI part of TVirtualX interface, implemented for MacOS X, using CoreGraphics (Quartz)
CTGRadioButton	Selects different options
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
CTGraph2DAsymmErrors	Graph 2D class with errors
CTGraph2DErrors	Graph 2D class with errors
CTGraph2DPainter	The TGraphDelaunay painting class
CTGraphAsymmErrors	TGraph with asymmetric error bars
CTGraphBentErrors	A TGraphBentErrors is a TGraph with bent, asymmetric error bars
CTGraphDelaunay	TGraphDelaunay generates a Delaunay triangulation of a TGraph2D
CTGraphDelaunay2D	TGraphDelaunay2D generates a Delaunay triangulation of a TGraph2D
CTGraphEdge	An edge object connecting two nodes which can be added in a TGraphStruct
CTGraphEditor	Implements GUI for graph attributes
CTGraphErrors	A TGraphErrors is a TGraph with error bars
CTGraphMultiErrors	TGraph with asymmetric error bars and multiple y error dimensions
CTGraphNode	A graph node object which can be added in a TGraphStruct
CTGraphPainter	The graph painter class
CTGraphPolar	To draw a polar graph
CTGraphPolargram	To draw polar axis
CTGraphQQ	This class allows to draw quantile-quantile plots
CTGraphSmooth	A helper class to smooth TGraph
CTGraphStruct	The Graph Structure is an interface to the graphviz package
CTGraphTime	TGraphTime is used to draw a set of objects evolving with nsteps in time between tmin and tmax
CTGRecorder	Provides GUI for TRecorder class
CTGRectangle
CTGRectMap
CTGRedirectOutputGuard	This class provides output redirection to a TGTextView in guaranteed exception safe way
CTGRegion
CTGRegionData
CTGRegionWithId
CTGRepeatFireButton
CTGResourcePool	This class implements a pool for the default GUI resource set, like GC's, colors, fonts, etc
CTGrid
CTGridCollection
CTGridJDL
CTGridJob
CTGridJobStatus
CTGridJobStatusList
CTGridResult
CTGroupButton	A specialized TButton used in a group of Buttons
CTGRowLayout	The following two layout managers do not make use of TGLayoutHints
CTGScrollBar	The classes in this file implement scrollbars
CTGScrollBarElement
CTGScrollBarElements	The "head", "tail" and "slider"
CTGSearchDialog
CTGSearchType
CTGSelectBox	This class represent a specialized expression editor for TTVLVEntry 'true name' and 'alias' data members
CTGSelectedPicture
CTGShapedFrame	A Shaped window
CTGShutter	A shutter widget contains a set of shutter items that can be open and closed like a shutter
CTGShutterItem
CTGSimpleTable	To provide a simple class to visualize an array of doubles, the class TGSimpleTable is provided
CTGSimpleTableInterface	TGSimpleTableInterface is a very simple implementation of a TVirtualTableInterface
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
CTGSplitButton	Implements a button with added menu functionality
CTGSplitFrame	A split frame
CTGSplitter	A splitter allows the frames left and right or above and below of it to be resized
CTGSplitTool	A split frame tool tip
CTGStatusBar	Provides a StatusBar widget
CTGStatusBarPart
CTGString	TGString wraps a TString and adds some graphics routines like drawing, size of string on screen depending on font, etc
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)
CTGTabElement	Service classes of the tab widget
CTGTabLayout	Service classes of the tab widget
CTGTable	Create an array to hold a bunch of numbers
CTGTableCell	TGTableCell is the class that represents a single cell in a TGTable
CTGTableFrame	TGTableFrame contains a composite frame that uses a TGMatrixLayout to Layout the frames it contains
CTGTableHeader	TGTableHeader is the class that implements a header for a row or column
CTGTableHeaderFrame	TGTableHeaderFrame implements a frame used to display TGTableHeaders in a TGTable
►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
CTableData_t
CTGTableLayoutHints	This class describes layout hints used by the TGTableLayout class
CTGText	A TGText is a multi line text buffer
CTGTextBuffer	A text buffer is used in several widgets, like TGTextEntry, TGFileDialog, etc
CTGTextButton	Yield an action as soon as it is clicked
CTGTextEdit	A TGTextEdit is a specialization of TGTextView
CTGTextEditCommand
CTGTextEditDialogs	This file defines several dialogs that are used by the TGTextEdit widget via its associated context popup menu
CTGTextEditHist
CTGTextEditor	A simple text editor that uses the TGTextEdit widget
CTGTextEntry	A TGTextEntry is a one line text input widget
CTGTextLayout	Is used to keep track of string measurement information when using the text layout facilities
CTGTextLBEntry	Text string listbox entries
CTGTextLine
CTGTextView	A TGTextView is a text viewer widget
CTGTextViewostream
CTGTextViewStream	A TGTextViewStream is a text viewer widget
CTGTextViewStreamBuf
CTGTileLayout	This is a layout manager for the TGListView widget
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
CTGTRA	A general twisted trapezoid
CTGTransientFrame	Defines transient windows that typically are used for dialogs windows
CTGTreeLBEntry
CTGTreeTable	TGTreeTable is a TGTable that owns it's own interface
CTGTripleHSlider	TripleSlider inherit from DoubleSlider widgets and allow easy selection of a min, max and pointer value out of a range
CTGTripleVSlider	TripleSlider inherit from DoubleSlider widgets and allow easy selection of a min, max and pointer value out of a range
CTGuiBldAction
CTGuiBldBorderFrame
CTGuiBldDragManager	Drag and drop manager used by the ROOT GUI Builder
CTGuiBldDragManagerGrid
CTGuiBldDragManagerPimpl
CTGuiBldDragManagerRepeatTimer
CTGuiBldEditor	The property editor
CTGuiBldGeometryFrame
CTGuiBldHintsButton	Special button class used for editing layout hints in the ROOT GUI Builder
CTGuiBldHintsEditor	Editor of widget's layout hints used by the ROOT GUI builder
CTGuiBldHintsManager
CTGuiBldMenuDialog
CTGuiBldMenuTitle
CTGuiBldNameFrame
CTGuiBldPopupMenu
CTGuiBldSaveFrame
CTGuiBldToolButton
CTGuiBuilder
CTGuiFactory	This ABC is a factory for GUI components
CTGuiNameFrame
CTGUndockedFrame
CTGUnknownWindowHandler	Handle events for windows that are not part of the native ROOT GUI
CTGVButtonGroup	Organizes TGButton widgets in a group with one vertical column
CTGVertical3DLine	A vertical 3D line is a line that can be used to separate groups of widgets
CTGVerticalFrame	A composite frame that layout their children in vertical way
CTGVerticalLayout
CTGVFileSplitter
CTGView	A TGView provides the infrastructure for text viewer and editor widgets
CTGViewFrame
CTGViewPort
CTGVProgressBar
CTGVScrollBar	The TGVScrollBar will generate the following event messages: kC_VSCROLL, kSB_SLIDERPOS, position, 0 kC_VSCROLL, kSB_SLIDERTRACK, position, 0
CTGVSlider	Concrete class for vertical slider
CTGVSplitter
CTGWidget	The widget base class
CTGWin32	This class is the basic interface to the Win32 graphics system
CTGWin32CallBackObject
CTGWin32GL	The TGWin32GL is win32gdk implementation of TVirtualGLImp class
►CTGWin32GLManager
CTGLContext
CTGWin32GLImpl
CTGWin32GLManagerProxy
CTGWin32ProxyBase	Proxy classes provide thread-safe interface to global objects
CTGWin32ProxyBasePrivate
CTGWin32VirtualXProxy
CTGWindow	ROOT GUI Window base class
CTGX11	This class is the basic interface to the X11 (Xlib) graphics system
CTGX11TTF	Interface to low level X11 (Xlib)
CTGXYLayout	Is a layout manager where the position and the size of each widget in the frame are defined by X / Y - coordinates
CTGXYLayoutHints	This layout hint must be used for the TGXYLayout manager!
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)
CTH1Editor	Editor for changing TH1 histogram attributes, rebinning & fitting
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)
CTH1Merger
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)
CTH2Editor	Editor for changing TH2 histogram attributes, rebinning & fitting
CTH2F	2-D histogram with a float per channel (see TH1 documentation)
CTH2GL	Rendering of TH2 and derived classes
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
CTH2PolyBin	Helper class to represent a bin in the TH2Poly histogram
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
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)
CTH3GL	OpenGL renderer class for TH3
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)
CTHaarMatrixT
CTHashList	THashList implements a hybrid collection class consisting of a hash table and a list to store TObject's
CTHashTable	THashTable implements a hash table to store TObject's
CTHashTableIter	Iterator of hash table
CTHbookBranch	HBOOK Branch
CTHbookFile	This class is an interface to the Hbook objects in Hbook files
CTHbookKey	HBOOK Key
CTHbookTree	A wrapper class supporting Hbook ntuples (CWN and RWN)
CTHelix	THelix has two different constructors
CTHilbertMatrixT
CTHilbertMatrixTSym
CTHistPainter	The histogram painter class
CTHistRange
CTHistRenderingRegion
CTHLimitsFinder	Class to compute nice axis limits
CTHn	Multidimensional histogram
CTHnBase	Multidimensional histogram base
CTHnChain	A class to chain together multiple histograms
CTHnIter	Iterator over THnBase bins
CTHnSparse	Efficient multidimensional histogram
CTHnSparseArrayChunk	THnSparseArrayChunk is used internally by THnSparse
CTHnSparseCompactBinCoord	THnSparseCompactBinCoord is a class used by THnSparse internally
CTHnSparseCoordCompression	THnSparseCoordCompression is a class used by THnSparse internally
CTHnSparseT	Templated implementation of the abstract base THnSparse
CTHnT	Templated implementation of the abstract base THn
CTHostAuth
CTHStack	The Histogram stack class
CTHttpCallArg	Contains arguments for single HTTP call
CTHttpEngine	Abstract class for implementing http protocol for THttpServer
CTHttpLongPollEngine	Emulation of websocket with long poll requests
CTHttpServer	Online http server for arbitrary ROOT application
CTHttpTimer
CTHttpWSEngine	Internal instance used to exchange WS functionality between THttpServer and THttpWSHandler
CTHttpWSHandler	Class for user-side handling of websocket with THttpServer
CTHYPE	An hyperboloid (not implemented)
CTIconBoxThumb
CTIdleTimer
CTIdleTOTimer
CTIdleTOTimerGuard
CTImage	An abstract interface to image processing library
CTImageDump	Save canvas as an image (GIF, JPEG, PNG, XPM, TIFF etc.)
CTImagePalette	A class to define a conversion from pixel values to pixel color
CTImagePlugin
CTIndArray
CTInetAddress	This class represents an Internet Protocol (IP) address
CTInsCharCom
CTInspectCanvas	A TInspectCanvas is a canvas specialized to inspect Root objects
CTInspectorImp	ABC describing GUI independent object inspector (abstraction mainly needed for Win32
CTInspectorObject	This class is designed to wrap a Foreign object in order to inject it into the Browse sub-system
CTInsTextCom
CTInstrumentedIsAProxy
►CTInterpreter	This class defines an abstract interface to a generic command line interpreter
CCallFuncIFacePtr_t
CSuspendAutoLoadingRAII
CSuspendAutoParsing
CTInterpreterValue
CTInterruptHandler
CTIsAProxy	TIsAProxy implementation class
CTIter
CTIterator	Iterator abstract base class
CTIteratorToSTLInterface	TIterator and GenericRooFIter front end with STL back end
CTIterCategory
CTJoinHelper
►CTJSONStackObj
CStlRead
►CTJSONTree
►CNode
CChildItImpl
►CImpl
CBaseNode
CNodeRef
►CTKDE	Kernel Density Estimation class
CKernelIntegrand
CTKernel
CTKDEFGT
CTKDTree	Class implementing a kd-tree
►CTKDTreeBinning	<- TKDTreeBinning - A class providing multidimensional binning ->
CCompareAsc
CCompareDesc
CTKey	Book space in a file, create I/O buffers, to fill them, (un)compress them
CTKeyElement	Element representing TKey from TDirectory
CTKeyMapFile	Utility class for browsing TMapFile objects
CTKeySQL	TKeySQL represents meta-information about object, which was written to SQL database
CTKeyXML
►CTLatex	To draw Mathematical Formula
CTextSpec_t	TLatex helper struct holding the attributes of a piece of text
CTLatexFormSize	TLatex helper class used to compute the size of a portion of a formula
►CTLeaf	A TLeaf describes individual elements of a TBranch See TBranch structure in TTree
CGetValueHelper
CGetValueHelper< Long64_t >
CGetValueHelper< LongDouble_t >
CGetValueHelper< ULong64_t >
CLeafCountValues
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
CTLeafDraw6Provider	Provider for drawing of ROOT6 classes
CTLeafDraw7Provider	Provider for drawing TLeaf/TBranch in ROOT7 canvas
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
CTLeafProvider	Provider for drawing of branches / leafs in the TTree
CTLeafS	A TLeaf for a 16 bit Integer data type
CTLegend	This class displays a legend box (TPaveText) containing several legend entries
CTLegendEntry	Storage class for one entry of a TLegend
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
CTLimitDataSource	This class serves as input for the TLimit::ComputeLimit method
CTLine	Use the TLine constructor to create a simple line
CTLinearFitter
CTLinearGradient
CTLinearMinimizer	TLinearMinimizer class: minimizer implementation based on TMinuit
CTLineEditor	Implements GUI for editing line attributes: shape, size, angle
CTLink	Special TText object used to show hyperlinks
CTList	A doubly linked list
CTListIter	Iterator of linked list
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
CTListOfEnumsWithLockIter	Iterator for TListOfEnumsWithLock
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
CTListOfFunctionsIter	Iterator for TListOfFunctions
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
CTListOfTypes	A collection of TDataType designed to hold the typedef information and numerical type information
CTLockFile	A scoped lock based on files
CTLockGuard
CTLockPath	Path locking class allowing shared and exclusive locks
CTLockPathGuard
►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)
CTLorentzRotationRow
CTLorentzVector
CTMacOSXSystem
CTMacro	Class supporting a collection of lines with C++ code
CTMakeProject
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)
CTMapFile	This class implements a shared memory region mapped to a file
CTMapIter	Iterator of map
CTMapRec	Keep track of an object in the mapped file
CTMarker	Manages Markers
CTMarker3DBox	A special 3-D marker designed for event display
CTMaterial	Manages a detector material
CTMathText	To draw TeX Mathematical Formula
CTMathTextRenderer
CTMatrixDEigen	TMatrixDEigen
CTMatrixDSymEigen	TMatrixDSymEigen
CTMatrixT	TMatrixT
CTMatrixTBase	TMatrixTBase
CTMatrixTColumn
CTMatrixTColumn_const
CTMatrixTCramerInv	TMatrixTCramerInv
CTMatrixTDiag
CTMatrixTDiag_const
CTMatrixTFlat
CTMatrixTFlat_const
CTMatrixTLazy	Templates of Lazy Matrix classes
CTMatrixTRow
CTMatrixTRow_const
CTMatrixTSparse	TMatrixTSparse
CTMatrixTSparseDiag
CTMatrixTSparseDiag_const
CTMatrixTSparseRow
CTMatrixTSparseRow_const
CTMatrixTSub
CTMatrixTSub_const
CTMatrixTSym	TMatrixTSym
CTMatrixTSymCramerInv	TMatrixTSymCramerInv
CTMatrixTSymLazy
CTMatrixTUtils	Matrix utility classes
CTMD5	This code implements the MD5 message-digest algorithm
CTMehrotraSolver	Derived class of TQpSolverBase implementing the original Mehrotra predictor-corrector algorithm
►CTMemberInspector	Abstract base class for accessing the data-members of a class
CTParentBuf
CTMemberStreamer
►CTMemFile	A TMemFile is like a normal TFile except that it reads and writes only from memory
CTMemBlock
CZeroCopyView_t	A read-only memory range which we do not control
CTMergerInfo
CTMessage
CTMessageHandler	Handle messages that might be generated by the system
CTMethod	Each ROOT class (see TClass) has a linked list of methods
CTMethodArg	Each ROOT method (see TMethod) has a linked list of its arguments
CTMethodBrowsable	This helper object allows the browsing of methods of objects stored in branches
CTMethodCall	Method or function calling interface
CTMinuit
CTMinuit2TraceObject
CTMinuitMinimizer	TMinuitMinimizer class: ROOT::Math::Minimizer implementation based on TMinuit
CTMixture	Manages a detector mixture
CTMLPAnalyzer	This utility class contains a set of tests useful when developing a neural network
CTMonitor
CTMPClient	Base class for multiprocess applications' clients
CTMPWorker	This class works in conjuction with TMPClient, reacting to messages received from it as specified by the Notify and HandleInput methods
CTMPWorkerExecutor	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	Templated derivation of TMPWorkerTree handlign generic function tree processing
CTMPWorkerTreeSel	Templated derivation of TMPWorkerTree handlign selector tree processing
CTMrbSubevent_Caen
CTMsgBox	A message dialog box
CTMultiDimFit	Multidimensional Fits in ROOT
CTMultiGraph	A TMultiGraph is a collection of TGraph (or derived) objects
CTMultiLayerPerceptron	This class describes a neural network
CTMutex
CTMutexImp
CTMVA	Base Class for all classes that need option parsing
CTMyBrowserImp
CTMySQLResult
CTMySQLRow
CTMySQLServer
►CTMySQLStatement
CTParamData
CTNamed	Base class for all named ROOT classes
CTNamedFont
CTNDArray	N-Dim array class
CTNDArrayRef	Gives access to a sub-dimension, e.g
CTNDArrayT
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/)
CTNetFileStager
CTNetSystem
CTNetXNGFile	Enables access to XRootD files using the new client
CTNetXNGFileStager	Enables access to XRootD staging capabilities using the new client
CTNetXNGSystem	Enables access to XRootD filesystem interface using the new client
CTNeuron	This class describes an elementary neuron, which is the basic element for a Neural Network
CTNewCanvasPainterReg
CTNewChainDlg
CTNewQueryDlg
CTNode	TNode description
CTNodeDiv	Description of parameters to divide a 3-D geometry object
CTNonCopyable
CTNonSplitBrowsable	Allows a TBrowser to browse non-split branches as if they were split
CTNotifyLink	A node in a doubly linked list of subscribers to TChain notifications
CTNotifyLinkBase	See TNotifyLink
CTNtuple	A simple TTree restricted to a list of float variables only
CTNtupleD	A simple TTree restricted to a list of double variables only
CTObjArray	An array of TObjects
CTObjArrayIter	Iterator of object array
CTObject	Mother of all ROOT objects
CTObjectDraw6Provider	Provider for drawing of ROOT6 classes
CTObjectDraw7Provider	Provider for drawing of ROOT7 classes
CTObjectLevelIter	Iterator over list of elements, designed for support TBrowser usage
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
CTObjLink	Wrapper around a TObject so it can be stored in a TList
CTObjOptLink
CTObjString	Collectable string class
CTODBCResult
CTODBCRow
CTODBCServer
►CTODBCStatement
CODBCBufferRec_t
CToolBarData_t
CTOptionListItem
CTOrdCollection	Ordered collection
CTOrdCollectionIter	Iterator of ordered collection
CTOutputListSelectorDataMap	Set the selector's data members to the corresponding elements of the output list
CTPackageDescription
►CTPacketizer	This class generates packets to be processed on PROOF worker servers
CTFileNode
CTFileStat
CTSlaveStat
►CTPacketizerAdaptive	This packetizer is based on TPacketizer but uses different load-balancing algorithms and data structures
CTFileNode
CTFileStat
CTSlaveStat
►CTPacketizerFile	This packetizer generates packets which contain a single file path to be used in process
CTIterObj
CTSlaveStat
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
CTSlaveStat
CTPackMgr	The PROOF package manager contains tools to manage packages
CTPad	The most important graphics class in the ROOT system
CTPadEditor	Editor of pad/canvas objects
CTPadPainter	Implement TVirtualPadPainter which abstracts painting operations
CTPadWebSnapshot
CTPainter3dAlgorithms	The Legos and Surfaces painter class
CTPair	Class used by TMap to store (key,value) pairs
CTPaletteAxis	The palette painting class
CTPaletteEditor	Edit the palette via a GUI
CTPARA	A parallelepiped
CTParallelCoord	Parallel Coordinates class
CTParallelCoordEditor	This is the TParallelCoord editor
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
CTParallelMergingFile
CTParameter	Named parameter, streamable and storable
CTParticle	Description of the dynamic properties of a particle
CTParticleClassPDG	Utility class used internally by TDatabasePDG
CTParticlePDG	Description of the static properties of a particle
CTParticleProxyBuilder
CTPave	A TBox with a bordersize and a shadow option
CTPaveClass	A TPaveLabel specialized to process classes inside a TClassTree
CTPaveLabel	A Pave (see TPave) with a text centered in the Pave
CTPaveStats	The histogram statistics painter class
CTPaveStatsEditor	Implements GUI for editing attributes of TPaveStats objects
CTPavesText	A PaveText (see TPaveText) with several stacked paves
CTPaveText	A Pave (see TPave) with text, lines or/and boxes inside
CTPBHandleDSType
CTPBHistType
CTPBReadType
CTPCON	A polycone
CTPDF	Interface to PDF
CTPerfEvent
CTPerfStats	Provides the interface for the PROOF internal performance measurement and event tracing
CTPGON	A polygon
CTPgSQLResult
CTPgSQLRow
CTPgSQLServer
CTPgSQLStatement
CTPickerStackGuard
CTPie	Draw a Pie Chart,
CTPieEditor	Implements GUI for pie-chart attributes
CTPieSlice	A slice of a piechart, see the TPie class
CTPieSliceEditor	Editor for changing pie-chart's slice attributes
CTPluginHandler
CTPluginManager	This class implements a plugin library manager
CTPMERegexp	Wrapper for PCRE library (Perl Compatible Regular Expressions)
CTPoint
CTPoints	2-D graphics point (world coordinates)
CTPoints3DABC	Abstract class to define Arrays of 3D points
CTPointSet3D	TPolyMarker3D using TPointSet3DGL for direct OpenGL rendering
CTPointSet3DGL	Direct OpenGL renderer for TPointSet3D
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
CTPopupDelayTimer
CTPosixCondition
CTPosixMutex
CTPosixThread
CTPosixThreadCleanUp
CTPosixThreadFactory
CTPostScript	Interface to PostScript
CTPRegexp
CTPrimary	Old version of a dynamic particle class created by event generators
CTPrincipal	Principal Components Analysis (PCA)
CTProcessEventTimer
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
CTProctimeTimer
CTProfile	Profile Histogram
CTProfile2D	Profile2D histograms are used to display the mean value of Z and its error for each cell in X,Y
CTProfile2Poly	2D Profile Histogram with Polygonal Bins
CTProfile2PolyBin	Helper class to represent a bin in the TProfile2Poly histogram
CTProfile3D	Profile3D histograms are used to display the mean value of T and its RMS for each cell in X,Y,Z
CTProfileHelper
►CTProof	This class controls a Parallel ROOT Facility, PROOF, cluster
CMD5Mod_t
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
CTProofChain
CTProofCondor
CTProofDebug
CTProofDesc
CTProofDraw	Implement Tree drawing using PROOF
CTProofDrawEntryList
CTProofDrawEventList
CTProofDrawGraph
CTProofDrawHist
►CTProofDrawListOfGraphs
CPoint3D_t
►CTProofDrawListOfPolyMarkers3D
CPoint4D_t
CTProofDrawPolyMarker3D
CTProofDrawProfile
CTProofDrawProfile2D
CTProofInputHandler
CTProofInterruptHandler
CTProofLimitsFinder	Class to find axis limits and synchronize them between workers
CTProofLite	This class starts a PROOF session on the local machine: no daemons, client and master merged, communications via UNIX-like sockets
CTProofLockPath
CTProofLockPathGuard
CTProofLog	Implementation of the PROOF session log handler
CTProofLogElem
CTProofMergePrg
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
CTDSetPlet
CTProofMonSenderSQL	TProofMonSender implementation for the SQL writers
CTProofNodeInfo	The purpose of this class is to provide a complete node description for masters, submasters and workers
CTProofNodes	PROOF worker node information
CTProofOutputFile	Class to steer the merging of files produced on the workers
CTProofOutputList	Derivation of TList with an overload of ls() and Print() allowing to filter out some of the variables
►CTProofPerfAnalysis	Set of tools to analyse the performance tree
CTFileInfo
CTPackInfo
CTWrkEntry
CTWrkInfo
CTWrkInfoFile
►CTProofPlayer	Internal class steering processing in PROOF
CTCleanup
CTProofPlayerLite	Version of TProofPlayerRemote merges the functionality needed by clients and masters
CTProofPlayerLocal
CTProofPlayerRemote
CTProofPlayerSlave
CTProofPlayerSuperMaster
CTProofProgressDialog	This class provides a query progress bar
CTProofProgressInfo
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
CTProofProgressStatus	Container class for processing statistics
CTProofQueryResult	TQueryResult version adapted to PROOF neeeds
CTProofResources
CTProofResourcesStatic	The purpose of this class is to provide a standard interface to static config files
CTProofServ	Class providing the PROOF server
CTProofServInputHandler
CTProofServInterruptHandler
CTProofServLite	Version of the PROOF worker server for local running
CTProofServLiteInputHandler
CTProofServLiteInterruptHandler
CTProofServLiteSegViolationHandler
CTProofServLiteSigPipeHandler
CTProofServLiteTerminationHandler
CTProofServLogHandler
CTProofServLogHandlerGuard
CTProofServSigPipeHandler
CTProofServTerminationHandler
CTProofSuperMaster	Implementation of TProof controlling PROOF federated clusters
CTProofVectorContainer
►CTProtoClass	Persistent version of a TClass
CTProtoRealData
CTPServerSocket
CTPSocket
CTPwdCtx
CTPyArg	Morphing argument type from evaluating python expressions
CTPyClassGenerator
CTPyDispatcher	Dispatcher for C++ callbacks into Python code
CTPyReturn	Morphing return type from evaluating python expressions
CTPythia8	TPythia8 is an interface class to C++ version of Pythia 8.1 event generators, written by T.Sjostrand
CTPythia8Decayer	This class implements the TVirtualMCDecayer interface using TPythia8
CTPython	Accessing the Python interpreter from C++
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
CTQConnectionList	TQConnectionList is the named list of connections, see also TQConnection class
CTQObject	This is the ROOT implementation of the Qt object communication mechanism (see also http://www.troll.no/qt/metaobjects.html)
CTQObjSender
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
CTQpVar	Class containing the variables for the general QP formulation
CTQSlot	Slightly modified TMethodCall class used in the object communication mechanism
CTQSlotPool
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
CTQueryResult	A container class for query results
CTQueryResultManager	Class managing the query-result area
CTQUndoManager	Recorder of operations for undo and redo
CTrack
CTRadialGradient
CTrainNodeInfo
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
CTRandomEngine
CTRandomGen
CTRatioPlot	Class for displaying ratios, differences and fit residuals
CTReadEnvParser
CTRealData	Manages the effective list of all data members for a given class
CTReaperTimer
CTRecCmdEvent	Class used for storing information about 1 commandline event
CTRecEvent	Abstract class that defines interface for a class storing information about 1 ROOT event
CTRecExtraEvent	Class TRecExtraEvent
CTRecGuiEvent	Class TRecGuiEvent
CTRecorder	Class provides direct recorder/replayer interface for a user
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
CTRecorderState	Abstract class that defines interface for a state of recorder
CTRecWinPair	Class used for storing of window IDs mapping
CTRedirectOutputGuard
CTReentrantRWLock	An implementation of a reentrant read-write lock with a configurable internal mutex/lock (default Spin Lock)
CTreeUtils	Different standalone functions to work with trees and tuples, not reqiuired to be a member of any class
CTRef	Persistent Reference link to a TObject A TRef is a lightweight object pointing to any TObject
CTRefArray	An array of references to TObjects
CTRefArrayIter	Iterator of object array
CTRefArrayProxy	A container proxy, which allows to access references stored in a TRefArray from TTree::Draw
CTRefCnt	Definitions for TRefCnt, base class for reference counted objects
CTRefProxy
CTRefTable	A TRefTable maintains the association between a referenced object and the parent object supporting this referenced object
CTRegexp	Regular expression class
CTRemoteObject	Protocol for browsing ROOT objects from a remote ROOT session
CTRepeatTimer
CTRF1
CTRint
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
CTROOT	ROOT top level object description
CTRootApplication	This class create the ROOT native GUI version of the ROOT application environment
CTRootAuth
CTRootBrowser	This class creates a ROOT object browser, constituted by three main tabs
CTRootBrowserCursorSwitcher
CTRootBrowserHistory
CTRootBrowserHistoryCursor
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
CTRootClingCallbacks
CTRootContainer
CTRootContextMenu	This class provides an interface to context sensitive popup menus
CTRootControlBar	This class provides an interface to the GUI dependent functions of the TControlBar class
CTRootDialog	A TRootDialog is used to prompt for the arguments of an object's member function
CTRootEmbeddedCanvas	This class creates a TGCanvas in which a TCanvas is created
CTRootEmbeddedContainer	Utility class used by TRootEmbeddedCanvas
CTRootGuiBuilder
CTRootGuiFactory	This class is a factory for ROOT GUI components
CTRootHelpDialog	A TRootHelpDialog is used to display help text (or any text in a dialog window)
CTRootIconBox
CTRootIconList
CTRootIOCtor
CTRootObjItem
CTRootSecContext
CTRootSniffer	Sniffer of ROOT objects, data provider for THttpServer
CTRootSnifferFull	Extends TRootSniffer for many ROOT classes
CTRootSnifferScanRec	Structure used to scan hierarchies of ROOT objects
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.
CTRotationRow
CTRotMatrix	Manages a detector rotation matrix
CTRSA_fun
CTRWLock
CTRWSpinLock	An implementation of a read-write lock with an internal spin lock
►CTRYMLTree
CImpl
►CNode
CImpl
CTS3HTTPRequest
CTS3WebFile	A TS3WebFile is a TWebFile which retrieves the file contents from a web server implementing the REST API of the Amazon S3 protocol
CTSAXParser	TSAXParser is a subclass of TXMLParser, it is a wraper class to libxml library
CTSAXParserCallback
CTSBRepeatTimer
CTScatter	A TScatter is able to draw four variables scatter plot on a single plot
CTSecContext
CTSecContextCleanup
CTSelector	A TSelector object is used by the TTree::Draw, TTree::Scan, TTree::Process to navigate in a TTree and make selections
CTSelectorDraw	A specialized TSelector for TTree::Draw
CTSelectorEntries	The class is derived from the ROOT class TSelector
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)
CTSelectorScalar	Named scalar type, based on Long64_t, streamable, storable and mergeable
CTSelEvent	Selector for PROOF I/O benchmark test
CTSelEventGen	Selector for event file generation
CTSelHandleDataSet	PROOF selector for file cache release
CTSelHist	PROOF selector for CPU-intensive benchmark test
CTSelVerifyDataSet	Selector to verify dataset in parallel on workers
CTSemaphore
CTSeqCollection	Sequenceable collection abstract base class
CTServerSocket
CTSessionDescription
CTSessionDialogs	This file defines several dialogs that are used by TSessionViewer
CTSessionFrame
CTSessionInputFrame
CTSessionLogView	Dialog used to display session logs from the session viewer
CTSessionOutputFrame
CTSessionQueryFrame
CTSessionServerFrame
CTSessionViewer	Widget used to manage PROOF or local sessions, PROOF connections, queries construction and results handling
CTShape	This is the base class for all geometry shapes
CTShutdownTimer
CTSignalHandler
CTSimpleAnalysis	A TSimpleAnalysis object creates histograms from a TChain
CTSingleShotCleaner
CTSlave	Class describing a PROOF worker server
CTSlaveInfo
CTSlaveLite	Version of TSlave for local worker servers
CTSlider	A specialized TPad including a TSliderBox object
CTSliderBox	The moving box in a TSlider
CTSocket
CTSocketHandler
CTSortedList	A sorted doubly linked list
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.
CTSpectrum2Transform	Advanced 2-dimensional orthogonal transform functions
CTSpectrum3	Advanced 3-dimensional spectra processing functions
CTSpectrumFit	Advanced 1-dimensional spectra fitting functions
CTSpectrumTransform	Advanced 1-dimensional orthogonal transform functions
CTSPHE	A Sphere
CTSpider	Spider class
CTSpiderEditor	The TSpider editor class
CTSpline	Base class for spline implementation containing the Draw/Paint methods
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
CTSplinePoly	Base class for TSpline knot
CTSplinePoly3	Class for TSpline3 knot
CTSplinePoly5	Class for TSpline5 knot
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
CTSqlCmdsBuffer
CTSQLColumnData
CTSQLColumnInfo
CTSQLFile	Access an SQL db via the TFile interface
CTSQLiteResult
CTSQLiteRow
CTSQLiteServer
CTSQLiteStatement
CTSQLMonitoringWriter
CTSQLObjectData	TSQLObjectData is used in TBufferSQL2 class in reading procedure
CTSQLObjectDataPool	XML object keeper class
CTSQLObjectInfo	Info (classname, version) about object in database
CTSqlRawBuffer
CTSqlRegistry
CTSQLResult
CTSQLRow
CTSQLServer
CTSQLStatement
CTSQLStructure	This is hierarchical structure, which is created when data is written by TBufferSQL2
CTSQLTableData
CTSQLTableInfo
CTSSLSocket
CTStatistic	Statistical variable, defined by its mean and variance (RMS)
CTStatsFeedback	Utility class to display PROOF stats feedback histos during queries
CTStatus	This class holds the status of an ongoing operation and collects error messages
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
CTStdExceptionHandler
CTStopTimer
CTStopwatch	Stopwatch class
CTStorage	Storage manager
CTStreamerArtificial
CTStreamerBase
CTStreamerBasicPointer
CTStreamerBasicType
CTStreamerElement	Describe one element (data member) to be Streamed
►CTStreamerInfo	Describes a persistent version of a class
CTCompInfo
CTPointerCollectionAdapter
CTStreamerLoop
CTStreamerObject
CTStreamerObjectAny
CTStreamerObjectAnyPointer
CTStreamerObjectPointer
CTStreamerSTL
CTStreamerSTLstring
CTStreamerString
►CTString	Basic string class
CLongStr_t
CRawStr_t
CRep_t
CShortStr_t
CUStr_t
CTStringLong	ATTENTION: this class is obsolete
CTStringToken	Provides iteration through tokens of a given string
CTStructNode
CTStructNodeEditor
CTStructNodeProperty
CTStructViewer
CTStructViewerGUI
CTStyle	TStyle objects may be created to define special styles
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
CTStyleManager	This class provides a Graphical User Interface to manage styles in ROOT
CTStylePreview	This class may be used to preview the result of applying a style to a canvas
CTSubString	A zero length substring is legal
CTSVDUnfold	SVD Approach to Data Unfolding
CTSVG	Interface to SVG
CTSynapse	This is a simple weighted bidirectional connection between two neurons
CTSysEvtHandler	Abstract base class for handling system events
CTSystem	Abstract base class defining a generic interface to the underlying Operating System
CTSystemDirectory	Describes an Operating System directory for the browser
CTSystemFile	A TSystemFile describes an operating system file
CTTabCom
CTTableRange
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.
CTTermInputHandler
CTTeXDump	Interface to TeX
CTText	Base class for several text objects
CTTextEditor	Editor for changing TText's and TLatex's attributes
►CTTF	Interface to the freetype 2 library
CTTGlyph	TTF helper class containing glyphs description
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
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.
CTThreadCleaner
CTThreadFactory
CTThreadImp
CTThreadPool
CTThreadPoolTask
CTThreadPoolTaskImp
CTThreadTearDownGuard
CTThreadTimer
CTTime	Basic time type with millisecond precision
CTTimeOutTimer
CTTimer	Handles synchronous and a-synchronous timer events
CTTimeStamp	The TTimeStamp encapsulates seconds and ns since EPOCH
CTTipDelayTimer
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
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
►CTTree	A TTree represents a columnar dataset
CTClusterIterator	Helper class to iterate over cluster of baskets
CTFriendLock	Helper class to prevent infinite recursion in the usage of TTree Friends
CTTreeBrowsingElement
►CTTreeCache	A cache to speed-up the reading of ROOT datasets
CIOPos
►CMissCache
CEntry
►CTTreeCacheUnzip	A TTreeCache which exploits parallelized decompression of its own content
CUnzipState
►CTTreeCloner	Class implementing or helping the various TTree cloning method
CCompareEntry
CCompareSeek
CTTreeDrawArgsParser	A class that parses all parameters for TTree::Draw()
CTTreeDrawMonitoring
CTTreeElement	Representing TTree in browsables
►CTTreeFormula	Used to pass a selection expression to the Tree drawing routine
CRealInstanceCache
CTTreeFormulaManager	Used to coordinate one or more TTreeFormula objects
CTTreeFriendLeafIter	Iterator on all the leaves in a TTree and its friend
CTTreeIndex	A Tree Index with majorname and minorname
CTTreeInput	Tree Input Dialog Widget
►CTTreePerfStats	TTree I/O performance measurement
CBasketInfo
CTTreePlayer	Implement some of the functionality of the class TTree requiring access to extra libraries (Histogram, display, etc)
►CTTreeReader	A simple, robust and fast interface to read values from ROOT columnar datasets such as TTree, TChain or TNtuple
CIterator_t	Iterate through the entries of a TTree
►CTTreeReaderArray	An interface for reading collections stored in ROOT columnar datasets
CIterator_t	Random access iterator to the elements of a TTreeReaderArray
CTTreeReaderValue	An interface for reading values stored in ROOT columnar datasets
CTTreeReaderValueFast	Extracts data from a TTree
CTTreeResult	Class defining interface to a TTree query result with the same interface as for SQL databases
CTTreeRow	Class defining interface to a row of a TTree query result
CTTreeSQL	A TTree object is a list of TBranch
CTTreeTableInterface	TTreeTableInterface is used to interface to data that is stored in a TTree
CTTreeView	A helper class that encapsulates a file and a tree
CTTreeViewer	A graphic user interface designed to handle ROOT trees and to take advantage of TTree class features
CTTUBE	A tube
CTTUBS	A segment of a tube
CTTVLVContainer	This class represent the list view container for the TreeView class
CTTVLVEntry	This class represent entries that goes into the TreeViewer listview container
CTTVRecord	I/O classes for TreeViewer session handling
CTTVSession	I/O classes for TreeViewer session handling
CTubeMesh
CTubeSegMesh
CTUDPSocket
CTUnfold	An algorithm to unfold distributions from detector to truth level
CTUnfoldBinning	Binning schemes for use with the unfolding algorithm TUnfoldDensity
CTUnfoldBinningXML	XML interfate to binning schemes, for use with the unfolding algorithm TUnfoldDensity
CTUnfoldDensity	An algorithm to unfold distributions from detector to truth level
CTUnfoldIterativeEM
CTUnfoldSys	An algorithm to unfold distributions from detector to truth level, with background subtraction and propagation of systematic uncertainties
CTUnixSystem
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
CTUnuranSampler	TUnuranSampler class class implementing the ROOT::Math::DistSampler interface using the UNU.RAN package for sampling distributions
CTUploadDataSetDlg
CTUri	This class represents a RFC 3986 compatible URI
CTUrl	This class represents a WWW compatible URL
CTUsrHit
CTUsrHitBuffer
CTUsrSevtData1
CTUsrSevtData2
CTUtmpContent
►CTUUID	This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDentifier)
Cuuid_time_t
CTVector2
CTVector3
CTVectorT	TVectorT
CTVersionCheck	Used to check if the shared library or plugin is compatible with the current version of ROOT
CTView	See TView3D
CTView3D	The 3D view class
CTViewer3DPad	Provides 3D viewer interface (TVirtualViewer3D) support on a pad
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
CTViewPubDataMembersIter	Iterator of over the view's content
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
CTViewPubFunctionsIter	Iterator of over the view's content
CTViewTimer
CTViewUpdateTimer
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
CTVirtualBranchBrowsable	TVirtualBranchBrowsable is a base class (not really abstract, but useless by itself) for helper objects that extend TBranch's browsing support
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
CTPushPop	RAII helper class that ensures that PushProxy() / PopProxy() are called when entering / leaving a C++ context
►CTVirtualCollectionPtrIterators
CTInternalIterator
CTVirtualDragManager
CTVirtualFFT	TVirtualFFT is an interface class for Fast Fourier Transforms
CTVirtualFitter	Abstract Base Class for Fitting
CTVirtualGeoConverter	Abstract class for geometry converters
CTVirtualGeoPainter	Abstract class for geometry painters
CTVirtualGeoTrack	Base class for user-defined tracks attached to a geometry
CTVirtualGL	Abstract base class defining the OpenGL interface protocol
CTVirtualGLManip
CTVirtualGLPainter
CTVirtualGraphPainter	Abstract interface to a histogram painter
CTVirtualHistPainter	Abstract interface to a histogram painter
CTVirtualIndex	Abstract interface for Tree Index
CTVirtualIsAProxy
CTVirtualMagField	Abstract class for magnetic field
CTVirtualMapFile	Abstract base class for TMapFile
CTVirtualMCDecayer	Abstract base class for particle decays
CTVirtualMonitoring	Provides the interface for externel Monitoring
CTVirtualMonitoringReader
CTVirtualMonitoringWriter
CTVirtualMutex	This class implements a mutex interface
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
►CTVirtualPacketizer	The packetizer is a load balancing object created for each query
CTVirtualSlaveStat
►CTVirtualPad	TVirtualPad is an abstract base class for the Pad and Canvas classes
CTContext	Small helper class to store/restore gPad context in TPad methods
CTVirtualPadEditor	Abstract base class used by ROOT graphics editor
CTVirtualPadPainter	To make it possible to use GL for 2D graphic in a TPad/TCanvas
CTVirtualPaveStats
CTVirtualPerfStats	Provides the interface for the PROOF internal performance measurement and event tracing
CTVirtualProofPlayer	Abstract interface for the PROOF player
CTVirtualPS	TVirtualPS is an abstract interface to Postscript, PDF, SVG
CTVirtualQConnection	Mediates the link between the signal and the slot
CTVirtualRefProxy
CTVirtualStreamerInfo	Abstract Interface class describing Streamer information for one class
CTVirtualTableInterface
CTVirtualTreePlayer	Abstract base class defining the interface for the plugins that implement Draw, Scan, Process, MakeProxy, etc
CTVirtualVectorIterators
CTVirtualViewer3D	Abstract 3D shapes viewer
CTVirtualX	Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...)
CTWbox	A TBox with a bordersize and a bordermode
CTWebArgsMenuItem
►CTWebCanvas	Basic TCanvasImp ABI implementation for Web-based Graphics Provides painting of main ROOT classes in web browsers using JSROOT
CPadStatus
CWebConn
CTWebCanvasTimer
CTWebCheckedMenuItem
CTWebControlBar	Web-based implementation for TControlBar class
CTWebFile
CTWebMenuArgument
CTWebMenuItem	Class contains info for producing menu item on the JS side
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
CTWebPadPainter	Implement TVirtualPadPainter which abstracts painting operations
CTWebPainting	Object used to store paint operations and deliver them to JSROOT
CTWebPalette
CTWebPS
CTWebSnapshot	Paint state of object to transfer to JavaScript side
CTWebSocket
CTWebSystem
CTWin32Condition
CTWin32Mutex
CTWin32SplashThread
CTWin32Thread
CTWin32ThreadCleanUp
CTWin32ThreadFactory
CTWinNTSystem	Class providing an interface to the Windows NT Operating System
CTWriteEnvParser
►CTX11GLManager	The TX11GLManager is X11 implementation of TGLManager
CTGLContext_t
CTX11GLImpl
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
CTXMLEntity
CTXMLFile
CTXMLInputStream
CTXMLNode	TXMLNode contains a pointer to xmlNode, which is a node under the DOM tree
CTXMLOutputStream
CTXMLParser	TXMLParser is an abstract class which interfaces with Libxml2
CTXMLPlayer
CTXMLSetup
CTXMLStackObj
CTXTRU	A poly-extrusion
CTypeTraits
CTZIPFile	Describes a ZIP archive file containing multiple sub-files
CTZIPMember	A ZIP archive consists of files compressed with the popular ZLIB compression algorithm; this class records the information about a single archive member
CUnuranRng	UnuranRng class for interface ROOT random generators to Unuran
Cusa
CUserGroup_t
CValue
CVariableSelectionRule
Cvec
CVecTVecDouble
CVecVecDouble
CVisual
CWebFont_t
Cwebsocket_client_thread_data
CWindowAttributes_t	Window attributes that can be inquired
C<X11Drawable>
C<X11Window>
CXColor
CXColor_t	Description of a X11 color
CXGCValues
CXImage
CXLFDAttributes_t
►CXMLReader
CAttributes
CXorDrawingView
CXorDrawingWindow
CXpmAttributes
CxRooProjectedPdf
CXSetWindowAttributes
CXShapeEvent
CXVisualInfo
CXWindow_t	Description of a X11 window
CZeroMQPoller	Wrapper class for polling ZeroMQ sockets
CZeroMQSvc	Wrapper class for basic ZeroMQ context and socket management
CZmqLingeringSocketPtrDeleter