| ►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 | |
| ►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 | |
| ►NRF_ARCH | |
| CRooBatchComputeClass | This class overrides some RooBatchComputeInterface functions, for the purpose of providing a CPU specific implementation of the library |
| 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 | |
| ►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 |
| 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 | < A class that holds configuration information for a model using a workspace as a store |
| 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 | Namespace for new ROOT classes and functions |
| ►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 | |
| CRAuxiliaryProcessorField | |
| CRAxes | Bin configurations for all dimensions of a histogram |
| 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 |
| CRBinIndex | A bin index with special values for underflow and overflow bins |
| ►CRBinIndexRange | A range of bin indices \([fBegin, fEnd)\) |
| CIterator | Iterator over RBinIndex |
| 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 |
| CREveCamera | |
| 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 | |
| CRHistEngine | A histogram data structure to bin data along multiple dimensions |
| CRIndirectDisplayItem | Extract (reference) only basic attributes from drawable, but not drawable itself |
| CRLinearizedIndex | A linearized index that can be invalid |
| 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) RNTupleProcessors |
| 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) |
| 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 |
| CRRegularAxis | A regular axis with equidistant bins in the interval \([fLow, fHigh)\) |
| ►CRStyle | A set of defaults for graphics attributes, e.g |
| CBlock_t | |
| ►CRTreeMapBase | Base logic for drawing a treemap visualization |
| CNode | |
| CRect | |
| CRGBColor | |
| CVec2 | |
| ►CRTreeMapPainter | Logic for drawing a treemap on a TVirtualPad |
| CNode | |
| CRVariableBinAxis | An axis with variable bins defined by their edges |
| 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 | |
| CRActionSnapshot | |
| CRArraySizeField | An artificial field that provides the size of a fixed-size array |
| CRBranchSet | |
| CRCallback | |
| CRColumnReadersInfo | This type aggregates some of the arguments passed to GetColumnReaders |
| CRColumnRegister | A binder for user-defined columns, variations and aliases |
| CRCsvDSColumnReader | |
| 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 |
| CRLazyDSColumnReader | |
| 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 |
| CRSqliteDSColumnReader | |
| 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 |
| CRTrivialDSColumnReader | |
| 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 |
| CTPointerHolder | Mother class of TTypedPointerHolder |
| CTTypedPointerHolder | Class to wrap a pointer and delete the memory associated to it correctly |
| CTValueGetter | Helper class which keeps track for each slot where to get the entry |
| CUntypedSnapshotRNTupleHelper | |
| CUntypedSnapshotTTreeHelper | |
| CUntypedSnapshotTTreeHelperMT | |
| CUseNativeDataType | Tag to let data sources use the native data type when creating a column reader |
| CValueType | |
| CValueType< ROOT::VecOps::RVec< T >, false > | |
| CValueType< T, false > | |
| ►NRootCling | |
| CDriverConfig | |
| CTROOTSYSSetter | |
| ►NSHA256 | |
| Csha256_t | |
| ►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 | |
| 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 |
| CRNTupleClusterBoundaries | |
| 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 |
| CRNTupleDrawVisitor | |
| ►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 | Class representing a data point |
| 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 |
| 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 | |
| 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 |
| CMnPoint | A point in x-y |
| 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) |
| 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 some basic parameters of a TH1D |
| CTH2DModel | A struct which stores some basic parameters of a TH2D |
| CTH3DModel | A struct which stores some basic parameters of a TH3D |
| CTHnDModel | A struct which stores some basic parameters of a THnD |
| CTProfile1DModel | A struct which stores some basic parameters of a TProfile |
| CTProfile2DModel | A struct which stores some basic 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 | RRVecDeleter is also used by RArrayAsRVecField and therefore declared public |
| 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 | |
| CTensorShape | |
| CTensorShape< Dim > | |
| CTensorShape< size_t > | |
| CTensorType | |
| CTensorType< bool > | |
| 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 |
| CMethodName | |
| 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_ | |
| CAlternateTupleIntDoubleAsc | |
| CAlternateTupleIntDoubleDes | |
| CAnyCollectionProxy | |
| CAnyCollectionStreamer | |
| Cauth_header | |
| 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 | |
| CCollectionManager | |
| CColorStruct_t | |
| CCompareAsc | |
| CcompareBAasc | |
| CcompareBAdesc | |
| CCompareDataHistBins | |
| CCompareDesc | |
| CCompareSparseHistBins | |
| CCompareVectorIndices | |
| CContDist | Free functions adapter needed by UNURAN for onedimensional continuous distributions |
| Ccout_redirect | |
| 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 | |
| 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 | |
| CMarkerDescription_t | |
| Cmd5_state_s | |
| 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_match_context | |
| Cmg_match_element | |
| 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 | |
| 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 | |
| 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 | |
| CRAxes_Regular1 | |
| CRAxes_Regular2 | |
| 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 |
| CRFieldsIterator | Iterator over RNTuple fields |
| CRFitPanel | Web-based FitPanel prototype |
| CRGroupIter | |
| CRHistEngine_int_Regular1 | |
| CRHistEngine_int_Regular2 | |
| 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 |
| 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 |
| CRooGaussExpTails | PDF implementing a Gaussian core + double-sided exponential tail distribution |
| 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 |
| CRooMultiPdf | The class RooMultiPdf allows for the creation of a RooMultiPdf object, which can switch between previously set probability density functions (PDF) by setting their associated indices |
| CRooMultiReal | |
| ►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 | |
| 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 | |
| CRRegularAxis | |
| 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 | |
| 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 | |
| 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 | |
| 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 |
| 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 |
| CTDNDData | Drag and drop data container |
| CTDOMParser | |
| CTDomParser | DOM stands for the Document Object Model; this is an API for accessing XML or HTML structured documents |
| CTDumpMembers | |
| 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 | |
| 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 | |
| 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 | 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 long integer data type (Long_t, non-portable size) |
| 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 | |
| ►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 |
| 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 | |
| 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 | |
| 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 |
| CToolBarData_t | |
| CTOptionListItem | |
| CTOrdCollection | Ordered collection |
| CTOrdCollectionIter | Iterator of ordered collection |
| 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 |
| CTPCON | A polycone |
| CTPDF | Interface to PDF |
| CTPGON | A polygon |
| 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 |
| 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 | |
| ►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) |
| 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 |
| 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 |
| CTSemaphore | |
| CTSeqCollection | Sequenceable collection abstract base class |
| CTServerSocket | |
| CTShape | This is the base class for all geometry shapes |
| CTSignalHandler | |
| CTSimpleAnalysis | A TSimpleAnalysis object creates histograms from a TChain |
| CTSingleShotCleaner | |
| 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) |
| 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 | |
| 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 |
| 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 |
| CTVirtualGeoChecker | Abstract class for geometry checkers |
| 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 |
| ►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 an internal performance measurement and event tracing |
| 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 |
| Ctwebdav_lock | |
| 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 | |
