| NApplicationClassificationKeras | |
| NApplicationClassificationPyTorch | |
| NApplicationRegressionKeras | |
| NApplicationRegressionPyTorch | |
| Narrow | |
| Nbenchmarks | |
| Nbent | |
| NBessel | |
| ►NBidirMMapPipe_impl | Namespace for implementation details of BidirMMapPipe |
| CPageChunk | Class representing a chunk of pages |
| ►CPages | Handle class for a number of Pages |
| Cimpl | Implementation |
| Nclang | |
| NClassificationKeras | |
| NClassificationPyTorch | |
| ►NClingMemberIterInternal | |
| CDCIter | Iteration over collected DeclContexts |
| ►CUsingDeclIter | |
| CUsingDeclFrame | |
| NCppyy | |
| ►NCPyCppyy | Set of helper functions that are invoked from the pythonizors, on the Python side |
| NPyStrings | |
| NTypeManip | |
| ►NUtility | |
| CPyError_t | |
| CPyOperators | |
| ►CCallContext | |
| CTemporary | |
| CConverter | |
| CCPPAbstractClassConstructor | |
| CCPPClassMethod | |
| CCPPConstructor | |
| CCPPDataMember | |
| CCPPExcInstance | |
| CCPPFunction | |
| CCPPGetItem | |
| CCPPIncompleteClassConstructor | |
| CCPPInstance | |
| CCPPMethod | |
| CCPPNamespaceConstructor | |
| ►CCPPOverload | |
| CMethodInfo_t | |
| CCPPReverseBinary | |
| CCPPScope | |
| CCPPSetItem | |
| CCPPSmartClass | |
| CDispatchPtr | |
| CExecutor | |
| Cindexiterobject | |
| CInstancePtrConverter | |
| CLowLevelView | |
| CMemoryRegulator | |
| ►CParameter | |
| CValue | |
| CPyCallable | |
| CPyException | |
| CPyResult | |
| CRefExecutor | |
| CStrictInstancePtrConverter | |
| CTemplateInfo | |
| CTemplateProxy | |
| Ctypedefpointertoclassobject | |
| Cvectoriterobject | |
| CVoidArrayConverter | |
| Ncustom_derivatives | |
| NDavix | |
| Ndemo | |
| Ndemoshelp | |
| Ndf001_introduction | |
| Ndf002_dataModel | |
| Ndf003_profiles | |
| Ndf004_cutFlowReport | |
| Ndf006_ranges | |
| Ndf007_snapshot | |
| Ndf008_createDataSetFromScratch | |
| Ndf010_trivialDataSource | |
| Ndf012_DefinesAndFiltersAsStrings | |
| Ndf014_CSVDataSource | |
| Ndf016_vecOps | |
| Ndf017_vecOpsHEP | |
| Ndf019_Cache | |
| Ndf021_createTGraph | |
| Ndf024_Display | |
| Ndf026_AsNumpyArrays | |
| Ndf031_Stats | |
| Ndf102_NanoAODDimuonAnalysis | |
| Ndf103_NanoAODHiggsAnalysis | |
| Ndf104_HiggsToTwoPhotons | |
| Ndf105_WBosonAnalysis | |
| Ndf106_HiggsToFourLeptons | |
| Ndf107_SingleTopAnalysis | |
| Ndistrdf001_spark_connection | |
| NDynamicSlice | |
| Nexample | |
| Nextract_docstrings | |
| Nfaddeeva_impl | |
| Nfildir | |
| Nfile | |
| Nfillrandom | |
| Nfirst | |
| Nfit1 | |
| Nfit1_py | |
| NFitterUtil | Utility functions to be used in the fitter classes |
| Nformula1 | |
| Nframework | |
| Nfw3dlego | |
| NGenerateModel | |
| Ngenreflex | |
| Ngeometry | |
| Ngerrors | |
| Ngraph | |
| Ngui_ex | |
| Nh1draw | |
| NHFit | |
| Nhist2workspace-argparse | |
| Nhsimple | |
| Nhsum | |
| Nlauncher | |
| NLegendre | |
| Nlineset | |
| Nllvm | |
| NmakeQuickModel | |
| NMath | Namespace for new Math classes and functions |
| NmathcoreStatFunc | |
| ►NMemstat | |
| CSCustomDigest | |
| CSFind_t | |
| CTMemStatFAddrContainer | |
| CTMemStatMng | |
| CToLower_t | |
| NMPCode | This namespace prevents conflicts between MPCode::kError and ELogLevel::kError |
| Nmrt | |
| NMulticlassKeras | |
| NMulticlassPyTorch | |
| Nmultifit | |
| Nna49geomfile | |
| Nna49view | |
| Nna49visible | |
| NnormalDist | |
| Nntuple1 | |
| NnumberEntry | |
| ►Noracle | |
| Nocci | |
| ►NOuter | |
| CInner | |
| CTemplate | |
| CTemplate< Inner, 1 > | Simple specialisation |
| CTemplate< Template< Inner, 2 >, 1 > | Complex specialisation |
| Nparse_CSV_file_with_TTree_ReadStream | |
| Nprincipal | |
| ►NPyROOT | |
| NPyStrings | |
| CRPyROOTApplication | Interactive application for Python |
| CTMemoryRegulator | |
| Npyroot001_arrayInterface | |
| Npyroot002_TTreeAsMatrix | |
| Npyroot003_prettyPrinting | |
| Npyroot004_NumbaDeclare | |
| ►NPyTorch_Generate_CNN_Model | |
| CReshape | |
| NR6 | |
| NR7 | |
| Nratioplot | |
| Nratioplot1 | |
| Nratioplot2 | |
| Nratioplot3 | |
| Nratioplot4 | |
| Nratioplot5 | |
| Nratioplot6 | |
| ►NRcpp | This is a class to support deprecated method to pass function to R's Environment, based in Rcpp::InternalFunction |
| Ntraits | |
| NRegressionKeras | |
| NRegressionPyTorch | |
| Nrf101_basics | |
| Nrf103_interprfuncs | |
| Nrf104_classfactory | |
| Nrf106_plotdecoration | |
| Nrf107_plotstyles | |
| Nrf108_plotbinning | |
| Nrf110_normintegration | |
| Nrf111_derivatives | |
| Nrf201_composite | |
| Nrf202_extendedmlfit | |
| Nrf203_ranges | |
| Nrf204_extrangefit | |
| Nrf205_compplot | |
| Nrf206_treevistools | |
| Nrf209_anaconv | |
| Nrf301_composition | |
| Nrf302_utilfuncs | |
| Nrf304_uncorrprod | |
| Nrf305_condcorrprod | |
| Nrf306_condpereventerrors | |
| Nrf307_fullpereventerrors | |
| Nrf308_normintegration2d | |
| Nrf309_ndimplot | |
| Nrf310_sliceplot | |
| Nrf311_rangeplot | |
| Nrf312_multirangefit | |
| Nrf313_paramranges | |
| Nrf314_paramfitrange | |
| Nrf315_projectpdf | |
| Nrf316_llratioplot | |
| Nrf402_datahandling | |
| Nrf404_categories | |
| Nrf405_realtocatfuncs | |
| Nrf406_cattocatfuncs | |
| Nrf407_latextables | |
| Nrf501_simultaneouspdf | |
| Nrf502_wspacewrite | |
| Nrf504_simwstool | |
| Nrf505_asciicfg | |
| Nrf506_msgservice | |
| Nrf507_debugtools | |
| Nrf509_wsinteractive | |
| Nrf511_wsfactory_basic | |
| Nrf513_wsfactory_tools | |
| Nrf603_multicpu | |
| Nrf604_constraints | |
| Nrf607_fitresult | |
| Nrf608_fitresultaspdf | |
| Nrf609_xychi2fit | |
| Nrf610_visualerror | |
| Nrf701_efficiencyfit | |
| Nrf702_efficiencyfit_2D | |
| Nrf703_effpdfprod | |
| Nrf704_amplitudefit | |
| Nrf706_histpdf | |
| Nrf707_kernelestimation | |
| Nrf708_bphysics | |
| Nrf801_mcstudy | |
| Nrf901_numintconfig | |
| Nrf902_numgenconfig | |
| Nrf903_numintcache | |
| ►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 |
| NRF_ARCH | Contains the part of the code of the RooBatchCompute Library that needs to be compiled for every different cpu architecture |
| CBracketAdapter | Little adapter that gives a bracket operator to types that don't have one |
| CBracketAdapterWithMask | |
| CRooBatchComputeInterface | The interface which should be implemented to provide optimised computation functions for implementations of RooAbsReal::evaluateSpan() |
| CRunContext | This struct enables passing computation data around between elements of a computation graph |
| ►NRooFit | The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or other types of arguments) |
| NSTLRefCountListHelpers | |
| NRooFit_internal | |
| NRooFitShortHand | |
| ►NRooHelpers | |
| CDisableCachingRAII | Disable all caches for sub-branches in an expression tree |
| 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 |
| NRooLinkedListImplDetails | |
| NRooSimultaneousAux | |
| ►NRooStats | Namespace for the RooStats classes |
| ►NHistFactory | |
| NConstraint | |
| 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 | |
| ►CEstimateSummary | |
| CNormFactor | |
| CShapeSys | |
| CFlexibleInterpVar | |
| Chf_exc | |
| CHistFactoryNavigation | |
| CHistFactorySimultaneous | RooSimultaneous facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset |
| 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 |
| CHistoToWorkspaceFactory | |
| CHistoToWorkspaceFactoryFast | This class provides helper functions for creating likelihood models from histograms |
| 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 | |
| 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 |
| 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 |
| CHybridCalculatorOriginal | HybridCalculatorOriginal class |
| 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 |
| CHypoTestInverterOriginal | This class is now deprecated and to be replaced by the HypoTestInverter |
| 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 |
| 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 |
| 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 |
| CProofConfig | Holds configuration options for proof and proof-lite |
| 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 |
| CToyMCPayload | |
| CToyMCSampler | ToyMCSampler is an implementation of the TestStatSampler interface |
| CToyMCStudy | ToyMCStudy is an implementation of RooAbsStudy for toy Monte Carlo sampling |
| 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 |
| NCocoaTutorials | |
| ►NDetail | |
| ►NRDF | |
| ►NCustomColExtraArgs | |
| CNone | |
| CSlot | |
| CSlotAndEntry | |
| CRColumnReaderBase | |
| CRDefine | |
| CRDefineBase | |
| CRFilter | |
| CRFilterBase | |
| 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 |
| CTCallback | |
| CTOneTimeCallback | |
| 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 |
| CRNodeBase | Base class for non-leaf nodes of the computational graph |
| CRRange | |
| CRRangeBase | |
| ►NVecOps | |
| ►CRAdoptAllocator | RAdoptAllocator can provide a view on already allocated memory |
| Crebind | |
| ►CRAdoptAllocator< bool > | |
| Crebind | |
| C__integer_sequence | |
| C__make | |
| C__make< 0 > | |
| C__make< 1 > | |
| C__make< 2 > | |
| C__make< 3 > | |
| C__make< 4 > | |
| C__make< 5 > | |
| C__make< 6 > | |
| C__make< 7 > | |
| C__parity | |
| ►C__parity< 0 > | |
| C__pmake | |
| ►C__parity< 1 > | |
| C__pmake | |
| ►C__parity< 2 > | |
| C__pmake | |
| ►C__parity< 3 > | |
| C__pmake | |
| ►C__parity< 4 > | |
| C__pmake | |
| ►C__parity< 5 > | |
| C__pmake | |
| ►C__parity< 6 > | |
| C__pmake | |
| ►C__parity< 7 > | |
| C__pmake | |
| C__repeat | |
| C__repeat< __integer_sequence< _Tp, _Np... >, _Extra... > | |
| 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 > | |
| CRMakeUniqueResult | |
| CRMakeUniqueResult< T[]> | |
| CRMakeUniqueResult< T[N]> | |
| 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 | |
| CTFutureImpl | |
| CTRangeStaticCast | TRangeStaticCast is an adaptater class that allows the typed iteration through a TCollection |
| ►CTSchemaRuleSet | |
| CTMatches | |
| ►CTStatusBitsChecker | |
| CRegistry | |
| CTTypedIter | TTypedIter is a typed version of TIter |
| ►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 |
| CRCluster | An in-memory subset of the packed and compressed pages of a cluster |
| ►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 |
| CRUnzipItem | Request to decompress and if necessary unpack compressed pages |
| CRColumn | |
| CRColumnElement | Pairs of C++ type and column type, like float and EColumnType::kReal32 |
| CRColumnElement< bool, EColumnType::kBit > | |
| CRColumnElement< char, EColumnType::kByte > | |
| CRColumnElement< ClusterSize_t, EColumnType::kIndex > | |
| CRColumnElement< double, EColumnType::kReal64 > | |
| CRColumnElement< float, EColumnType::kReal32 > | |
| CRColumnElement< RColumnSwitch, EColumnType::kSwitch > | |
| CRColumnElementBase | |
| ►CRFieldBase | |
| ►CRSchemaIterator | Iterates over the sub tree of fields in depth-first search order |
| CPosition | |
| CRFieldFuse | |
| CRFieldValue | |
| 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 |
| 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 |
| 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 |
| 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 |
| ►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 |
| CRPageAllocatorFile | Manages pages read from a the file |
| CRPageAllocatorHeap | Uses standard C++ memory allocation for the column data pages |
| CRPageDeleter | A closure that can free the memory associated with a mapped page |
| CRPagePool | A thread-safe cache of column pages |
| CRPageSink | Abstract interface to write data into an ntuple |
| CRPageSinkFile | Storage provider that write ntuple pages into a file |
| CRPageSource | Abstract interface to read data from an ntuple |
| ►CRPageSourceFile | Storage provider that reads ntuple pages from a file |
| CRCounters | I/O performance counters that get registered in fMetrics |
| ►CRPageStorage | Common functionality of an ntuple storage for both reading and writing |
| CRColumnHandle | |
| CRTaskScheduler | The interface of a task scheduler to schedule page (de)compression tasks |
| ►NEveGlu | |
| CTriangleCollector | |
| ►NHist | |
| CRCoordArray | |
| ►NInternal | |
| 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 > | |
| ►CIsMappable | |
| CRFailure | |
| 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 > | |
| CRDirectoryEntry | |
| 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 |
| CRIOShared | |
| CRIOSharedBase | |
| 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 |
| ►CRNTupleFileWriter | Write RNTuple data blocks in a TFile or a bare file container |
| CRFileProper | |
| CRFileSimple | |
| CRResultBase | Common handling of the error case for RResult<T> (T != void) and RResult<void> |
| 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 | |
| CTBulkBranchRead | Helper class for reading many branch entries at once to optimize throughput |
| CTTreeReaderValueFastBase | |
| CRArrayField | The generic field for fixed size arrays, which do not need an offset column |
| CRAttrAxis | All supported axes attributes for: line, ticks, labels, title, min/max, log, reverse, .. |
| ►CRAttrBase | Base class for all attributes, used with RDrawable |
| CRec_t | |
| CVal_t | |
| CRAttrBox | Drawing attributes for a box: rectangular lines with size and position |
| CRAttrColor | Access RColor from drawable attributes |
| CRAttrFill | Drawing fill attributes for different objects |
| CRAttrLine | Drawing line attributes for different objects |
| ►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 |
| ►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 | Plain axis drawing |
| CRAxisDrawableBase | Axis base drawing - only attributes and position |
| 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 |
| CRAxisLabelsDrawable | Labels axis drawing |
| CRCanvas | A window's topmost RPad |
| CRCanvasDisplayItem | Class RCanvasDisplayItem |
| CRChangeAttrRequest | |
| CRClassField | The field for a class with dictionary |
| ►CRClusterDescriptor | Meta-data for a set of ntuple clusters |
| CRColumnRange | The window of element indexes of a particular column in a particular cluster |
| CRLocator | Generic information about the physical location of data |
| ►CRPageRange | Records the parition 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 |
| CRClusterIndex | Addresses a column element or field item relative to a particular cluster, instead of a global NTupleSize_t index |
| CRClusterSize | Wrap the 32bit integer in a struct in order to avoid template specialization clash with std::uint32_t |
| CRCollectionField | |
| CRCollectionNTuple | A virtual ntuple for collections that can be used to some extent like a real ntuple |
| CRColor | The color class |
| CRColumnDescriptor | Meta-data stored for every column of an ntuple |
| CRColumnModel | Holds the static meta-data of a column in a tree |
| CRColumnSwitch | Holds the index and the tag of a kSwitch column |
| CRDanglingFieldDescriptor | A helper class for piece-wise construction of an RFieldDescriptor |
| ►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 |
| ►CRError | Captures diagnostics related to a ROOT runtime error |
| CRLocation | |
| CREve3DProjection | |
| CREveAunt | |
| CREveAuntAsList | |
| CREveBox | |
| CREveBoxProjected | |
| ►CREveBoxSet | |
| CBAABox_t | |
| CBAABoxFixedDim_t | |
| CBCone_t | |
| CBEllipticCone_t | |
| CBFreeBox_t | |
| CBHex_t | |
| CBOrigin_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 | |
| CREveDataSimpleProxyBuilderTemplate | |
| CREveDataTable | |
| ►CREveDigitSet | |
| CDigitBase_t | |
| CREveElement | |
| CREveEllipsoid | |
| CREveEllipsoidProjected | |
| CREveException | REveException Exception-type thrown by Eve classes |
| CREveFrameBox | |
| CREveGeoManagerHolder | REveGeoManagerHolder Exception-safe global variable holders |
| CREveGeomConfig | Configuration parameters which can be configured on the client Send as is to-from client |
| ►CREveGeomDescription | |
| CShapeDescr | |
| CREveGeomDrawing | Object with full description for drawing geometry It includes list of visible items and list of nodes required to build them |
| CREveGeomNode | Full node description including matrices and other attributes |
| CREveGeomNodeBase | Base description of geometry node, required only to build hierarchy |
| CREveGeomNodeInfo | |
| CREveGeomRequest | Request object send from client for different operations |
| CREveGeomViewer | |
| CREveGeomVisible | REveGeomVisible contains description of visible node It is path to the node plus reference to shape rendering data |
| CREveGeoPainter | |
| ►CREveGeoPolyShape | |
| CEdge_t | |
| CREveGeoShape | |
| CREveGeoShapeExtract | |
| CREveGeoShapeProjected | |
| 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 | |
| CConn | |
| CRExceptionHandler | |
| CRRedrawDisabler | |
| 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 |
| CRecord | |
| CREveSelectorToEventList | REveSelectorToEventList TSelector that stores entry numbers of matching TTree entries into an event-list |
| 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 |
| 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 | |
| CRException | Base class for all ROOT issued exceptions |
| CRField | Classes with dictionaries that can be inspected by TClass |
| CRField< bool > | |
| CRField< ClusterSize_t > | Template specializations for concrete C++ types |
| CRField< double > | |
| CRField< float > | |
| CRField< ROOT::VecOps::RVec< bool > > | RVec<bool> needs special treatment due to std::vector<bool> sepcialization |
| CRField< ROOT::VecOps::RVec< ItemT > > | The RVec type has different layouts depending on the item type, therefore we cannot go with a generic RVec implementation as we can with std::vector |
| CRFieldDescriptor | Meta-data stored for every field of an ntuple |
| CRFieldMerger | Two-way merge between NTuple fields |
| 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 |
| CRFitResult | |
| ►CRFrame | Holds an area where drawing on user coordinate-system can be performed |
| CRUserRanges | |
| CRZoomRequest | |
| CRFunction | |
| CRGeomRawRenderInfo | Render info with raw data |
| CRGeomRenderInfo | Base class for render info block |
| CRGeomShapeRenderInfo | Render info with shape itself - client can produce shape better |
| 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 |
| 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 |
| CRMenuItems | List of items for object context menu |
| CRNTuple | Entry point for an RNTuple in a ROOT file |
| ►CRNTupleClusterRange | Used to loop over entries of collections in a single cluster |
| CRIterator | |
| ►CRNTupleDescriptor | The on-storage meta-data of an ntuple |
| ►CRColumnDescriptorRange | Used to loop over a field's associated columns |
| CRIterator | |
| ►CRFieldDescriptorRange | Used to loop over a field's child fields |
| CRIterator | |
| CRNTupleDescriptorBuilder | A helper class for piece-wise construction of an RNTupleDescriptor |
| CRNTupleDS | |
| CRNTupleFormatter | Contains helper functions for RNTupleReader::PrintInfo() and RPrintSchemaVisitor::VisitField() |
| ►CRNTupleGlobalRange | Used to loop over indexes (entries or collections) between start and end |
| CRIterator | |
| CRNTupleImtTaskScheduler | |
| CRNTupleModel | The RNTupleModel encapulates the schema of an ntuple |
| ►CRNTupleReader | An RNTuple that is used to read data from storage |
| CRIterator | |
| CRNTupleReadOptions | Common user-tunable settings for reading ntuples |
| CRNTupleVersion | For forward and backward compatibility, attach version information to the consitituents of the file format (column, field, cluster, ntuple) |
| CRNTupleView | An RNTupleView provides read-only access to a single field of the ntuple |
| CRNTupleViewCollection | A view for a collection, that can itself generate new ntuple views for its nested fields |
| CRNTupleWriteOptions | Common user-tunable settings for storing ntuples |
| CRNTupleWriter | An RNTuple that gets filled with entries (data) and writes them to storage |
| CRPad | Graphic container for RDrawable-s |
| ►CRPadBase | Base class for graphic containers for RDrawable-s |
| CBoundKindAndValue | Simple struct representing an axis bound |
| CRPadBaseDisplayItem | Class RPadBaseDisplayItem |
| CRPadCartesianUserAxis | |
| 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 |
| CRPadUserAxisBase | Base class for user coordinates (e.g |
| ►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 | |
| 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 |
| ►CRStyle | A set of defaults for graphics attributes, e.g |
| CBlock_t | |
| CRVectorField | The generic field for a (nested) std::vector<Type> except for std::vector<bool> |
| CRWebDisplayArgs | Holds different arguments for starting browser with RWebDisplayHandle::Display() method |
| ►CRWebDisplayHandle | |
| CBrowserCreator | |
| CChromeCreator | |
| CCreator | !< page content |
| CFirefoxCreator | |
| ►CRWebWindow | Represents web window, which can be shown in web browser or any other supported environment |
| 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 | |
| CTFuture | A TFuture class. It can wrap an std::future |
| CTObjectDisplayItem | Display item for TObject with drawing options |
| CTObjectDrawable | Provides v7 drawing facilities for TObject types (TGraph etc) |
| CTTaskGroup | A class to manage the asynchronous execution of work items |
| ►CTTreeReaderFast | |
| CIterator_t | |
| CTTreeReaderValueFast | |
| CTTreeReaderValueFast< Bool_t > | |
| CTTreeReaderValueFast< double > | |
| CTTreeReaderValueFast< float > | |
| CTTreeReaderValueFast< Int_t > | |
| CTTreeReaderValueFast< UInt_t > | |
| ►NFit | Namespace for the fitting classes |
| NExecutionPolicy | |
| ►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 > | |
| NHFitInterface | |
| CBasicFCN | BasicFCN class: base class for the objective functions used in the fits It has a reference to the data and th emodel function used in the fit |
| 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: |
| CChi2FCN | Chi2FCN class for binnned 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 |
| CDummyDeleter | |
| 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 containg the result of the fit and all the related information (fitted parameter values, error, covariance matrix and minimizer result information) Contains a pointer also to the fitted (model) function, modified with the fit parameter values |
| CFitter | Fitter class, entry point for performing all type of fits |
| CLogLikelihoodFCN | LogLikelihoodFCN class for likelihood fits |
| 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 |
| CSparseData | |
| CUnBinData | Class describing the unbinned data sets (just x coordinates values) of any dimensions |
| NFoundationUtils | |
| ►NGeom | |
| CVertex_t | |
| NGLTutorials | |
| ►NInternal | |
| ►NExecutorUtils | |
| CResultCaster | |
| CResultCaster< TObject *, F > | |
| ►NRDF | |
| ►NGraphDrawing | |
| CGraphCreatorHelper | |
| CGraphNode | |
| CDisplayHelper | |
| CPassAsVecHelper | |
| CRAction | A RDataFrame node that produces a result |
| CRActionBase | |
| CRBookedDefines | Encapsulates the columns defined by the user |
| CRColumnReadersInfo | This type aggregates some of the arguments passed to InitColumnReaders |
| CRDataBlockFlag | |
| CRDataBlockNotifier | |
| CRDefineReader | Column reader for defined (aka custom) columns |
| CRDisplayElement | Helper class to let Display print compact tabular representations of the events |
| CRDSColumnReader | Column reader type that deals with values read from RDataSources |
| CRJittedAction | |
| CRNumpyDS | A RDataSource implementation which takes a collection of RVecs, which are able to adopt data from Numpy arrays |
| CRRootDS | |
| CRSlotStack | This is an helper class to allow to pick a slot resorting to a map indexed by thread ids |
| 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 |
| ►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 |
| ►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 | |
| CClassDefGenerateInitInstanceLocalInjector | |
| ►CDictSelectionReader | |
| CTemplateInfo | |
| CFriendInfo | |
| CGetFunctorType | |
| 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 | |
| ►CRConcurrentHashColl | This class is a TS set of unsigned set |
| CHashValue | |
| CRecurseCounts | |
| ►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 |
| CROptions | On construction, an ROptions parameter can customize the RRawFile behavior |
| CRRawFileDavix | Read-only access to remote non-ROOT files |
| CRRawFileUnix | Uses POSIX calls to read from a mounted file system |
| CRRawFileWin | Uses portable C I/O calls to read from a drive |
| CRStl | |
| CRTaskArenaWrapper | Wrapper for tbb::task_arena |
| CTArrayCharProxy | |
| CTArrayProxy | |
| CTArrayType | |
| CTArrayType< T, 0 > | |
| 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 | |
| CTCDGIILIBase | |
| ►CTCheckHashRecursiveRemoveConsistency | |
| CValue | |
| CTClaArrayProxy | |
| CTClaImpProxy | |
| CTClaObjProxy | |
| CTClaProxy | |
| CTClassGetClassHelper | |
| CTDefaultInitBehavior | |
| CTDirectoryAtomicAdapter | |
| ►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 | |
| CTHashConsistencyHolder | |
| CTHnBaseBinIter | Iterator over THnBase bins (internal implementation) |
| CTHnBaseBrowsable | TBrowser helper for THnBase |
| CTImpProxy | |
| CTInitBehavior | |
| CTMultiArrayType | |
| CTNamedBranchProxy | |
| CTObjProxy | |
| CTOperatorNewHelper | |
| CTParBranchProcessingRAII | |
| CTQObjectInitBehavior | |
| CTRangeDynCastIterator | Internal help class implmenting an iterator for TRangeDynCast |
| CTSchemaHelper | |
| CTSchemaRuleProcessor | |
| CTSchemaType | |
| CTSpinLockGuard | A spin mutex-as-code-guard class |
| CTStdBitsetHelper | |
| CTStlArrayProxy | |
| CTStlImpProxy | |
| CTStlObjProxy | |
| CTStlProxy | |
| CTStlSimpleProxy | |
| CTStringView | |
| CTTreeGeneratorBase | |
| CTTreeProxyGenerator | |
| CTTreeReaderArrayBase | Base class of TTreeReaderArray |
| CTTreeReaderDescriptor | |
| CTTreeReaderGenerator | |
| CTTreeReaderValueBase | Base class of TTreeReaderValue |
| CTTreeView | |
| CTVirtualCollectionReader | |
| ►CUniqueLockRecurseCount | |
| CLocalCounts | |
| ►NMacOSX | |
| ►NDetails | |
| CCocoaPrivate | |
| ►CFontCache | |
| CFontList | |
| 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 | |
| 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 assigment 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 contrinution to the function which is required by some algorithm (like Fumili) |
| CBasicMinimizer | Base Minimizer class, which defines the basic funcionality of various minimizer implementations (apart from Minuit and Minuit2) It provides support for storing parameter values, step size, parameter transofrmation etc |
| 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) |
| 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 |
| CFunctor | Documentation for class Functor class |
| CFunctor1D | Functor1D class for one-dimensional functions |
| CFunctorGradHandler | Functor Handler class for gradient functions where both callable objects are provided for the function evaluation (type Func) and for the gradient (type GradFunc) |
| CFunctorHandler | Functor Handler class is responsible for wrapping any other functor and pointer to free C functions |
| CFunctorImpl | FunctorImpl is a base class for the functor handler implementation class |
| 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 |
| 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 | |
| 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 ) |
| 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 implment 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 | Gradient interface (abstract class) defining the signature for calculating the gradient of a multi-dimensional function |
| CIGradientOneDim | Specialized Gradient interface(abstract class) for one dimensional functions It provides a method to evaluate the derivative of the function, Derivative and a method to evaluate at the same time the function and the derivative FdF |
| 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 parameteric 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 | |
| CKelvinFunctions | This class calculates the Kelvin functions Ber(x), Bei(x), Ker(x), Kei(x), and their first derivatives |
| 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 |
| CMemFunHandler | Functor Handler to Wrap pointers to member functions The member function type must be (XXX means any name is allowed) : double XXX ( double x) for 1D functions and double XXXX (const double *x) for multi-dimensional functions |
| CMemGradFunHandler | Functor Handler to Wrap pointers to member functions for the evaluation of the function and the gradient |
| 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..) Plug-in's exist in ROOT to be able to instantiate the derived classes like ROOT::Math::GSLMinimizer or ROOT::Math::Minuit2Minimizer via the plug-in manager |
| 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 | Structures 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 parameteric function interface This is used typically in fitting where internally the function is stored as multidimension |
| CMultiDimParamGradFunctionAdapter | MultiDimParamGradFunctionAdapter class to wrap a one-dimensional parametric gradient function in a multi dimensional parameteric gradient function interface This is used typically in fitting where internally the function is stored as multidimension |
| 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 parameteric 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 | |
| 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 impelmentation 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 |
| 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 fron 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 concrate 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 pbject implementing the operator()(const double * x, const double * p) in an interface-like IParamFunction with a vector storing and caching internally the parameter values |
| 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 | |
| CBasicFunctionGradient | |
| ►CBasicFunctionMinimum | Result of the minimization; both internal and external (MnUserParameterState) representation available For the parameters at the Minimum |
| CMnAboveMaxEdm | |
| CMnReachedCallLimit | |
| ►CBasicMinimumError | Internal Class containing the error information on the estimated minimum : Error matrix + dcovar + additional flags for quality and validity checks |
| CMnHesseFailed | |
| CMnInvertFailed | |
| CMnMadePosDef | |
| CMnNotPosDef | |
| CBasicMinimumParameters | |
| CBasicMinimumSeed | |
| CBasicMinimumState | |
| 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) |
| 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 | |
| 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 | |
| CFunctionMinimizer | Base class for function minimizers; user may give FCN or FCN with Gradient, Parameter starting values and initial Error guess (sigma) (or "step size"), or Parameter starting values and initial covariance matrix; covariance matrix is stored in Upper triangular packed storage format, e.g |
| CFunctionMinimum | Class holding the full result of the minimization; both internal and external (MnUserParameterState) representation available for the parameters at the Minimum |
| 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 |
| CLASymMatrix | Class describing a symmetric matrix of size n |
| CLAVector | |
| CMatrixInverse | |
| CMatrixInverse< vec, M, T > | |
| CMinimumBuilder | |
| CMinimumError | MinimumError keeps the inv |
| CMinimumErrorUpdator | |
| CMinimumParameters | |
| CMinimumSeed | MinimumSeed contains the starting values for the minimization produced by the SeedGenerator |
| 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) |
| 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 |
| 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 three levels of strategies: low (0), medium (1), high (>=2); acts on: Migrad (behavioural), Minos (lowers strategy by 1 for Minos-own minimization), Hesse (iterations), Numerical2PDerivative (iterations) |
| 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 |
| CParametricFunction | Function which has parameters |
| 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 choosen |
| 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 | |
| NInternal | |
| CRArrowDS | RDataFrame data source class to interface with Apache Arrow |
| CRCsvDS | RDataFrame data source class for reading CSV files |
| CRCutFlowReport | |
| CRDataSource | RDataSource defines an API that RDataFrame can use to read arbitrary data formats |
| CRDisplay | This class is the textual representation of the content of a columnar dataset |
| CRInterface | The public interface to the RDataFrame federation of classes |
| CRLazyDS | A RDataSource implementation which is built on top of result proxies |
| CRResultHandle | |
| CRResultPtr | Smart pointer for the return type of actions |
| 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 | |
| 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 |
| CTProfile1DModel | A struct which stores the parameters of a TProfile |
| CTProfile2DModel | A struct which stores the parameters of a TProfile2D |
| ►NTF1Helper | |
| CTGradientParFunction | Function class representing the derivative with respect a parameter of a given TF1 |
| ►NTMetaUtils | |
| NAST2SourceTools | |
| NpropNames | |
| ►CAnnotatedRecordDecl | |
| CCompareByName | |
| CRConstructorType | |
| CTClingLookupHelper | |
| CTNormalizedCtxt | |
| NTreeUtils | |
| 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 |
| ►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 high level interface for analyses of data stored in TTrees, CSV's and other data formats |
| CROpaqueTaskArena | |
| CTExecutorCRTP | This class defines an interface to execute the same task multiple times, possibly in parallel and with different arguments every time |
| CTGenericClassInfo | |
| CTIOFeatures | TIOFeatures provides the end-user with the ability to change the IO behavior of data written via a TTree |
| 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 | |
| Nrootmarks | |
| ►NROOTwriter | |
| CROOTwriter | |
| NSelectionRulesUtils | |
| Nshapes | |
| Nsqlcreatedb | |
| Nsqlfilldb | |
| Nsqlio | |
| Nsqlselect | |
| Nstaff | |
| Nsurfaces | |
| ►NTClassEdit | |
| CFunctionSplitInfo | Result of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters) |
| CTInterpreterLookupHelper | |
| CTSplitType | |
| NTessellated | Typedefs used by the geometry group |
| Ntest | |
| NTGeant4Unit | |
| NTGeoUnit | |
| NtimeSeriesFromCSV | |
| ►NTMath | TMath |
| CLimits | |
| NTMatrixTAutoloadOps | |
| NTMatrixTCramerInv | |
| NTMatrixTSymCramerInv | |
| ►NTMVA | Create variable transformations |
| ►NDNN | |
| NBlas | |
| ►NCNN | |
| CTCNNDescriptors | |
| CTCNNWorkspace | |
| CTConvLayer | |
| CTConvParams | |
| CTMaxPoolLayer | Generic Max Pooling Layer class |
| ►NRNN | |
| CTBasicGRULayer | |
| CTBasicLSTMLayer | |
| CTBasicRNNLayer | |
| CTRNNDescriptors | |
| CTRNNWorkspace | |
| CBatch | Encapsulates one mini-batch |
| CClassificationSettings | Settings for classificationused to distinguish between different function signatures |
| CCudaActivationDescriptor | |
| CCudaConvolutionBwdDataAlgo | |
| CCudaConvolutionBwdFilterAlgo | |
| CCudaConvolutionDescriptor | |
| CCudaConvolutionFwdAlgo | |
| CCudaDataType | |
| CCudaDropoutDescriptor | |
| CCudaEmptyDescriptor | |
| CCudaFilterDescriptor | |
| CCudaPoolingDescriptor | |
| CDummyConvolutionBwdDataAlgo | |
| CDummyConvolutionBwdFilterAlgo | |
| CDummyConvolutionDescriptor | |
| CDummyConvolutionFwdAlgo | |
| CDummyCudaDataType | |
| CDummyDataType | |
| CDummyDescriptor | |
| CDummyDropoutDescriptor | |
| CDummyEmptyDescriptor | |
| CDummyFilterDescriptor | |
| CDummyPoolingDescriptor | |
| CLayer | Layer defines the layout of a layer |
| CLayerData | LayerData holds the data of one layer |
| CMeanVariance | |
| CNet | Neural net |
| CSettings | Settings for the training of the neural net |
| CSteepest | Steepest Gradient Descent algorithm (SGD) |
| CTAdadelta | Adadelta Optimizer class |
| CTAdagrad | Adagrad Optimizer class |
| CTAdam | Adam Optimizer class |
| CTBatch | TBatch |
| CTBatchIterator | TBatchIterator |
| CTBatchNormLayer | Layer implementing Batch Normalization |
| CTCpu | The TCpu architecture class |
| ►CTCpuBuffer | TCpuBuffer |
| CFakeIteratorBegin | |
| CTDestructor | |
| CTCpuMatrix | The TCpuMatrix class |
| CTCpuTensor | |
| CTCuda | The TCuda architecture class |
| ►CTCudaDeviceBuffer | TCudaDeviceBuffer |
| CTDestructor | |
| CTCudaDeviceReference | TCudaDeviceReference |
| ►CTCudaHostBuffer | TCudaHostBuffer |
| CTDestructor | |
| CTCudaMatrix | TCudaMatrix Class |
| ►CTCudaTensor | TCudaTensor Class |
| CTensorDescriptor | |
| CTDataLoader | TDataLoader |
| CTDataLoader< AData, TReference< AReal > > | |
| CTDeepNet | Generic Deep Neural Network class |
| CTDenseLayer | Generic layer class |
| CTDescriptors | |
| CTDevice | TDevice |
| CTDLGradientDescent | |
| CTDNNGenDescriptors | |
| CTGradientDescent | |
| CTLayer | Generic layer class |
| CTNet | Generic neural network class |
| CTReference | The reference architecture class |
| CTReshapeLayer | |
| CTRMSProp | RMSProp Optimizer class |
| CTSGD | Stochastic Batch Gradient Descent Optimizer class |
| CTSharedLayer | Layer class width shared weight and bias layers |
| CTTensorBatch | TTensorBatch |
| CTTensorBatchIterator | TTensorBatchIterator |
| CTTensorDataLoader | TTensorDataLoader |
| CTTensorDataLoader< AData, TReference< AReal > > | |
| CTWorkspace | |
| CVGeneralLayer | Generic General Layer class |
| CVOptimizer | Generic Optimizer class |
| ►NExperimental | |
| ►NInternal | |
| Cand_types | Type checking for all types of a parameter pack, e.g., used in combination with std::is_convertible |
| Cand_types< T0, Ts... > | |
| CComputeHelper | Compute helper |
| CXMLConfig | Container for information extracted from TMVA XML config |
| NObjectives | |
| CBranchlessForest | Forest using branchless trees |
| CBranchlessJittedForest | Forest using branchless jitted trees |
| CBranchlessTree | Branchless representation of a decision tree using topological ordering |
| CClassification | |
| CClassificationResult | |
| CForestBase | Forest base class |
| CRBDT | Fast boosted decision tree inference |
| CRReader | TMVA::Reader legacy interface |
| CRStandardScaler | |
| ►CRTensor | RTensor is a container with contiguous memory and shape information |
| CIterator | |
| CSaveXGBoost | Save an XGBoost to a ROOT file to be used with the fast tree inference system of TMVA |
| NInternal | |
| ►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 |
| Ccompose_binary_t | |
| Ccompose_unary_t | |
| ►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 Excutor 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 |
| Ntmva100_DataPreparation | |
| Ntmva101_Training | |
| Ntmva102_Testing | |
| Ntornado | |
| Ntree | |
| ►NTStreamerInfoActions | |
| ►CTActionSequence | |
| CSequencePtr | |
| CTConfiguration | Base class of the Configurations |
| CTConfiguredAction | |
| CTIDNode | |
| CTLoopConfiguration | Base class of the Configurations for the member wise looping routines |
| CTNestedIDs | |
| NtStudent | |
| Ntwoscales | |
| ►Nvecgeom | |
| Ncxx | |
| Nvo001_AdoptOrOwnMemory | |
| Nvo004_SortAndSelect | |
| Nvo005_Combinations | |
| ►Nwriter | |
| Cwriter | |
| Nxmlio | |
| NXPD | |
| NXrdCl | |
| Nzdemo | |
| Nzones | |
