| Narrow | |
| ►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 | |
| ►Nclad | |
| ►Ncustom_derivatives | |
| ►NROOT | |
| NMath | |
| NTMath | |
| Nclang | |
| ►NClingMemberIterInternal | |
| CDCIter | Iteration over collected DeclContexts |
| ►CUsingDeclIter | |
| CUsingDeclFrame | |
| ►NCppyy | |
| NReflex | |
| ►NCppyyLegacy | |
| CExceptionContext_t | |
| ►NCPyCppyy | |
| NPyStrings | |
| NTypeManip | |
| ►NUtility | |
| CPyError_t | |
| 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 | |
| NDavix | |
| Nfw3dlego | |
| Ngenreflex | |
| NHFit | |
| NLiterals | |
| Nllvm | |
| NMath | Namespace for new Math classes and functions |
| NMPCode | This namespace prevents conflicts between MPCode::kError and ELogLevel::kError |
| NNumberCountingUtils | RooStats standalone utilities |
| Nonnx | |
| ►NOuter | |
| CInner | |
| CTemplate | |
| CTemplate< Inner, 1 > | Simple specialisation |
| CTemplate< Template< Inner, 2 >, 1 > | Complex specialisation |
| ►NPyROOT | |
| CRPyROOTApplication | Interactive application for Python |
| CReshape | |
| NQuantize | |
| ►NR6 | |
| CDim | |
| ►CDim< T, 1 > | |
| CEE | |
| CII | |
| ►CDim< T, 2 > | |
| CEE | |
| CII | |
| CRedirect | |
| CRedirect< 1, double > | |
| CRedirect< 1, float > | |
| CRedirect< 2, double > | |
| CRedirect< 2, float > | |
| ►NR7 | |
| CDim | |
| ►CDim< T, 1 > | |
| CEE | |
| CII | |
| ►CDim< T, 2 > | |
| CEE | |
| CII | |
| ►NRcpp | This is a class to support deprecated method to pass function to R's Environment, based in Rcpp::InternalFunction |
| Ntraits | |
| ►NReadSpeed | |
| CArgs | |
| CByteData | |
| CData | |
| CEntryRange | |
| CReadSpeedRegex | |
| CResult | |
| ►NRgl | |
| ►NFgt | |
| CTKDEAdapter | |
| ►NMc | |
| CTCell | |
| CTDefaultSplitter | |
| CTF3Adapter | |
| CTF3EdgeSplitter | |
| CTGridGeometry | |
| CTH3Adapter | |
| CTIsoMesh | |
| CTMeshBuilder | |
| CTSlice | |
| CTSourceAdapterSelector | |
| CTSourceAdapterSelector< TF3 > | |
| CTSourceAdapterSelector< TH3C > | |
| CTSourceAdapterSelector< TH3D > | |
| CTSourceAdapterSelector< TH3F > | |
| CTSourceAdapterSelector< TH3I > | |
| CTSourceAdapterSelector< TH3S > | |
| CTSourceAdapterSelector< TKDEFGT > | |
| CTSplitterSelector | |
| CTSplitterSelector< TF3, V > | |
| CTSplitterSelector< TH3C, V > | |
| CTSplitterSelector< TH3D, V > | |
| CTSplitterSelector< TH3F, V > | |
| CTSplitterSelector< TH3I, V > | |
| CTSplitterSelector< TH3S, V > | |
| CTSplitterSelector< TKDEFGT, V > | |
| ►NPad | |
| CBoundingRect | |
| CFillAttribSet | |
| CGLLimits | |
| CLineAttribSet | |
| CMarkerPainter | |
| CMeshPatch_t | |
| COffScreenDevice | |
| CPolygonStippleSet | |
| CTesselator | |
| CPlotTranslation | |
| CTGuardBase | |
| CTOneArgGuard | |
| CTTwoArgsGuard | |
| ►NRooBatchCompute | Namespace for dispatching RooFit computations to various backends |
| ►NCUDA | |
| CRooBatchComputeClass | This class overrides some RooBatchComputeInterface functions, for the purpose of providing a cuda specific implementation of the library |
| ►NCudaInterface | |
| CArray | A templated class for managing an array of data using a specified memory type |
| CCudaEvent | |
| CCudaStream | |
| CAbsBuffer | |
| CAbsBufferManager | |
| CBatch | |
| CBatches | |
| CBracketAdapter | Little adapter that gives a bracket operator to types that don't have one |
| CBracketAdapterWithMask | |
| CConfig | Minimal configuration struct to steer the evaluation of a single node with the RooBatchCompute library |
| CReduceNLLOutput | |
| CRooBatchComputeInterface | The interface which should be implemented to provide optimised computation functions for implementations of RooAbsReal::doEval() |
| ►NRooFit | The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or other types of arguments) |
| ►NDetail | |
| NMathFuncs | |
| CCompileContext | |
| CDataKey | |
| CFlatMap | |
| CHashAssistedFind | Helper for hash-map-assisted finding of elements by name |
| ►CJSONNode | |
| ►Cchild_iterator_t | |
| CImpl | |
| Cchildren_view_t | |
| CJSONTree | |
| CRooAbsDataFiller | |
| CRooFixedProdPdf | A RooProdPdf with a fixed normalization set can be replaced by this class |
| CRooNormalizedPdf | |
| CRooPyBind | |
| ►NExperimental | |
| ►CCodegenContext | A class to maintain the context for squashing of RooFit models into code |
| CLoopScope | A class to manage loop scopes using the RAII technique |
| CScopeRAII | |
| CCodegenIntegralImplCaller | |
| CPrio | |
| ►CRooFuncWrapper | A wrapper class to store a C++ function of type 'double (*)(double*, double*)' |
| CObsInfo | |
| ►NJSONIO | |
| ►NDetail | |
| ►CDomains | |
| ►CProductDomain | |
| CProductDomainElement | |
| CExporter | |
| CExportKeys | |
| CImporter | |
| CImportExpression | |
| ►NMultiProcess | |
| ►NDetail | |
| CHeatmapAnalyzerJsonData | |
| ►CConfig | Configuration for MultiProcess infrastructure |
| CLikelihoodJob | |
| CQueue | |
| CFIFOQueue | A Queue with simple FIFO behavior |
| CHeatmapAnalyzer | Reads and processes logfiles produced by RooFit::MultiProcess::ProcessTimer |
| CJob | Interface class for defining the actual work that must be done |
| CJobManager | Main point of access for all MultiProcess infrastructure |
| CJobTask | Combined job_object, state and task identifier type |
| CMessenger | Manages ZeroMQ sockets and wraps send and receive calls |
| COrderedJobTask | |
| CPriorityQueue | Queue that orders tasks according to specified task priorities |
| CProcessManager | Fork processes for queue and workers |
| CProcessTimer | Can be used to generate timings of multiple processes simultaneously and output logs |
| CQueue | Keeps a queue of tasks for workers and manages the queue process through its event loop |
| ►NTestStatistics | Namespace for new RooFit test statistic calculation |
| CConstantTermsOptimizer | Analyzes a function given a dataset/observables for constant terms and caches those in the dataset |
| ►CLikelihoodGradientJob | |
| Ctask_result_t | |
| CLikelihoodGradientWrapper | Virtual base class for implementation of likelihood gradient calculation strategies |
| ►CLikelihoodJob | |
| Ctask_result_t | |
| Cupdate_state_t | |
| CLikelihoodSerial | Serial likelihood calculation strategy implementation |
| CLikelihoodWrapper | Virtual base class for implementation of likelihood calculation strategies |
| CMinuitFcnGrad | Minuit-RooMinimizer interface which synchronizes parameter data and coordinates evaluation of likelihood (gradient) values |
| CNLLFactory | |
| ►CRooAbsL | |
| CClonePdfData | Convenience wrapper class used to distinguish between pdf/data owning and non-owning constructors |
| CSection | A part of some range delimited by two fractional points between 0 and 1 (inclusive) |
| CRooBinnedL | |
| CRooRealL | RooAbsReal that wraps RooAbsL likelihoods for use in RooFit outside of the RooMinimizer context |
| CRooSubsidiaryL | |
| CRooSumL | Likelihood class that sums over multiple -log components |
| CRooUnbinnedL | |
| CWrapperCalculationCleanFlags | For communication with wrappers, an instance of this struct must be shared between them and MinuitFcnGrad |
| CEvalBackend | |
| CEvalContext | |
| CEvaluator | Evaluates a RooAbsReal object in other ways than recursive graph traversal |
| CNodeInfo | A struct used by the Evaluator to store information on the RooAbsArgs in the computation graph |
| CUniqueId | A UniqueId can be added as a class member to enhance any class with a unique identifier for each instantiated object |
| NRooFitShortHand | |
| ►NRooHelpers | |
| NDetail | |
| 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 |
| NRooHeterogeneousMath | |
| ►NRooStats | Namespace for the RooStats classes |
| ►NHistFactory | |
| NConstraint | |
| ►NDetail | |
| NMagicConstants | |
| 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 | |
| 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 |
| NNumberCountingUtils | |
| NROOTDict | |
| CAcceptanceRegion | |
| CAsymptoticCalculator | Hypothesis Test Calculator based on the asymptotic formulae for the profile likelihood ratio |
| CBayesianCalculator | BayesianCalculator is a concrete implementation of IntervalCalculator, providing the computation of a credible interval using a Bayesian method |
| CBernsteinCorrection | BernsteinCorrection is a utility in RooStats to augment a nominal PDF with a polynomial correction term |
| CBranchStore | |
| CCombinedCalculator | CombinedCalculator is an interface class for a tools which can produce both RooStats HypoTestResults and ConfIntervals |
| CConfidenceBelt | ConfidenceBelt is a concrete implementation of the ConfInterval interface |
| CConfInterval | ConfInterval is an interface class for a generic interval in the RooStats framework |
| CDebuggingSampler | |
| CDebuggingTestStat | |
| CDetailedOutputAggregator | This class is designed to aid in the construction of RooDataSets and RooArgSets, particularly those naturally arising in fitting operations |
| CFeldmanCousins | (like the Feldman-Cousins technique) is essentially a specific configuration of the more general NeymanConstruction |
| CFrequentistCalculator | Does a frequentist hypothesis test |
| CHeaviside | Represents the Heaviside function |
| CHLFactory | HLFactory is an High Level model Factory allows you to describe your models in a configuration file (datacards) acting as an interface with the RooFactoryWSTool |
| CHybridCalculator | Same purpose as HybridCalculatorOriginal, but different implementation |
| CHybridPlot | This class provides the plots for the result of a study performed with the HybridCalculatorOriginal class |
| CHybridResult | Class encapsulating the result of the HybridCalculatorOriginal |
| CHypoTestCalculator | HypoTestCalculator is an interface class for a tools which produce RooStats HypoTestResults |
| CHypoTestCalculatorGeneric | Common base class for the Hypothesis Test Calculators |
| CHypoTestInverter | A class for performing a hypothesis test inversion by scanning the hypothesis test results of a HypoTestCalculator for various values of the parameter of interest |
| CHypoTestInverterPlot | Class to plot a HypoTestInverterResult, the output of the HypoTestInverter calculator |
| CHypoTestInverterResult | HypoTestInverterResult class holds the array of hypothesis test results and compute a confidence interval |
| CHypoTestPlot | This class provides the plots for the result of a study performed with any of the HypoTestCalculatorGeneric (e.g |
| CHypoTestResult | HypoTestResult is a base class for results from hypothesis tests |
| CIntervalCalculator | IntervalCalculator is an interface class for a tools which produce RooStats ConfIntervals |
| CLikelihoodFunction | |
| CLikelihoodInterval | LikelihoodInterval is a concrete implementation of the RooStats::ConfInterval interface |
| CLikelihoodIntervalPlot | This class provides simple and straightforward utilities to plot a LikelihoodInterval object |
| CMarkovChain | Stores the steps in a Markov Chain of points |
| CMaxLikelihoodEstimateTestStat | MaxLikelihoodEstimateTestStat: TestStatistic that returns maximum likelihood estimate of a specified parameter |
| CMCMCCalculator | Bayesian Calculator estimating an interval or a credible region using the Markov-Chain Monte Carlo method to integrate the likelihood function with the prior to obtain the posterior function |
| CMCMCInterval | MCMCInterval is a concrete implementation of the RooStats::ConfInterval interface |
| CMCMCIntervalPlot | This class provides simple and straightforward utilities to plot a MCMCInterval object |
| CMetropolisHastings | This class uses the Metropolis-Hastings algorithm to construct a Markov Chain of data points using Monte Carlo |
| CMinNLLTestStat | MinNLLTestStat is an implementation of the TestStatistic interface that calculates the minimum value of the negative log likelihood function and returns it as a test statistic |
| CModelConfig | ModelConfig is a simple class that holds configuration information specifying how a model should be used in the context of various RooStats tools |
| CNeymanConstruction | NeymanConstruction is a concrete implementation of the NeymanConstruction interface that, as the name suggests, performs a NeymanConstruction |
| CNuisanceParametersSampler | Helper class for ToyMCSampler |
| CNumberCountingPdfFactory | A factory for building PDFs and data for a number counting combination |
| CNumEventsTestStat | NumEventsTestStat is a simple implementation of the TestStatistic interface used for simple number counting |
| CPdfProposal | PdfProposal is a concrete implementation of the ProposalFunction interface |
| CPointSetInterval | PointSetInterval is a concrete implementation of the ConfInterval interface |
| CPosteriorCdfFunction | |
| CPosteriorFunction | |
| CPosteriorFunctionFromToyMC | Posterior function obtaining sampling toy MC for the nuisance according to their pdf |
| CProfileInspector | Utility class to plot conditional MLE of nuisance parameters vs |
| CProfileLikelihoodCalculator | The ProfileLikelihoodCalculator is a concrete implementation of CombinedCalculator (the interface class for tools which can produce both a RooStats HypoTestResult and ConfInterval) |
| CProfileLikelihoodTestStat | ProfileLikelihoodTestStat is an implementation of the TestStatistic interface that calculates the profile likelihood ratio at a particular parameter point given a dataset |
| CProposalFunction | ProposalFunction is an interface for all proposal functions that would be used with a Markov Chain Monte Carlo algorithm |
| CProposalHelper | |
| CRatioOfProfiledLikelihoodsTestStat | TestStatistic that returns the ratio of profiled likelihoods |
| CRooStatsConfig | |
| CSamplingDistPlot | This class provides simple and straightforward utilities to plot SamplingDistribution objects |
| CSamplingDistribution | This class simply holds a sampling distribution of some test statistic |
| CSamplingSummary | |
| CSamplingSummaryLookup | |
| CSequentialProposal | Class implementing a proposal function that samples the parameter space by moving only in one coordinate (chosen randomly) at each step |
| CSimpleInterval | SimpleInterval is a concrete implementation of the ConfInterval interface |
| CSimpleLikelihoodRatioTestStat | TestStatistic class that returns -log(L[null] / L[alt]) where L is the likelihood |
| CSPlot | A class to calculate "sWeights" used to create an "sPlot" |
| CTestStatistic | TestStatistic is an interface class to provide a facility for construction test statistics distributions to the NeymanConstruction class |
| CTestStatSampler | TestStatSampler is an interface class for a tools which produce RooStats SamplingDistributions |
| CToyMCImportanceSampler | ToyMCImportanceSampler is an extension of the ToyMCSampler for Importance Sampling |
| CToyMCSampler | ToyMCSampler is an implementation of the TestStatSampler interface |
| CUniformProposal | UniformProposal is a concrete implementation of the ProposalFunction interface for use with a Markov Chain Monte Carlo algorithm |
| CUpperLimitMCSModule | This class allow to compute in the ToyMcStudy framework the ProfileLikelihood upper limit for each toy-MC sample generated |
| ►NROOT | Tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tbb::task_arena without forward declaring tbb::interface7 |
| N_pythonization | |
| ►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 |
| NCocoaTutorials | |
| ►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 |
| ►NInternal | |
| NRDF | |
| ►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 > | |
| 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 | |
| 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 |
| CRFieldVisitor | Abstract base class for classes implementing the visitor design pattern |
| CRHistBinIter | Iterates over the bins of a RHist or RHistImpl |
| CRHistBinPtr | Points to a histogram bin (or actually a RHistBinRef) |
| CRHistBinRef | Represents a bin reference |
| CRHistBinStat | Const view on a bin's statistical data |
| CRHistData | A RHistImplBase's data, provides accessors to all its statistics |
| CRHistImpl | |
| CRHistImplBase | Interface class for RHistImpl |
| CRHistImplPrecisionAgnosticBase | Base class for RHistImplBase that abstracts out the histogram's PRECISION |
| CRLogBuilder | Builds a diagnostic entry, emitted by the static RLogManager upon destruction of this builder, where - by definition - the RLogEntry has been completely built |
| 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 | An either thread-safe or non thread safe counter for CPU ticks |
| CRNTupleTimer | Record wall time and CPU time between construction and destruction |
| ►NEveGlu | |
| CTestTriangleHandler | TestTriangleHandler is just helper class to get access to protected members of TriangleCollector Hide static declarations, let use "native" GL types |
| CTriangleCollector | |
| ►NHist | |
| CRCoordArray | |
| ►NInternal | |
| NBitPacking | |
| CAxisConfigToType | Converts a RAxisConfig of whatever kind to the corresponding RAxisBase-derived object |
| CAxisConfigToType< RAxisConfig::kEquidistant > | |
| CAxisConfigToType< RAxisConfig::kGrow > | |
| CAxisConfigToType< RAxisConfig::kIrregular > | |
| CAxisConfigToType< RAxisConfig::kLabels > | |
| CRArraySizeField | An artificial field that provides the size of a fixed-size array |
| ►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 |
| CRColumnMergeInfo | |
| CRComputeGlobalBin | Recursively gets the total number of regular bins before the current dimension, when computing a global bin that is in under- or overflow in at least one dimension |
| CRComputeGlobalBin<-1, NDIMS, BINS, AXES > | |
| CRComputeGlobalBinRaw | Recursively computes a zero-based global bin index, given.. |
| CRComputeGlobalBinRaw<-1, NDIMS, BINS, AXES, BINTYPE > | |
| CRComputeLocalBins | Recursively computes the number of regular bins before the current dimension, as well as the number of under- and overflow bins left to account for, after the current dimension |
| CRComputeLocalBins< 0, NDIMS, AXES > | |
| CRComputeLocalBinsInitialisation | Recursively compute some quantities needed for ComputeLocalBins, namely the total number of bins per hyperplane (overflow and regular) and the number of regular bins per hyperplane on the hyperplanes that have them |
| CRComputeLocalBinsInitialisation< 0, NDIMS, AXES > | |
| CRComputeLocalBinsRaw | Recursively computes zero-based local bin indices, given.. |
| CRComputeLocalBinsRaw<-1, NDIMS, BINS, AXES, BINTYPE > | |
| ►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 |
| CRDirectoryEntry | |
| CRExtraTypeInfoDescriptorBuilder | A helper class for piece-wise construction of an RExtraTypeInfoDescriptor |
| CRFieldDescriptorBuilder | A helper class for piece-wise construction of an RFieldDescriptor |
| CRFieldRepresentationModifier | |
| CRFileSharedPtrCtor | |
| CRFileStorageInterface | Base class for RFile storage backends |
| CRFillIterRange | Recursively fills the ranges of all axes, excluding under- and overflow |
| CRFillIterRange<-1, AXES > | |
| CRFindLocalBins | Find the per-axis local bin indices associated with a certain set of coordinates |
| CRFindLocalBins<-1, NDIMS, BINS, COORD, AXES > | |
| CRGetNBinsCount | Recursively gets the total number of bins in whole hist, including under- and overflow |
| CRGetNBinsCount< 0, AXES > | |
| CRGetNBinsNoOverCount | Recursively gets the total number of bins in whole hist, excluding under- and overflow |
| CRGetNBinsNoOverCount< 0, AXES > | |
| CRGetNRegularBinsBefore | Recursively gets the number of regular bins just before the current dimension |
| CRGetNRegularBinsBefore<-1, NDIMS, BINS, AXES > | |
| CRHistBufferedFillBase | |
| CRHistImplGen | Generate RHist::fImpl from RHist constructor arguments |
| CRHistImplGen< NDIM, NDIM, DATA, PROCESSEDAXISCONFIG... > | Generate RHist::fImpl from constructor arguments; recursion end |
| CRIndexIter | Iterates over an index; the REFERENCE is defined by the REFERENCE template parameter |
| 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 > | |
| CRIOShared | |
| CRIOSharedBase | |
| CRKeyBlob | The RKeyBlob writes an invisible key into a TFile |
| CRLocalBinsToCoords | Recursively converts local axis bins from the standard kUnderflowBin/kOverflowBin for under/overflow bin indexing convention, to the corresponding bin coordinates |
| CRLocalBinsToCoords<-1, NDIMS, BINS, COORD, AXES > | |
| CRLocalBinsToVirtualBins | Recursively converts local axis bins from the standard kUnderflowBin/kOverflowBin for under/overflow bin indexing convention, to a "virtual bin" convention where the underflow bin has index 0 and the overflow bin has index N+1 where N is the axis' number of regular bins |
| CRLocalBinsToVirtualBins<-1, NDIMS, BINS, AXES > | |
| CRMiniFileReader | Read RNTuple data blocks from a TFile container, provided by a RRawFile |
| CRNTupleColumnReader | Every RDF column is represented by exactly one RNTuple field |
| 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 |
| ►CRNTupleExporter | |
| CRFilter | |
| CRPagesOptions | |
| CRPagesResult | |
| ►CRNTupleFileWriter | Write RNTuple data blocks in a TFile or a bare file container |
| CRFileProper | |
| CRFileSimple | |
| CRNTupleImtTaskScheduler | |
| ►CRNTupleIndex | Builds an index on one or several fields of an RNTuple so it can be joined onto other RNTuples |
| CRIndexValue | Container for the hashes of the indexed fields |
| CRIndexValueHash | Hash combinining the individual index value hashes from RIndexValue |
| CRNTupleMergeData | |
| CRNTupleMergeOptions | |
| CRNTupleMerger | Given a set of RPageSources merge them into an RPageSink, optionally changing their compression |
| CRNTupleModelChangeset | The incremental changes to a RNTupleModel |
| ►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 |
| CRPageNullSink | Dummy sink that discards all 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 |
| CRPageSinkDaos | Storage provider that writes ntuple pages to into a DAOS container |
| ►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()` |
| CRPageSourceDaos | Storage provider that reads ntuple pages from a DAOS container |
| ►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 |
| CRProjectedFields | The projected fields of a RNTupleModel |
| CRRDFCardinalityField | An artificial field that transforms an RNTuple column that contains the offset of collections into collection sizes |
| CRSealedPageMergeData | |
| 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 |
| CRVirtualBinsToLocalBins | Recursively converts zero-based virtual bins where the underflow bin has index 0 and the overflow bin has index N+1 where N is the axis' number of regular bins, to the standard kUnderflowBin/kOverflowBin for under/overflow bin indexing convention |
| CRVirtualBinsToLocalBins<-1, NDIMS, BINS, AXES > | |
| ►CRVirtualCanvasPainter | Abstract interface for painting a canvas |
| CGenerator | |
| ►CRWritePageMemoryManager | Helper to maintain a memory budget for the write pages of a set of columns |
| CRColumnInfo | |
| 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 | |
| CHasCollectionProxyMemberType | Template specializations for classes with collection proxies |
| CIsCollectionProxy | The point here is that we can only tell at run time if a class has an associated 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 |
| 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 > | |
| ►CRAxisBase | Histogram axis base class |
| Cconst_iterator | Random const_iterator through bins |
| ►CRAxisConfig | Objects used to configure the different axis types |
| CGrow_t | Tag type signalling that an axis should be able to grow; used for calling the appropriate constructor |
| CRAxisDrawable | Axis drawing |
| CRAxisEquidistant | Axis with equidistant bin borders |
| CRAxisGrow | An axis that can extend its range, keeping the number of its bins unchanged |
| CRAxisIrregular | An axis with non-equidistant bins (also known as "variable binning") |
| CRAxisLabels | A RAxisGrow that has a label assigned to each bin and a bin width of 1 |
| CRBitsetField | Template specializations for C++ std::bitset |
| CRCanvas | A window's topmost RPad |
| CRCanvasDisplayItem | Class RCanvasDisplayItem |
| ►CRCanvasPainter | Implementation of painter for ROOT::Experimental::RCanvas, using RWebWindow |
| CGeneratorImpl | |
| CWebCommand | |
| CWebConn | |
| CWebUpdate | |
| CRCardinalityField | An artificial field that transforms an RNTuple column that contains the offset of collections into collection sizes |
| CRChangeAttrRequest | |
| ►CRClassField | The field for a class with dictionary |
| CRClassDeleter | |
| CRSubFieldInfo | |
| ►CRClusterDescriptor | Meta-data for a set of ntuple clusters |
| CRColumnRange | The window of element indexes of a particular column in a particular cluster |
| ►CRColumnRangeIterable | |
| CRIterator | |
| ►CRPageRange | Records the partition of data into pages for a particular column in a particular cluster |
| CRPageInfo | We do not need to store the element size / uncompressed page size because we know to which column the page belongs |
| CRPageInfoExtended | |
| CRClusterGroupDescriptor | Clusters are bundled in cluster groups |
| CRClusterIndex | Addresses a column element or field item relative to a particular cluster, instead of a global NTupleSize_t index |
| CRClusterSize | Wrap the integer in a struct in order to avoid template specialization clash with std::uint64_t |
| CRColor | The color class |
| ►CRColumnDescriptor | Meta-data stored for every column of an ntuple |
| CRValueRange | |
| CRColumnSwitch | Holds the index and the tag of a kSwitch column |
| ►CRDirectory | Key/value store of objects |
| CToContentType | |
| CRDirectoryTypeMismatch | Objects of this class are thrown to signal that the value known under the given name |
| CRDirectoryUnknownKey | Objects of this class are thrown to signal that no key with that name exists |
| CRDisplayHistStat | Object send to client for display of RHistStat, required to avoid sending histogram to the client |
| 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 |
| ►CREntry | The REntry is a collection of values in an ntuple corresponding to a complete row in the data set |
| CRFieldToken | The field token identifies a (sub)field in this entry |
| CREnumField | The field for an unscoped or scoped enum with dictionary |
| CREve3DProjection | |
| CREveAunt | |
| CREveAuntAsList | |
| CREveBox | |
| CREveBoxProjected | |
| ►CREveBoxSet | |
| CBFreeBox_t | |
| CInstanced_t | |
| CInstancedScaled_t | |
| CInstancedScaledRotated_t | |
| CREveCalo2D | |
| CREveCalo3D | |
| ►CREveCaloData | |
| CCellData_t | |
| CCellGeom_t | |
| CCellId_t | |
| CRebinData_t | |
| CSliceInfo_t | |
| CREveCaloDataHist | |
| CREveCaloDataSelector | |
| CREveCaloDataSliceSelector | |
| CREveCaloDataVec | |
| CREveCaloLego | |
| CREveCaloViz | |
| ►CREveChunkManager | |
| Citerator | |
| CREveChunkVector | |
| CREveClient | |
| CREveCluster | REveCluster Reconstructed cluster (also used in VSD) |
| CREveCollectionCompound | |
| CREveCompound | |
| CREveCompoundProjected | |
| CREveDataCollection | |
| CREveDataColumn | |
| CREveDataItem | |
| ►CREveDataItemList | |
| CTTip | |
| ►CREveDataProxyBuilderBase | |
| CProduct | |
| ►CREveDataSimpleProxyBuilder | |
| CSPBProduct | |
| CREveDataSimpleProxyBuilderTemplate | |
| CREveDataTable | |
| ►CREveDigitSet | |
| CDigitBase_t | |
| CREveElement | |
| CREveEllipsoid | |
| CREveEllipsoidProjected | |
| CREveException | REveException Exception-type thrown by Eve classes |
| CREveFrameBox | |
| CREveGeoManagerHolder | REveGeoManagerHolder Exception-safe global variable holders |
| ►CREveGeoPolyShape | |
| CEdge_t | |
| CREveGeoShape | |
| CREveGeoShapeExtract | |
| CREveGeoShapeProjected | |
| CREveGeoTopNodeData | |
| CREveGeoTopNodeViz | |
| CREveHit | REveHit Monte Carlo hit (also used in VSD) |
| CREveJetCone | |
| CREveJetConeProjected | |
| CREveLine | REveLine An arbitrary polyline with fixed line and marker attributes |
| CREveLineProjected | |
| CREveMagField | REveMagField Abstract interface to magnetic field |
| CREveMagFieldConst | REveMagFieldConst Interface to constant magnetic field |
| CREveMagFieldDuo | REveMagFieldDuo Interface to magnetic field with two different values depending on radius |
| ►CREveManager | |
| CChangeGuard | |
| CConn | |
| ►CLogger | |
| CHandler | |
| CMIR | |
| CRExceptionHandler | |
| CServerState | |
| CREveMCRecCrossRef | REveMCRecCrossRef Cross-reference of sim/rec data per particle (also used in VSD) |
| CREveMCTrack | REveMCTrack |
| CREvePathMarkT | Special-point on track: |
| CREvePointSelector | REvePointSelector TSelector for direct extraction of point-like data from a Tree |
| CREvePointSelectorConsumer | |
| CREvePointSet | |
| CREvePointSetArray | |
| CREvePointSetProjected | |
| ►CREvePolygonSetProjected | |
| CPolygon_t | |
| CREveProjectable | |
| CREveProjected | |
| ►CREveProjection | REveProjection Base for specific classes that implement non-linear projections |
| CPreScaleEntry_t | |
| CREveProjectionManager | REveProjectionManager Manager class for steering of projections and managing projected objects |
| CREveRecCascade | REveRecCascade |
| CREveRecKink | REveRecKink Reconstructed kink (also used in VSD) |
| CREveRecTrackT | REveRecTrack Template for reconstructed track (also used in VSD) |
| CREveRecV0 | REveRecV0 |
| CREveRefBackPtr | REveRefBackPtr reference-count with back pointers |
| CREveRefCnt | REveRefCnt REveRefCnt base-class (interface) |
| CREveRenderData | |
| CREveRGBAPalette | |
| CREveRhoZProjection | |
| CREveRPhiProjection | |
| CREveScalableStraightLineSet | |
| ►CREveScene | |
| CSceneCommand | |
| CREveSceneInfo | REveSceneInfo Scene in a viewer |
| CREveSceneList | |
| CREveSecondarySelectable | |
| ►CREveSelection | REveSelection Container for selected and highlighted elements |
| CDeviator | |
| CRecord | |
| CREveSelectorToEventList | REveSelectorToEventList TSelector that stores entry numbers of matching TTree entries into an event-list |
| CREveServerStatus | |
| CREveShape | |
| ►CREveStraightLineSet | REveStraightLineSet Set of straight lines with optional markers along the lines |
| CLine_t | |
| CMarker_t | |
| CREveStraightLineSetProjected | REveStraightLineSetProjected Projected copy of a REveStraightLineSet |
| CREveTableEntry | REveTableEntry |
| CREveTableHandle | REveTableHandle |
| CREveTableProxyBuilder | |
| CREveTableViewInfo | REveTableViewInfo |
| CREveText | |
| CREveTrack | REveTrack Track with given vertex, momentum and optional referece-points (path-marks) along its path |
| CREveTrackList | REveTrackList A list of tracks supporting change of common attributes and selection based on track parameters |
| CREveTrackListProjected | REveTrackListProjected Specialization of REveTrackList for holding REveTrackProjected objects |
| CREveTrackProjected | REveTrackProjected Projected copy of a REveTrack |
| ►CREveTrackPropagator | REveTrackPropagator Calculates path of a particle taking into account special path-marks and imposed boundaries |
| CHelix_t | |
| CREveTrans | |
| CREveUtil | REveUtil Standard utility functions for Reve |
| CREveVector2T | REveVector2T A two-vector template without TObject inheritance and virtual functions |
| CREveVector4T | REveVector4T A four-vector template without TObject inheritance and virtual functions |
| CREveVectorT | REveVectorT A three-vector template without TObject inheritance and virtual functions |
| CREveViewContext | |
| CREveViewer | REveViewer Reve representation of TGLViewer |
| CREveViewerList | REveViewerList List of Viewers providing common operations on REveViewer collections |
| CREveVSD | |
| CREveXZProjection | |
| CREveYZProjection | |
| CREveZXProjection | |
| CREveZYProjection | |
| 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 |
| CRBulk | Similar to RValue but manages an array of consecutive values |
| CRBulkSpec | |
| CRCheckResult | Used in the return value of the Check() method |
| CRColumnRepresentations | Some fields have multiple possible column representations, e.g |
| CRCreateObjectDeleter | |
| CRCreateObjectDeleter< void > | |
| CRDeleter | A functor to release the memory acquired by CreateValue (memory and constructor) |
| ►CRSchemaIteratorTemplate | Iterates over the sub tree 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 | Meta-data stored for every field of an ntuple |
| CRFieldZero | The container field for an ntuple model, which itself has no physical representation |
| ►CRFile | A ROOT file |
| COptions_t | Options for RFile construction |
| CRFilePtr | Points to an object that stores or reads objects in ROOT's binary format |
| ►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 |
| CRFitResult | |
| ►CRFrame | Holds an area where drawing on user coordinate-system can be performed |
| CRUserRanges | |
| CRZoomRequest | |
| CRFunction | |
| CRHist | Histogram class for histograms with DIMENSIONS dimensions, where each bin count is stored by a value of type PRECISION |
| CRHist1Drawable | |
| CRHist1StatBox | |
| CRHist2Drawable | |
| CRHist2StatBox | |
| CRHist3Drawable | |
| CRHist3StatBox | |
| CRHist< DIMENSIONS, PRECISION > | RHist with no STAT parameter uses RHistStatContent by default |
| CRHistBufferedFill | Buffers calls to Fill() |
| CRHistConcurrentFiller | Buffers a thread's Fill calls and submits them to the RHistConcurrentFillManager |
| CRHistConcurrentFillManager | Manages the synchronization of calls to FillN() |
| ►CRHistDataMomentUncert | For now do as RH1: calculate first (xw) and second (x^2w) moment |
| CRBinStat | No-op; this class does not provide per-bin statistics |
| CRHistDisplayItem | |
| CRHistDrawable | |
| ►CRHistDrawableBase | |
| CRReply | |
| CRRequest | |
| CRHistStatBox | Template class for statistic box for RHist class |
| ►CRHistStatBoxBase | Base class for histogram statistic box, provides graphics attributes and virtual method for fill statistic |
| CRReply | |
| CRRequest | |
| ►CRHistStatContent | Basic histogram statistics, keeping track of the bin content and the total number of calls to Fill() |
| CRBinStat | Modifying view on a RHistStatContent for a given bin |
| CRConstBinStat | Const view on a RHistStatContent for a given bin |
| ►CRHistStatRuntime | Interface implementing a pure virtual functions DoFill(), DoFillN() |
| CRBinStat | No-op; this class does not provide per-bin statistics |
| ►CRHistStatTotalSumOfSquaredWeights | Keeps track of the histogram's total sum of squared weights |
| CRBinStat | No-op; this class does not provide per-bin statistics |
| ►CRHistStatTotalSumOfWeights | Keeps track of the histogram's total sum of weights |
| CRBinStat | No-op; this class does not provide per-bin statistics |
| ►CRHistStatUncertainty | Histogram statistics to keep track of the Poisson uncertainty per bin |
| CRBinStat | Modifying view on a RHistStatUncertainty for a given bin |
| CRConstBinStat | Const view on a RHistStatUncertainty for a given bin |
| CRHistView | A view on a histogram, selecting a range on a subset of dimensions |
| CRHistViewOutOfRange | |
| CRIndirectDisplayItem | Extract (reference) only basic attributes from drawable, but not drawable itself |
| 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 |
| CRMenuItems | List of items for object context menu |
| CRNTupleChainProcessor | Processor specializiation for vertically concatenated RNTuples (chains) |
| ►CRNTupleClusterRange | Used to loop over entries of collections in a single cluster |
| CRIterator | |
| CRNTupleCollectionView | A view for a collection, that can itself generate new ntuple views for its nested fields |
| ►CRNTupleDescriptor | The on-storage meta-data of an ntuple |
| ►CRClusterDescriptorIterable | Used to loop over all the clusters of an ntuple (in unspecified order) |
| CRIterator | |
| ►CRClusterGroupDescriptorIterable | Used to loop over all the cluster groups of an ntuple (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 ntuple (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 |
| ►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 |
| CRNTupleFillContext | A context for filling entries (data) into clusters of an RNTuple |
| CRNTupleFillStatus | A status object after filling an entry |
| CRNTupleFormatter | Contains helper functions for RNTupleReader::PrintInfo() and RPrintSchemaVisitor::VisitField() |
| ►CRNTupleGlobalRange | Used to loop over indexes (entries or collections) between start and end |
| CRIterator | |
| ►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 specializiation for horizontally concatenated RNTuples (joins) |
| 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 ntuple |
| CNameWithDescription_t | A wrapper over a field name and an optional description; used in AddField() and RUpdater::AddField() |
| CRUpdater | A model is usually immutable after passing it to an RNTupleWriter |
| CRNTupleOpenSpec | Used to specify the underlying RNTuples in RNTupleProcessor |
| CRNTupleParallelWriter | A writer to fill an RNTuple from multiple contexts |
| ►CRNTupleProcessor | Interface for iterating over entries of RNTuples and vertically concatenated RNTuples (chains) |
| CRFieldContext | Manager for a field as part of the RNTupleProcessor |
| CRIterator | Iterator over the entries of an RNTuple, or vertical concatenation thereof |
| ►CRNTupleReader | An RNTuple that is used to read data from storage |
| CRIterator | |
| CRNTupleReadOptions | Common user-tunable settings for reading ntuples |
| CRNTupleSingleProcessor | Processor specializiation for processing a single RNTuple |
| CRNTupleView | An RNTupleView for a known type |
| CRNTupleView< void > | |
| CRNTupleViewBase | An RNTupleView provides read-only access to a single field of the ntuple |
| CRNTupleWriteOptions | Common user-tunable settings for storing ntuples |
| CRNTupleWriteOptionsDaos | DAOS-specific user-tunable settings for storing ntuples |
| 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 |
| CROnFrameDrawable | Base class for drawable which can be drawn on frame or on pad |
| ►CROptionalField | |
| CROptionalDeleter | |
| 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 |
| CRPairField | Template specializations for C++ std::pair |
| ►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 |
| 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 | |
| ►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 | |
| CRRealField | |
| ►CRRecordField | The field for an untyped record |
| CRRecordDeleter | |
| ►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 | |
| ►CRStyle | A set of defaults for graphics attributes, e.g |
| CBlock_t | |
| 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 | |
| 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 | |
| NHFitInterface | |
| 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 |
| NFoundationUtils | |
| ►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 | |
| 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 | |
| CRCallback | |
| CRColumnReadersInfo | This type aggregates some of the arguments passed to GetColumnReaders |
| CRColumnRegister | A binder for user-defined columns, variations and aliases |
| CRDefineReader | Column reader for defined columns |
| CRDefinesWithReaders | A helper type that keeps track of RDefine objects and their corresponding RDefineReaders |
| CRDisplayElement | Helper class to let Display print compact tabular representations of the events |
| CRDSColumnReader | Column reader type that deals with values read from RDataSources |
| CRemoveFirstParameterIf | type is TypeList if MustRemove is false, otherwise it is a TypeList with the first type removed |
| CRemoveFirstParameterIf< true, TypeList > | |
| CRemoveFirstTwoParametersIf | |
| CRemoveFirstTwoParametersIf< true, TypeList > | |
| CRJittedAction | |
| CRJittedVariation | A wrapper around a concrete RVariation, which forwards all calls to it RJittedVariation is a placeholder that is inserted in the computation graph in place of a RVariation that will be just-in-time compiled |
| CRMetaDataJson | |
| CRNewSampleFlag | |
| CRNewSampleNotifier | |
| 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 > | |
| CRRootDS | This class is unused and it has only been implemented as a proof of concept |
| CRStringCache | A Thread-safe cache for strings |
| CRTreeColumnReader | RTreeColumnReader specialization for TTree values read via TTreeReaderValues |
| CRTreeColumnReader< RVec< bool > > | RTreeColumnReader specialization for arrays of boolean values read via TTreeReaderArrays |
| CRTreeColumnReader< RVec< T > > | RTreeColumnReader specialization for TTree values read via TTreeReaderArrays |
| CRTreeOpaqueColumnReader | |
| CRVariation | |
| CRVariationBase | This type includes all parts of RVariation that do not depend on the callable signature |
| CRVariationReader | Column reader that reads the value for a specific column, variation and slot |
| CRVariationsWithReaders | |
| CRVariedAction | Just like an RAction, but it has N action helpers and N previous nodes (N is the number of variations) |
| CRVecDS | A RDataSource implementation which takes a collection of RVecs, which are able to adopt data from Numpy arrays |
| CTValueGetter | Helper class which keeps track for each slot where to get the entry |
| CValueType | |
| CValueType< ROOT::VecOps::RVec< T >, false > | |
| CValueType< T, false > | |
| ►NRootCling | |
| CDriverConfig | |
| CTROOTSYSSetter | |
| ►NSHA256 | |
| Csha256_t | |
| ►NTDS | |
| CTPointerHolder | Mother class of TTypedPointerHolder |
| CTTypedPointerHolder | Class to wrap a pointer and delete the memory associated to it correctly |
| ►NTreeUtils | Namespace hosting functions and classes to retrieve tree information for internal use |
| CRNoCleanupNotifier | |
| CRNoCleanupNotifierHelper | |
| ►NTThreadedObjectUtils | |
| CCloner | Return a copy of the object or a "Clone" if the copy constructor is not implemented |
| CCloner< T, false > | |
| CDetacher | |
| CDetacher< T, true > | |
| CDirCreator | |
| CDirCreator< T, true > | |
| ►NVecOps | |
| CIsRVec | |
| CIsRVec< ROOT::VecOps::RVec< T > > | |
| CRVecInlineStorageSize | The size of the inline storage of an RVec |
| CSmallVectorAlignmentAndSize | Used to figure out the offset of the first element of an RVec |
| CSmallVectorBase | This is all the stuff common to all SmallVectors |
| CSmallVectorStorage | Storage for the SmallVector elements |
| CSmallVectorStorage< T, 0 > | We need the storage to be properly aligned even for small-size of 0 so that the pointer math in SmallVectorTemplateCommon::getFirstEl() is well-defined |
| CSmallVectorTemplateBase | SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put method implementations that are designed to work with non-trivial T's |
| CSmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put method implementations that are designed to work with trivially copyable T's |
| CSmallVectorTemplateCommon | This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD |
| CClassDefGenerateInitInstanceLocalInjector | |
| ►CDictSelectionReader | |
| CTemplateInfo | |
| CGetFunctorType | Internal class used by TF1 for obtaining the type from a functor out of the set of valid operator() signatures |
| CGetFunctorType< T(F::*)(const T *, const double *) const > | |
| CGetFunctorType< T(F::*)(const T *, const double *)> | |
| CGetFunctorType< T(F::*)(T *, double *) const > | |
| CGetFunctorType< T(F::*)(T *, double *)> | |
| CInterpreterMutexRegistrationRAII | |
| ►CParsingStateRAII | RAII used to store Parser, Sema, Preprocessor state for recursive parsing |
| CSemaExprCleanupsRAII | |
| CSemaParsingInitForAutoVarsRAII | |
| CRBaseType | |
| CRCast | |
| CRCast< T, false, false > | |
| CRCast< T, false, true > | |
| ►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 | |
| CRHashMap | |
| ►CRIoUring | |
| CRReadEvent | Basic read event composed of IO data and a target file descriptor |
| ►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 stack of N indexes (0 to size - 1) |
| CRSlotStackRAII | A RAII object to pop and push slot numbers from a RSlotStack object |
| CRStl | |
| CRTaskArenaWrapper | Wrapper for tbb::task_arena |
| 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 |
| CTTreeReaderValueBase | Base class of TTreeReaderValue |
| CTTreeView | |
| CTVirtualCollectionReader | |
| CTypedIter | |
| ►CUniqueLockRecurseCount | |
| CLocalCounts | |
| CUpdate | |
| ►NMacOSX | |
| ►NDetails | |
| CCocoaPrivate | |
| ►CFontCache | |
| CFontList | |
| CMacOSXSystem | |
| NOpenGL | |
| ►NUtil | |
| CAutoreleasePool | |
| CCFScopeGuard | |
| CCFStrongReference | |
| CNSScopeGuard | |
| CNSStrongReference | |
| CScopedArray | |
| ►NX11 | |
| NDetail | |
| CClearArea | |
| ►CColorParser | |
| CRGB_t | |
| CCommand | |
| ►CCommandBuffer | |
| CWidgetRect | |
| CCopyArea | |
| CDeletePixmap | |
| CDrawBoxXor | |
| CDrawLine | |
| CDrawLineXor | |
| CDrawRectangle | |
| CDrawSegments | |
| CDrawString | |
| CEventTranslator | |
| CFillPolygon | |
| CFillRectangle | |
| CPoint | |
| CRectangle | |
| CUpdateWindow | |
| CXLFDName | |
| ►NMath | |
| NBlas | |
| NBrentMethods | |
| NCephes | |
| NChebyshev | Template recursive functions for defining evaluation of Chebyshev polynomials T_n(x) and the series S(x) = Sum_i c_i* T_i(x) |
| ►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 | |
| NGenAlgoOptUtil | |
| NGenVector | |
| ►NGenVector_detail | |
| ►CBitReproducible | |
| CDB8 | |
| CBitReproducibleException | |
| NGSLRootHelper | Helper functions to test convergence of Root-Finding algorithms |
| NGSLSimAn | |
| ►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 |
| NIntegMultiDim | |
| NIntegOneDim | |
| ►NIntegOptionsUtil | |
| COptionTrait | |
| COptionTrait< IntegratorMultiDimOptions > | |
| COptionTrait< IntegratorOneDimOptions > | |
| NIntegration | |
| NIntegrationMultiDim | |
| NIntegrationOneDim | |
| NInternal | |
| Ninternal | |
| NInterpolation | |
| NMCIntegration | |
| NMinim | |
| NMinim1D | |
| ►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 > | |
| NSampler | |
| NUtil | Namespace defining Utility functions needed by mathcore |
| NVectorUtil | Global Helper functions for generic Vector classes |
| 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 |
| 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 withtout derivatives for multi-dimensional minimization algorithm |
| CGSLMultiMinDerivFunctionWrapper | Wrapper for a multi-dimensional function with derivatives used in GSL multidim minimization algorithm |
| CGSLMultiMinFunctionAdapter | Class for adapting any multi-dimension C++ functor class to C function pointers used by GSL MultiMin algorithms |
| CGSLMultiMinFunctionWrapper | Wrapper to a multi-dim function withtout derivatives for multi-dimensional minimization algorithm |
| CGSLMultiMinimizer | GSLMultiMinimizer class , for minimizing multi-dimensional function using derivatives |
| CGSLMultiRootBaseSolver | GSLMultiRootBaseSolver, internal class for implementing GSL multi-root finders This is the base class for GSLMultiRootSolver (solver not using derivatives) and GSLMUltiRootDerivSolver (solver using derivatives) |
| CGSLMultiRootDerivFunctionWrapper | Wrapper to a multi-dim function with derivatives for multi roots algorithm |
| CGSLMultiRootDerivSolver | GSLMultiRootDerivSolver, internal class for implementing GSL multi-root finders using derivatives |
| CGSLMultiRootFinder | Class for Multidimensional root finding algorithms bassed on GSL |
| CGSLMultiRootFunctionAdapter | Class for adapting a C++ functor class to C function pointers used by GSL MultiRoot Algorithm The templated C++ function class must implement: |
| CGSLMultiRootFunctionWrapper | Wrapper to a multi-dim function without derivatives for multi roots algorithm |
| CGSLMultiRootSolver | GSLMultiRootSolver, internal class for implementing GSL multi-root finders not using derivatives |
| CGSLNLSMinimizer | GSLNLSMinimizer class for Non Linear Least Square fitting It Uses the Levemberg-Marquardt algorithm from GSL Non Linear Least Square fitting |
| CGSLPlainIntegrationWorkspace | |
| CGSLQRngNiederreiter2 | Niederreiter generator gsl_qrng_niederreiter_2 from here |
| CGSLQRngSobol | Sobol generator gsl_qrng_sobol from here |
| CGSLQRngWrapper | GSLQRngWrapper class to wrap gsl_qrng structure |
| CGSLQuasiRandomEngine | GSLQuasiRandomEngine Base class for all GSL quasi random engines, normally user instantiate the derived classes which creates internally the generator and uses the class ROOT::Math::QuasiRandom |
| CGSLRandomEngine | GSLRandomEngine Base class for all GSL random engines, normally user instantiate the derived classes which creates internally the generator |
| CGSLRngCMRG | Combined multiple recursive generator (L'Ecuyer) see here |
| CGSLRngGFSR4 | Lagged Fibonacci generator by Ziff see here |
| CGSLRngMinStd | MINSTD generator (Park and Miller) see here |
| CGSLRngMixMax | MixMax generator based on ROOT::Math::MixMaxEngine of N=240 |
| CGSLRngMRG | 5-th order multiple recursive generator (L'Ecuyer, Blouin and Coutre) see here |
| CGSLRngMT | Mersenne-Twister generator gsl_rng_mt19937 from here |
| CGSLRngRand | BSD rand() generator gsl_rmg_rand from here |
| CGSLRngRanLux | Old Ranlux generator (James, Luscher) (default luxury level, p = 223) (This is eequivalent to TRandom1 with default luxury level) see here |
| CGSLRngRanLuxD1 | Double precision (48 bits) version of Second generation of Ranlux generator with luxury level of 1 (It throws away 202 value for every 12 used) see here |
| CGSLRngRanLuxD2 | Double precision (48 bits) version of Second generation of Ranlux generator with luxury level of 2 (It throws away 397 value for every 12 used) see here |
| CGSLRngRanLuxS1 | Second generation of Ranlux generator for single precision with luxury level of 1 (It throws away 202 values for every 12 used) see here |
| CGSLRngRanLuxS2 | Second generation of Ranlux generator for Single precision with luxury level of 2 (It throws away 397 value for every 12 used) see here |
| CGSLRngRanMar | RANMAR generator see here |
| CGSLRngROOTWrapper | Class for wrapping ROOT Engines in gsl_rng types which can be used as extra GSL random number generators For this we need to implement functions which will be called by gsl_rng |
| CGSLRngTaus | Tausworthe generator by L'Ecuyer see here |
| CGSLRngWrapper | GSLRngWrapper class to wrap gsl_rng structure |
| CGSLRootFdFSolver | Root-Finder with derivatives implementation class using GSL |
| CGSLRootFinder | Base class for GSL Root-Finding algorithms for one dimensional functions which do not use function derivatives |
| CGSLRootFinderDeriv | Base class for GSL Root-Finding algorithms for one dimensional functions which use function derivatives |
| CGSLRootFSolver | Root-Finder implementation class using GSL |
| CGSLSimAnFunc | GSLSimAnFunc class description |
| CGSLSimAnMinimizer | GSLSimAnMinimizer class for minimization using simulated annealing using the algorithm from GSL |
| CGSLSimAnnealing | GSLSimAnnealing class for performing a simulated annealing search of a multidimensional function |
| CGSLSimAnParams | Structure holding the simulated annealing parameters |
| CGSLVegasIntegrationWorkspace | Workspace for VEGAS |
| CIBaseFunctionMultiDimTempl | Documentation for the abstract class IBaseFunctionMultiDim |
| CIBaseFunctionOneDim | Interface (abstract class) for generic functions objects of one-dimension Provides a method to evaluate the function given a value (simple double) by implementing operator() (const double ) |
| CIBaseParam | Documentation for the abstract class IBaseParam |
| CIGradientFunctionMultiDimTempl | Interface (abstract class) for multi-dimensional functions providing a gradient calculation |
| CIGradientFunctionOneDim | Interface (abstract class) for one-dimensional functions providing a gradient calculation |
| CIGradientMultiDimTempl | |
| CIMinimizer1D | Interface class for numerical methods for one-dimensional minimization |
| CIntegrandTransform | Auxiliary inner class for mapping infinite and semi-infinite integrals |
| CIntegratorMultiDim | User class for performing multidimensional integration |
| CIntegratorMultiDimOptions | Numerical multi dimensional integration options |
| CIntegratorOneDim | User Class for performing numerical integration of a function in one dimension |
| CIntegratorOneDimOptions | Numerical one dimensional integration options |
| CInterpolator | Class for performing function interpolation of points |
| CInverter | Matrix Inverter class Class to specialize calls to Dinv |
| CInverter< 0 > | Inverter<0> |
| CInverter< 1 > | 1x1 matrix inversion \(a_{11} \to 1/a_{11}\) |
| CInverter< 2 > | 2x2 matrix inversion using Cramers rule |
| CIOptions | Generic interface for defining configuration options of a numerical algorithm |
| CIParametricFunctionMultiDimTempl | IParamFunction interface (abstract class) describing multi-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionMultiDim and ROOT::Math::IBaseParam |
| CIParametricFunctionOneDim | Specialized IParamFunction interface (abstract class) for one-dimensional parametric functions It is a derived class from ROOT::Math::IBaseFunctionOneDim and ROOT::Math::IBaseParam |
| CIParametricGradFunctionMultiDimTempl | Interface (abstract class) for parametric gradient multi-dimensional functions providing in addition to function evaluation with respect to the coordinates also the gradient with respect to the parameters, via the method ParameterGradient |
| CIParametricGradFunctionOneDim | Interface (abstract class) for parametric one-dimensional gradient functions providing in addition to function evaluation with respect the coordinates also the gradient with respect to the parameters, via the method ParameterGradient |
| CIRootFinderMethod | Interface for finding function roots of one-dimensional functions |
| CKahanSum | The Kahan summation is a compensated summation algorithm, which significantly reduces numerical errors when adding a sequence of finite-precision floating point numbers |
| ►CKDTree | |
| CBaseNode | |
| CBinNode | |
| CComparePoints | |
| CCut | |
| CHeadNode | |
| Citerator | |
| CSplitNode | |
| CTerminalNode | |
| CLCGEngine | |
| CLocalCoordinateSystemTag | Tag for identifying vectors based on a local coordinate system |
| CLorentzRotation | Lorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix |
| CLorentzVector | Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part |
| CLSResidualFunc | LSResidualFunc class description |
| CMathMoreLib | |
| CMatRepStd | Expression wrapper class for Matrix objects |
| CMatRepSym | MatRepSym Matrix storage representation for a symmetric matrix of dimension NxN This class is a template on the contained type and on the symmetric matrix size, N |
| CMatrixMulOp | Class for Matrix-Matrix multiplication |
| CMersenneTwisterEngine | Random number generator class based on M |
| Cmeta_col_dot | |
| Cmeta_col_dot< 0 > | |
| Cmeta_dot | |
| Cmeta_dot< 0 > | |
| Cmeta_mag | |
| Cmeta_mag< 0 > | |
| Cmeta_matrix_dot | |
| Cmeta_matrix_dot< 0 > | |
| Cmeta_row_dot | |
| Cmeta_row_dot< 0 > | |
| CMinimizer | Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2, Minuit, GSL, etc..) in ROOT |
| CMinimizerOptions | Minimizer options |
| CMinimizerVariableTransformation | Base class for MinimizerVariable transformations defining the functions to deal with bounded parameters |
| CMinimTransformFunction | MinimTransformFunction class to perform a transformations on the variables to deal with fixed or limited variables (support both double and single bounds) The class manages the passed function pointer |
| CMinimTransformVariable | MinimTransformVariable class Contains meta information of the variables such as bounds, fix flags and deals with transformation of the variable The class does not contain the values and the step size (error) of the variable This is an internal class used by the MinimTransformFunction class |
| CMinOp | Subtraction Operation Class |
| CMinus | Unary Minus Operation Class |
| CMinusEquals | Evaluate the expression performing a -= operation Need to check whether creating a temporary object with the expression result (like in op: A -= A * B ) |
| CMinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > > | Specialization for symmetrix -= general : NOT Allowed operation |
| CMinusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > > | Specialization for symmetric matrices |
| CMiserParameters | Structure collecting parameters for MISER multidimensional integration |
| CMixMaxEngine | MixMaxEngine is a wrapper class for the MIXMAX Random number generator |
| CMixMaxEngineImpl | |
| CMixMaxEngineImpl< ROOT_MM_N > | |
| CMulOp | Multiplication (element-wise) Operation Class |
| CMultiDimParamFunctionAdapter | MultiDimParamFunctionAdapter class to wrap a one-dimensional parametric function in a multi dimensional parametric function interface This is used typically in fitting where internally the function is stored as multidimensional |
| CMultiDimParamGradFunctionAdapter | MultiDimParamGradFunctionAdapter class to wrap a one-dimensional parametric gradient function in a multi dimensional parametric gradient function interface This is used typically in fitting where internally the function is stored as multidimensional |
| CMultiGenFunctionFitness | |
| CMultiNumGradFunction | MultiNumGradFunction class to wrap a normal function in a gradient function using numerical gradient calculation provided by the class Derivator (based on GSL numerical derivation) |
| CMultPolicy | Matrix-matrix multiplication policy |
| CNullTypeFunc1D | |
| COneDimMultiFunctionAdapter | OneDimMultiFunctionAdapter class to wrap a multidimensional function in one dimensional one |
| COneDimParamFunctionAdapter | OneDimParamFunctionAdapter class to wrap a multi-dim parametric function in one dimensional one |
| CParamFunction | Base template class for all Parametric Functions |
| CParamFunctionBase | Class defining the signature for multi-dim parametric functions |
| ►CParamFunctorHandler | ParamFunctor Handler class is responsible for wrapping any other functor and pointer to free C functions |
| CFuncEvaluator | |
| CFuncEvaluator< F *, T > | |
| CFuncEvaluator< F *const, T > | |
| CParamFunctorTempl | Param Functor class for Multidimensional functions |
| ►CParamMemFunHandler | ParamFunctor Handler to Wrap pointers to member functions |
| CMemFuncEvaluator | |
| CPDFIntegral | |
| CPlaceExpr | |
| CPlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > > | |
| CPlaceExpr< T, D1, D2, D3, D4, A, MatRepSym< T, D1 >, MatRepSym< T, D3 > > | |
| CPlaceMatrix | Structure to deal when a submatrix is placed in a matrix |
| CPlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > > | |
| CPlaceMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > > | |
| CPlainParameters | |
| CPlusEquals | Evaluate the expression performing a += operation Need to check whether creating a temporary object with the expression result (like in op: A += A * B ) |
| CPlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepStd< T, D1, D2 > > | Specialization for symmetrix += general : NOT Allowed operation |
| CPlusEquals< T, D1, D2, A, MatRepSym< T, D1 >, MatRepSym< T, D1 > > | Specialization for symmetric matrices Evaluate the expression performing a += operation for symmetric matrices Need to have a separate functions to avoid to modify two times the off-diagonal elements (i.e applying two times the expression) Need to check whether creating a temporary object with the expression result (like in op: A += A * B ) |
| CPolar2D | Class describing a polar 2D coordinate system based on r and phi Phi is restricted to be in the range [-PI,PI) |
| CPolar3D | Class describing a polar coordinate system based on r, theta and phi Phi is restricted to be in the range [-PI,PI) |
| CPolynomial | Parametric Function class describing polynomials of order n |
| CPositionVector2D | Class describing a generic position vector (point) in 2 dimensions |
| CPositionVector3D | Class describing a generic position vector (point) in 3 dimensions |
| CPtEtaPhiE4D | Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and E (or rho, phi, eta , T) The metric used is (-,-,-,+) |
| CPtEtaPhiM4D | Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+) |
| CPxPyPzE4D | Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors stored as (Px, Py, Pz, E) |
| CPxPyPzM4D | Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M) |
| CQuasiRandom | User class for MathMore random numbers template on the Engine type |
| CQuaternion | Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k) |
| CRandom | Documentation for the Random class |
| CRandomFunctions | |
| CRandomFunctions< EngineType, ROOT::Math::GSLRandomEngine > | Specialized implementation of the Random functions based on the GSL library |
| CRandomFunctionsImpl | Definition of the generic implementation class for the RandomFunctions |
| CRandomFunctionsImpl< TRandomEngine > | Implementation class for the RandomFunction for all the engined that derives from TRandomEngine class, which defines an interface which has TRandomEngine::Rndm() In this way we can have a common implementation for the RandomFunctions |
| CRanluxppCompatEngineGslRanlxd | Compatibility engine for gsl_rng_ranlxd* from the GNU Scientific Library |
| CRanluxppCompatEngineGslRanlxs | Compatibility engine for gsl_rng_ranlxs* from the GNU Scientific Library |
| CRanluxppCompatEngineJames | |
| CRanluxppCompatEngineLuescherImpl | |
| CRanluxppCompatEngineLuescherRanlxd | Compatibility engine for Lüscher's ranlxd implementation written in C |
| CRanluxppCompatEngineLuescherRanlxs | Compatibility engine for Lüscher's ranlxs implementation written in C |
| CRanluxppCompatEngineStdRanlux24 | Compatibility engine for std::ranlux24 from the C++ standard |
| CRanluxppCompatEngineStdRanlux48 | Compatibility engine for std::ranlux48 from the C++ standard |
| CRanluxppEngine | Implementation of the RANLUX++ generator |
| CRanluxppEngineImpl | |
| CRetrieveMatrix | Structure for getting sub matrices We have different cases according to the matrix representations |
| CRetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepStd< T, D3, D4 > > | |
| CRetrieveMatrix< T, D1, D2, D3, D4, MatRepSym< T, D1 >, MatRepSym< T, D3 > > | |
| CRichardsonDerivator | User class for calculating the derivatives of a function |
| CRMinimizer | RMinimizer class |
| CRootFinder | User Class to find the Root of one dimensional functions |
| CRotation3D | Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix |
| CRotationX | Rotation class representing a 3D rotation about the X axis by the angle of rotation |
| CRotationY | Rotation class representing a 3D rotation about the Y axis by the angle of rotation |
| CRotationZ | Rotation class representing a 3D rotation about the Z axis by the angle of rotation |
| CRotationZYX | Rotation class with the (3D) rotation represented by angles describing first a rotation of an angle phi (yaw) about the Z axis, followed by a rotation of an angle theta (pitch) about the Y axis, followed by a third rotation of an angle psi (roll) about the X axis |
| CRowOffsets | Static structure to keep the conversion from (i,j) to offsets in the storage data for a symmetric matrix |
| CSDeterminant | Dsfact |
| CSinVariableTransformation | Sin Transformation class for dealing with double bounded variables |
| CSInverter | Dsinv |
| CSkipFunction | |
| CSkipFunction< 0 > | |
| ►CSMatrix | SMatrix: a generic fixed size D1 x D2 Matrix class |
| CSMatrixRow | |
| CSMatrixRow_const | |
| CSMatrixIdentity | |
| CSMatrixNoInit | |
| CSqr | Unary Square Operation Class |
| CSqrt | Unary Square Root Operation Class |
| CSqrtLowVariableTransformation | Sqrt Transformation class for dealing with lower bounded variables |
| CSqrtUpVariableTransformation | Sqrt Transformation class for dealing with upper bounded variables |
| CStdEngine | Class to wrap engines from the C++ standard random library in the ROOT Random interface |
| CStdEngineType | |
| CStdRandomEngine | |
| CSVector | SVector: a generic fixed size Vector class |
| CTDataPoint | |
| CTDataPointN | |
| CTensorMulOp | Class for Tensor Multiplication (outer product) of two vectors giving a matrix |
| CTRandomEngine | |
| CTransposeOp | Class for Transpose Operations |
| CTranspPolicy | Matrix transpose policy |
| CTranspPolicy< T, D1, D2, MatRepSym< T, D1 > > | |
| CUnaryOp | UnaryOperation class A class representing unary operators in the parse tree |
| CVavilov | Base class describing a Vavilov distribution |
| CVavilovAccurate | Class describing a Vavilov distribution |
| CVavilovAccurateCdf | Class describing the Vavilov cdf |
| CVavilovAccuratePdf | Class describing the Vavilov pdf |
| CVavilovAccurateQuantile | Class describing the Vavilov quantile function |
| CVavilovFast | Class describing a Vavilov distribution |
| CVecExpr | Expression wrapper class for Vector objects |
| CVectorMatrixColOp | Class for Vector-Matrix multiplication |
| CVectorMatrixRowOp | |
| CVegasParameters | Structures collecting parameters for VEGAS multidimensional integration For implementation of default parameters see file mathmore/src/GSLMCIntegrationWorkspace.h |
| CVirtualIntegrator | Abstract class for all numerical integration methods (1D and multi-dim) Interface defining the common methods for the numerical integrator classes of one and multi dimensions The derived class VirtualIntegratorOneDim defines the methods for one-dimensional integration |
| CVirtualIntegratorMultiDim | Interface (abstract) class for multi numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLMCIntegrator |
| CVirtualIntegratorOneDim | Interface (abstract) class for 1D numerical integration It must be implemented by the concrete Integrator classes like ROOT::Math::GSLIntegrator |
| CWrappedFunction | Template class to wrap any C++ callable object which takes one argument i.e |
| CWrappedMemFunction | Template class to wrap any member function of a class taking a double and returning a double in a 1D function interface For example, if you have a class like: struct X { double Eval(double x); }; you can wrapped in the following way: WrappedMemFunction<X, double ( X::* ) (double) > f; |
| CWrappedMemMultiFunction | |
| CWrappedMultiFunction | Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-dimensional function interface |
| CWrappedMultiTF1Templ | Class to Wrap a ROOT Function class (like TF1) in a IParamMultiFunction interface of multi-dimensions to be used in the ROOT::Math numerical algorithm |
| CWrappedParamFunction | WrappedParamFunction class to wrap any multi-dimensional function object implementing the operator()(const double * x, const double * p) in an interface-like IParamFunction with a vector storing and caching internally the parameter values |
| CWrappedParamFunctionGen | WrappedParamGenFunction class to wrap any multi-dimensional function implementing the operator()(const double * ) in an interface-like IParamFunction, by fixing some of the variables and define them as parameters |
| CWrappedTF1 | Class to Wrap a ROOT Function class (like TF1) in a IParamFunction interface of one dimensions to be used in the ROOT::Math numerical algorithms The wrapper does not own bby default the TF1 pointer, so it assumes it exists during the wrapper lifetime |
| NMathMore | |
| ►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 |
| NMinuit | |
| ►NMinuit2 | |
| CABObj | |
| CABObj< sym, LASymMatrix, double > | |
| CABObj< vec, LAVector, double > | |
| CABProd | |
| CABSum | |
| CAlgebraicProdType | |
| CAlgebraicProdType< gen, gen > | |
| CAlgebraicProdType< gen, sym > | |
| CAlgebraicProdType< gen, vec > | |
| CAlgebraicProdType< sym, gen > | |
| CAlgebraicProdType< sym, sym > | |
| CAlgebraicProdType< sym, vec > | |
| CAlgebraicProdType< T, T > | |
| CAlgebraicProdType< vec, gen > | |
| CAlgebraicProdType< vec, sym > | |
| CAlgebraicSumType | |
| CAlgebraicSumType< gen, vec > | |
| CAlgebraicSumType< sym, vec > | |
| CAlgebraicSumType< T, T > | |
| CAlgebraicSumType< vec, gen > | |
| CAlgebraicSumType< vec, sym > | |
| 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) |
| 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 | |
| Cgen | |
| CGenericFunction | Class from which all the other classes, representing functions, inherit |
| CGradientCalculator | Interface class for gradient calculators |
| CHessianGradientCalculator | HessianGradientCalculator: class to calculate Gradient for Hessian |
| CInitialGradientCalculator | Class to calculate an initial estimate of the gradient |
| CLASquareMatrix | |
| CLASymMatrix | Class describing a symmetric matrix of size n |
| CLAVector | |
| CMatrixInverse | |
| CMatrixInverse< vec, M, T > | |
| CMinimumBuilder | |
| ►CMinimumError | MinimumError keeps the inv |
| CData | |
| CMinimumErrorUpdator | |
| ►CMinimumParameters | |
| CData | |
| ►CMinimumSeed | |
| CData | |
| CMinimumSeedGenerator | Base class for seed generators (starting values); the seed generator prepares initial starting values from the input (MnUserParameterState) for the minimization; |
| ►CMinimumState | MinimumState keeps the information (position, Gradient, 2nd deriv, etc) after one minimization step (usually in MinimumBuilder) |
| CData | |
| CMinosError | Class holding the result of Minos (lower and upper values) for a specific parameter |
| CMinuit2Minimizer | Minuit2Minimizer class implementing the ROOT::Math::Minimizer interface for Minuit2 minimization algorithm |
| CMinuitParameter | Class for the individual Minuit Parameter with Name and number; contains the input numbers for the minimization or the output result from minimization; possible interactions: Fix/release, set/remove limits, set Value/error; |
| CMnApplication | Application interface class for minimizers (migrad, simplex, Minimize, Scan) User normally instantiates the derived class like ROOT::Minuit2::MnMigrad for using Migrad for minimization |
| CMnContours | API class for Contours Error analysis (2-dim errors); minimization has to be done before and Minimum must be valid; possibility to ask only for the points or the points and associated Minos errors; |
| CMnCovarianceSqueeze | Class to reduce the covariance matrix when a parameter is fixed by removing the corresponding row and index |
| ►CMnCross | |
| CCrossFcnLimit | |
| CCrossNewMin | |
| CCrossParLimit | |
| CMnEigen | API class for calculating the eigenvalues of symmetric matrix |
| CMnFcn | Wrapper class to FCNBase interface used internally by Minuit |
| CMnFumiliMinimize | API class for minimization using Fumili technology; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc.; also used by MnMinos and MnContours; |
| CMnFunctionCross | MnFunctionCross |
| CMnGlobalCorrelationCoeff | Class for global correlation coefficient |
| CMnHesse | API class for calculating the numerical covariance matrix (== 2x Inverse Hessian == 2x Inverse 2nd derivative); can be used by the user or Minuit itself |
| CMnLineSearch | Implements a 1-dimensional minimization along a given direction (i.e |
| CMnMachinePrecision | Sets the relative floating point (double) arithmetic precision |
| CMnMigrad | API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc.; also used by MnMinos and MnContours; |
| CMnMinimize | API class for minimization using Variable Metric technology ("MIGRAD"); allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc.; also used by MnMinos and MnContours; |
| CMnMinos | API class for Minos Error analysis (asymmetric errors); minimization has to be done before and Minimum must be valid; possibility to ask only for one side of the Minos Error; |
| CMnParabola | This class defines a parabola of the form a*x*x + b*x + c |
| CMnParabolaFactory | |
| CMnParabolaPoint | A point of a parabola |
| CMnParameterScan | Scans the values of FCN as a function of one Parameter and retains the best function and Parameter values found |
| CMnParStr | |
| CMnPlot | MnPlot produces a text-screen graphical output of (x,y) points, e.g |
| CMnPosDef | Force the covariance matrix to be positive defined by adding extra terms in the diagonal |
| ►CMnPrint | |
| COneline | |
| CMnRefCountedPointer | |
| CMnReferenceCounter | |
| CMnScan | API class for minimization using a scan method to find the minimum; allows for user interaction: set/change parameters, do minimization, change parameters, re-do minimization etc.; |
| CMnSeedGenerator | Concrete implementation of the MinimumSeedGenerator interface; used within ModularFunctionMinimizer; |
| CMnSimplex | API class for minimization using the Simplex method, which does not need and use the derivatives of the function, but only function values |
| CMnStrategy | API class for defining four levels of strategies: low (0), medium (1), high (2), very high (>=3); acts on: Migrad (behavioural), Minos (lowers strategy by 1 for Minos-own minimization), Hesse (iterations), Numerical2PDerivative (iterations) |
| CMnTiny | |
| CMnTraceObject | |
| CMnUserCovariance | Class containing the covariance matrix data represented as a vector of size n*(n+1)/2 Used to hide internal matrix representation to user |
| CMnUserFcn | Wrapper used by Minuit of FCN interface containing a reference to the transformation object |
| 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 |
| CMnVectorTransform | |
| 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 |
| CRResultHandle | A type-erased version of RResultPtr and RResultMap |
| CRResultPtr | Smart pointer for the return type of actions |
| CRSampleInfo | This type represents a sample identifier, to be used in conjunction with RDataFrame features such as DefinePerSample() and per-sample callbacks |
| CRSnapshotOptions | A collection of options to steer the creation of the dataset on file |
| ►CRSqliteDS | RSqliteDS is an RDF data source implementation for SQL result sets from sqlite3 files |
| CValue_t | Used to hold a single "cell" of the SELECT query's result table. Can be changed to std::variant once available |
| CRTrivialDS | A simple data-source implementation, for demo purposes |
| CRVariationsDescription | A descriptor for the systematic variations known to a given RDataFrame node |
| CTCutInfo | |
| CTH1DModel | A struct which stores the parameters of a TH1D |
| CTH2DModel | A struct which stores the parameters of a TH2D |
| CTH3DModel | A struct which stores the parameters of a TH3D |
| CTHnDModel | A struct which stores the parameters of a THnD |
| CTProfile1DModel | A struct which stores the parameters of a TProfile |
| CTProfile2DModel | A struct which stores the parameters of a TProfile2D |
| CVerifyValidColumnType | Helper to determine if a given Column is a supported type |
| ►NTestSupport | |
| ►CCheckDiagsRAII | Install a ROOT diagnostic handler to analyse diagnostics |
| CDiag_t | |
| CFilterDiagsRAII | Allows a user function to catch and filter/analyse ROOT and cling diagnostics, e.g |
| CForbidDiagnostics | Error handler for gtests that generates failures for every received diagnostic > kInfo when this file is linked to |
| ►NTF1Helper | |
| CTGradientParFunction | Function class representing the derivative with respect a parameter of a given TF1 |
| ►NTMetaUtils | |
| NAST2SourceTools | |
| NpropNames | |
| ►CAnnotatedRecordDecl | |
| CCompareByName | |
| CRConstructorType | |
| CTClingLookupHelper | |
| CTNormalizedCtxt | |
| CTNormalizedCtxtImpl | |
| ►NTreeUtils | |
| CInvalidTupleType | |
| CInvalidTupleType< TNtuple > | |
| CInvalidTupleType< TNtupleD > | |
| CRFriendInfo | Information about friend trees of a certain TTree or TChain object |
| NTThreadedObjectUtils | |
| ►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 | |
| NTFastFun | |
| 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 | |
| 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 | |
| ►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 | |
| 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 |
| ►CRError | Captures diagnostics related to a ROOT runtime error |
| CRLocation | |
| CRException | Base class for all ROOT issued exceptions |
| 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 | |
| CRNTuple | Representation of an RNTuple data set in a ROOT file |
| CRNTupleCardinality | Helper types to present an offset column as array of collection sizes |
| CROpaqueTaskArena | |
| CRQt5CreatorReg | |
| ►CRQt5WebDisplayHandle | |
| CQt5Creator | |
| CRQt6CreatorReg | |
| ►CRQt6WebDisplayHandle | |
| CQt6Creator | |
| CRRangeCast | Wraps any collection that can be used in range-based loops and applies static_cast<T> or dynamic_cast<T> to each element |
| 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> |
| CRTreeDrawInvokeTimer | |
| CRTreeDrawMonitoring | |
| ►CRTreeViewer | Web-based ROOT TTree viewer |
| CRBranchInfo | |
| CRConfig | |
| 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 | |
| Nroot-argparse | |
| Nrootcling-argparse | |
| Nrootlogon | Module for the Python tutorials |
| ►NROOTwriter | |
| CROOTwriter | |
| NSelectionRulesUtils | |
| Nsqlio | |
| ►NTClassEdit | |
| CFunctionSplitInfo | Result of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters) |
| CTInterpreterLookupHelper | |
| CTSplitType | |
| NTessellated | Typedefs used by the geometry group |
| NTGeant4Unit | |
| NTGeoUnit | |
| ►NTMath | TMath |
| NROOTDict | |
| CLimits | |
| NTMatrixTAutoloadOps | |
| NTMatrixTCramerInv | |
| NTMatrixTSymCramerInv | |
| ►NTMVA | Create variable transformations |
| ►NDNN | |
| NBlas | |
| ►NCNN | |
| CTCNNDescriptors | |
| CTCNNWorkspace | |
| CTConvLayer | |
| CTConvParams | |
| CTMaxPoolLayer | Generic Max Pooling Layer class |
| NCuda | |
| ►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 | |
| NBLAS | |
| ►NPyKeras | |
| NINTERNAL | |
| ►NPyTorch | |
| NINTERNAL | |
| NUTILITY | |
| 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 | |
| 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_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_Pool | |
| CROperator_Range | |
| CROperator_Reduce | |
| CROperator_Relu | |
| CROperator_Reshape | |
| CROperator_RNN | Recurrent Neural Network operator |
| CROperator_Selu | |
| CROperator_Shape | |
| CROperator_Sigmoid | |
| CROperator_Slice | |
| CROperator_Softmax | |
| CROperator_Split | |
| CROperator_Swish | |
| CROperator_Tanh | |
| CROperator_Tile | |
| CROperator_TopK | |
| CROperator_Transpose | |
| CTensorInfo | |
| CTensorType | |
| CTensorType< double > | |
| CTensorType< float > | |
| CTensorType< int32_t > | |
| CTensorType< int64_t > | |
| CTensorType< uint32_t > | |
| CTensorType< uint64_t > | |
| CUnaryOpTraits | |
| CUnaryOpTraits< T, EBasicUnaryOperator::kExp > | |
| CUnaryOpTraits< T, EBasicUnaryOperator::kLog > | |
| CUnaryOpTraits< T, EBasicUnaryOperator::kNeg > | |
| CUnaryOpTraits< T, EBasicUnaryOperator::kReciprocal > | |
| 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 |
| NTMVAGlob | |
| CAbsoluteDeviationLossFunction | Absolute Deviation Loss Function |
| CAbsoluteDeviationLossFunctionBDT | Absolute Deviation BDT Loss Function |
| CAbsValue | |
| CBDTEventWrapper | |
| CBinarySearchTree | A simple Binary search tree including a volume search method |
| CBinarySearchTreeNode | Node for the BinarySearch or Decision Trees |
| CBinaryTree | Base class for BinarySearch and Decision Trees |
| CCCPruner | A helper class to prune a decision tree using the Cost Complexity method (see Classification and Regression Trees by Leo Breiman et al) |
| ►CCCTreeWrapper | |
| CCCTreeNode | |
| CClassifierFactory | This is the MVA factory |
| CClassInfo | Class that contains all the information of a class |
| ►CConfig | Singleton class for global configuration settings used by TMVA |
| CIONames | |
| CVariablePlotting | |
| CConfigurable | |
| CConvergenceTest | Check for convergence |
| CCostComplexityPruneTool | A class to prune a decision tree using the Cost Complexity method |
| CCrossEntropy | Implementation of the CrossEntropy as separation criterion |
| CCrossValidation | Class to perform cross validation, splitting the dataloader into folds |
| CCrossValidationFoldResult | |
| CCrossValidationResult | Class to save the results of cross validation, the metric for the classification ins ROC and you can ROC curves ROC integrals, ROC average and ROC standard deviation |
| CCvSplit | |
| CCvSplitKFolds | |
| CCvSplitKFoldsExpr | |
| CDataInputHandler | Class that contains all the data information |
| CDataLoader | |
| CDataSet | Class that contains all the data information |
| ►CDataSetFactory | Class that contains all the data information |
| CEventStats | |
| CDataSetInfo | Class that contains all the data information |
| CDataSetManager | Class that contains all the data information |
| CDecisionTree | Implementation of a Decision Tree |
| CDecisionTreeNode | |
| CDeleteFunctor_t | |
| CDTNodeTrainingInfo | |
| CEnvelope | Abstract base class for all high level ml algorithms, you can book ml methods like BDT, MLP |
| CEvent | |
| CExecutor | Base Executor class |
| CExpectedErrorPruneTool | A helper class to prune a decision tree using the expected error (C4.5) method |
| CFactory | This is the main MVA steering class |
| CFitterBase | Base class for TMVA fitters |
| CGeneticAlgorithm | Base definition for genetic algorithm |
| CGeneticFitter | Fitter using a Genetic Algorithm |
| CGeneticGenes | Cut optimisation interface class for genetic algorithm |
| CGeneticPopulation | Population definition for genetic algorithm |
| CGeneticRange | Range definition for genetic algorithm |
| CGiniIndex | Implementation of the GiniIndex as separation criterion |
| CGiniIndexWithLaplace | Implementation of the GiniIndex With Laplace correction as separation criterion |
| CHuberLossFunction | Huber Loss Function |
| CHuberLossFunctionBDT | Huber BDT Loss Function |
| CHyperParameterOptimisation | |
| CHyperParameterOptimisationResult | |
| CIFitterTarget | Interface for a fitter 'target' |
| CIMethod | Interface for all concrete MVA method implementations |
| CIncrement | |
| CInterval | The TMVA::Interval Class |
| CIPruneTool | IPruneTool - a helper interface class to prune a decision tree |
| CIPythonInteractive | This class is needed by JsMVA, and it's a helper class for tracking errors during the training in Jupyter notebook |
| CKDEKernel | KDE Kernel for "smoothing" the PDFs |
| CLDA | |
| CLeastSquaresLossFunction | Least Squares Loss Function |
| CLeastSquaresLossFunctionBDT | Least Squares BDT Loss Function |
| CLogInterval | The TMVA::Interval Class |
| CLossFunction | |
| CLossFunctionBDT | |
| CLossFunctionEventInfo | |
| CMCFitter | Fitter using Monte Carlo sampling of parameters |
| CMethodANNBase | Base class for all TMVA methods using artificial neural networks |
| CMethodBase | Virtual base Class for all MVA method |
| CMethodBayesClassifier | Description of bayesian classifiers |
| CMethodBDT | Analysis of Boosted Decision Trees |
| CMethodBoost | Class for boosting a TMVA method |
| CMethodC50 | |
| CMethodCategory | Class for categorizing the phase space |
| CMethodCFMlpANN | Interface to Clermond-Ferrand artificial neural network |
| ►CMethodCFMlpANN_Utils | Implementation of Clermond-Ferrand artificial neural network |
| CVARn2 | |
| CMethodCompositeBase | Virtual base class for combining several TMVA method |
| CMethodCrossValidation | |
| CMethodCuts | Multivariate optimisation of signal efficiency for given background efficiency, applying rectangular minimum and maximum requirements |
| CMethodDL | |
| ►CMethodDNN | Deep Neural Network Implementation |
| CTTrainingSettings | |
| CMethodDT | Analysis of Boosted Decision Trees |
| CMethodFDA | Function discriminant analysis (FDA) |
| CMethodFisher | Fisher and Mahalanobis Discriminants (Linear Discriminant Analysis) |
| CMethodHMatrix | H-Matrix method, which is implemented as a simple comparison of chi-squared estimators for signal and background, taking into account the linear correlations between the input variables |
| CMethodInfo | |
| CMethodKNN | Analysis of k-nearest neighbor |
| CMethodLD | Linear Discriminant |
| CMethodLikelihood | Likelihood analysis ("non-parametric approach") |
| CMethodMLP | Multilayer Perceptron class built off of MethodANNBase |
| CMethodPDEFoam | The PDEFoam method is an extension of the PDERS method, which divides the multi-dimensional phase space in a finite number of hyper-rectangles (cells) of constant event density |
| CMethodPDERS | This is a generalization of the above Likelihood methods to \( N_{var} \) dimensions, where \( N_{var} \) is the number of input variables used in the MVA |
| CMethodPyAdaBoost | |
| CMethodPyGTB | |
| CMethodPyKeras | |
| CMethodPyRandomForest | |
| CMethodPyTorch | |
| CMethodRSNNS | |
| CMethodRSVM | |
| CMethodRuleFit | J Friedman's RuleFit method |
| CMethodRXGB | |
| CMethodSVM | SMO Platt's SVM classifier with Keerthi & Shavade improvements |
| CMethodTMlpANN | This is the TMVA TMultiLayerPerceptron interface class |
| CMinuitFitter | /Fitter using MINUIT |
| CMinuitWrapper | Wrapper around MINUIT |
| CMisClassificationError | Implementation of the MisClassificationError as separation criterion |
| CMonitoring | |
| CMsgLogger | Ostringstream derivative to redirect and format output |
| CNode | Node for the BinarySearch or Decision Trees |
| Cnull_t | |
| COptimizeConfigParameters | |
| COption | |
| COption< T * > | |
| COptionBase | Class for TMVA-option handling |
| ►COptionMap | Class to storage options for the differents methods |
| CBinding | |
| CPDEFoam | Implementation of PDEFoam |
| CPDEFoamCell | |
| CPDEFoamDecisionTree | This PDEFoam variant acts like a decision tree and stores in every cell the discriminant |
| CPDEFoamDecisionTreeDensity | This is a concrete implementation of PDEFoam |
| CPDEFoamDensityBase | This is an abstract class, which provides an interface for a PDEFoam density estimator |
| CPDEFoamDiscriminant | This PDEFoam variant stores in every cell the discriminant |
| CPDEFoamDiscriminantDensity | This is a concrete implementation of PDEFoam |
| CPDEFoamEvent | This PDEFoam variant stores in every cell the sum of event weights and the sum of the squared event weights |
| CPDEFoamEventDensity | This is a concrete implementation of PDEFoam |
| CPDEFoamKernelBase | This class is the abstract kernel interface for PDEFoam |
| CPDEFoamKernelGauss | This PDEFoam kernel estimates a cell value for a given event by weighting all cell values with a gauss function |
| CPDEFoamKernelLinN | This PDEFoam kernel estimates a cell value for a given event by weighting with cell values of the nearest neighbor cells |
| CPDEFoamKernelTrivial | This class is a trivial PDEFoam kernel estimator |
| CPDEFoamMultiTarget | This PDEFoam variant is used to estimate multiple targets by creating an event density foam (PDEFoamEvent), which has dimension: |
| CPDEFoamTarget | This PDEFoam variant stores in every cell the average target fTarget (see the Constructor) as well as the statistical error on the target fTarget |
| CPDEFoamTargetDensity | This is a concrete implementation of PDEFoam |
| CPDEFoamVect | |
| CPDF | PDF wrapper for histograms; uses user-defined spline interpolation |
| CPruningInfo | |
| CPyMethodBase | |
| ►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 |
| CEncodeProcessDecode | |
| CMLPGraphIndependent | |
| CMLPGraphNetwork | |
| CSofieGNN | |
| CEncodeProcessDecode | |
| CMLPGraphIndependent | |
| CMLPGraphNetwork | |
| ►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 | |
| Nutil | |
| ►Nvecgeom | |
| Ncxx | |
| ►Nwriter | |
| Cwriter | |
| Nxmlio | |
| NXrdCl | |
| ►NZMQ | |
| ►NDetail | |
| Cis_trivial | |
| CMoreException | |
| Cppoll_error_t | |
| CTimeOutException | |
