This file contains a specialised ROOT message handler to test for diagnostic in unit tests. More...

Namespaces
namespace	CocoaTutorials

namespace	Detail
	Special implementation of ROOT::RRangeCast for TCollection, including a check that the cast target type inherits from TObject and a new constructor that takes the TCollection by pointer.

namespace	ExecutorUtils
	This namespace contains pre-defined functions to be used in conjuction with TExecutor::Map and TExecutor::MapReduce.

namespace	Experimental

namespace	Fit
	Namespace for the fitting classes.

namespace	FoundationUtils

namespace	Geom

namespace	GLTutorials

namespace	Internal

namespace	MacOSX

namespace	Math

namespace	MathMore

namespace	Meta

namespace	Minuit

namespace	Minuit2

namespace	option
	The namespace of The Lean Mean C++ Option Parser.

namespace	Quartz

namespace	R
	namespace associated R package for ROOT.

namespace	RDF

namespace	TestSupport

namespace	TF1Helper

namespace	TMetaUtils

namespace	TreeUtils

namespace	TThreadedObjectUtils

namespace	TypeTraits
	ROOT type_traits extensions.

namespace	v5

namespace	VecOps

Classes
struct	RCompressionSetting
	The global settings depend on a global variable named R__ZipMode which can be modified by a global function named R__SetZipMode. More...

class	RDataFrame
	ROOT's RDataFrame offers a modern, high-level interface for analysis of data stored in TTree , CSV and other data formats, in C++ or Python. More...

class	ROpaqueTaskArena

class	RRangeCast
	Wraps any collection that can be used in range-based loops and applies `static_cast<T>` or `dynamic_cast<T>` to each element. More...

class	TBufferMerger
	TBufferMerger is a class to facilitate writing data in parallel from multiple threads, while writing to a single output file. More...

class	TBufferMergerFile
	A TBufferMergerFile is similar to a TMemFile, but when data is written to it, it is appended to the TBufferMerger queue. More...

class	TClassAlt

class	TClassRec

class	TExecutorCRTP
	This class defines an interface to execute the same task multiple times, possibly in parallel and with different arguments every time. More...

class	TForNamespace

class	TIOFeatures
	`TIOFeatures` provides the end-user with the ability to change the IO behavior of data written via a `TTree`. More...

class	TMapDeclIdToTClass

class	TMapTypeToClassRec

class	TMapTypeToTClass

class	TModuleGenerator

class	TNumSlots
	Defines the number of threads in some of ROOT's interfaces. More...

class	TProcessExecutor
	This class provides a simple interface to execute the same task multiple times in parallel, possibly with different arguments every time. More...

class	TReadLockGuard

class	TReentrantRWLock

class	TRWMutexImp

class	TRWSpinLock

class	TRWSpinLockReadGuard

class	TRWSpinLockWriteGuard

class	TSchemaRule

class	TSeq
	A pseudo container class which is a generator of indices. More...

class	TSequentialExecutor

class	TSpinMutex
	A spin mutex class which respects the STL interface for mutexes. More...

class	TThreadedObject
	A wrapper to make object instances thread private, lazily. More...

class	TThreadExecutor
	This class provides a simple interface to execute the same task multiple times in parallel threads, possibly with different arguments every time. More...

class	TTreeProcessorMP
	This class provides an interface to process a TTree dataset in parallel with multi-process technology. More...

class	TTreeProcessorMT
	A class to process the entries of a TTree in parallel. More...

class	TVirtualRWMutex

class	TWriteLockGuard

Typedefs
using	ColumnNamesPtr_t = std::shared_ptr< const ColumnNames_t >

typedef void(*	DelArrFunc_t) (void *)

typedef void(*	DelFunc_t) (void *)

typedef void(*	DesFunc_t) (void *)

typedef void(*	DirAutoAdd_t) (void , TDirectory )

using	Double_v = Double_t

using	Float_v = Float_t

using	Int32_v = Int_t

using	Int_v = Int_t

typedef std::map< std::string, ROOT::Internal::TSchemaType >	MembersTypeMap_t

typedef Long64_t(*	MergeFunc_t) (void , TCollection , TFileMergeInfo *)

typedef void (	NewArrFunc_t) (Long_t size, void *arena)

typedef void (	NewFunc_t) (void *)

typedef void(*	ResetAfterMergeFunc_t) (void , TFileMergeInfo )

using	RVecB = ROOT::VecOps::RVec< bool >

using	RVecC = ROOT::VecOps::RVec< char >

using	RVecD = ROOT::VecOps::RVec< double >

using	RVecF = ROOT::VecOps::RVec< float >

using	RVecI = ROOT::VecOps::RVec< int >

using	RVecL = ROOT::VecOps::RVec< long int >

using	RVecLL = ROOT::VecOps::RVec< long long int >

using	RVecU = ROOT::VecOps::RVec< unsigned int >

using	RVecUL = ROOT::VecOps::RVec< unsigned long int >

using	RVecULL = ROOT::VecOps::RVec< unsigned long long int >

typedef std::map< std::string, std::list< SchemaRuleMap_t > >	SchemaRuleClassMap_t

typedef std::map< std::string, std::string >	SchemaRuleMap_t

typedef std::list< std::pair< ROOT::Internal::TSchemaType, std::string > >	SourceTypeList_t

using	TDataFrame = ROOT::RDataFrame

using	TSeqI = TSeq< int >

using	TSeqL = TSeq< long >

using	TSeqU = TSeq< unsigned int >

using	TSeqUL = TSeq< unsigned long >

using	UInt32_v = UInt_t

using	UInt_v = UInt_t

Enumerations
enum	ECompressionAlgorithm { kUseGlobalCompressionSetting = RCompressionSetting::EAlgorithm::kUseGlobal , kUseGlobalSetting = RCompressionSetting::EAlgorithm::kUseGlobal , kZLIB = RCompressionSetting::EAlgorithm::kZLIB , kLZMA = RCompressionSetting::EAlgorithm::kLZMA , kOldCompressionAlgo = RCompressionSetting::EAlgorithm::kOldCompressionAlgo , kLZ4 = RCompressionSetting::EAlgorithm::kLZ4 , kZSTD = RCompressionSetting::EAlgorithm::kZSTD , kUndefinedCompressionAlgorithm = RCompressionSetting::EAlgorithm::kUndefined }

enum class	EExecutionPolicy { kSequential , kMultiThread , kMultiProcess }

enum class	EFromHumanReadableSize { kSuccess , kParseFail , kOverflow }

enum	EFunctionMatchMode { kExactMatch = 0 , kConversionMatch = 1 }

enum class	EIOFeatures { kSupported = 0 }

enum	ESTLType { kNotSTL = 0 , kSTLvector = 1 , kSTLlist = 2 , kSTLdeque = 3 , kSTLmap = 4 , kSTLmultimap = 5 , kSTLset = 6 , kSTLmultiset = 7 , kSTLbitset = 8 , kSTLforwardlist = 9 , kSTLunorderedset = 10 , kSTLunorderedmultiset = 11 , kSTLunorderedmap = 12 , kSTLunorderedmultimap = 13 , kROOTRVec = 14 , kSTLend = 15 , kSTLany = 300 , kSTLstring = 365 }

enum	EThreadSlotReservation { kMaxUserThreadSlot = 20 , kPadThreadSlot = 20 , kClassThreadSlot = 21 , kFileThreadSlot = 23 , kPerfStatsThreadSlot = 24 , kMaxThreadSlot = 25 }

Functions
class	_NAME2_ (_R__UNIQUE_(_NAME2_(R__dummyholder, default)), _c)

class	_NAME2_ (_R__UNIQUE_(R__dummyStreamer), _c)

class	_NAME2_ (_R__UNIQUE_(R__dummyVersionNumber), _c)

void	AddClass (const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits)
	Global function called by the ctor of a class's init class (see the ClassImp macro).

void	AddClass (const char *cname, Version_t id, DictFuncPtr_t dict, Int_t pragmabits)

ROOT::TClassAlt *	AddClassAlternate (const char normName, const char alternate)
	Global function called by GenerateInitInstance.

void	CallRecursiveRemoveIfNeeded (TObject &obj)
	call RecursiveRemove for obj if gROOT is valid and obj.TestBit(kMustCleanup) is true.

void	Class_ShowMembers (TClass cl, const void obj, TMemberInspector &)
	Indirect call to the implementation of ShowMember allowing [forward] declaration with out a full definition of the TClass class.

static UInt_t	ClassTableHash (const char *name, UInt_t size)

int	CompressionSettings (RCompressionSetting::EAlgorithm::EValues algorithm, int compressionLevel)

int	CompressionSettings (ROOT::ECompressionAlgorithm algorithm, int compressionLevel)
	Deprecated name, do not use:

TClass *	CreateClass (const char cname, Version_t id, const char dfil, const char *ifil, Int_t dl, Int_t il)
	Global function called by a class' static Dictionary() method (see the ClassDef macro).

TClass *	CreateClass (const char cname, Version_t id, const std::type_info &info, TVirtualIsAProxy isa, const char dfil, const char ifil, Int_t dl, Int_t il)
	Global function called by a class' static Dictionary() method (see the ClassDef macro).

void	DisableImplicitMT ()
	Disables the implicit multi-threading in ROOT (see EnableImplicitMT).

void	EnableImplicitMT (UInt_t numthreads=0)
	Enable ROOT's implicit multi-threading for all objects and methods that provide an internal parallelisation mechanism.

void	EnableThreadSafety ()
	Enable support for multi-threading within the ROOT code in particular, enables the global mutex to make ROOT thread safe/aware.

static std::string::size_type	FindEndSymbol (std::string &command)

template<typename T >
EFromHumanReadableSize	FromHumanReadableSize (ROOT::Internal::TStringView str, T &value)

template<typename T >
EFromHumanReadableSize	FromHumanReadableSize (std::string_view str, T &value)
	Convert strings like the following into byte counts 5MB, 5 MB, 5M, 3.7GB, 123b, 456kB, 3.7GiB, 5MiB with some amount of forgiveness baked into the parsing.

template<typename T >
TClass *	GetClass (const T *)

template<typename T >
TClass *	GetClass (const T **)

template<typename T >
TClass *	GetClass (const T const )

template<typename T >
TClass *	GetClass (T *)

template<typename T >
TClass *	GetClass (T **)

std::vector< std::unique_ptr< TClassRec > > &	GetDelayedAddClass ()

std::vector< std::pair< const char , const char > > &	GetDelayedAddClassAlternate ()

TString &	GetMacroPath ()

TROOT *	GetROOT ()

void	GetRuleIncludes (std::list< std::string > &result)
	Get the list of includes specified in the shema rules.

UInt_t	GetThreadPoolSize ()
	Returns the size of ROOT's thread pool.

bool	HasValidDataMembers (SchemaRuleMap_t &rule, MembersTypeMap_t &members, std::string &error_string)
	Check if given rule contains references to valid data members.

Bool_t	IsImplicitMTEnabled ()
	Returns true if the implicit multi-threading in ROOT is enabled.

template<class T >
TSeq< T >	MakeSeq (T begin, T end, T step=1)

template<class T >
TSeq< T >	MakeSeq (T end)

bool	ParseRule (std::string command, ROOT::Internal::MembersMap_t &result, std::string &error_string)
	Parse the schema rule as specified in the LinkDef file.

void	ProcessReadPragma (const char *args, std::string &error_string)
	I am being called when a read pragma is encountered.

void	ProcessReadRawPragma (const char *args, std::string &error_string)
	I am being called then a readraw pragma is encountered.

template<typename T , typename Range_t >
RRangeCast< T, true, Range_t >	RangeDynCast (Range_t &&coll)
	Takes any collection that can be used in range-based loops and applies dynamic_cast<T> to each element.

template<typename T , typename U , std::size_t N>
RRangeCast< T, true, std::span< U > >	RangeDynCast (U(&arr)[N])

template<typename T , typename Range_t >
RRangeCast< T, false, Range_t >	RangeStaticCast (Range_t &&coll)
	Takes any collection that can be used in range-based loops and applies static_cast<T> to each element.

template<typename T , typename U , std::size_t N>
RRangeCast< T, false, std::span< U > >	RangeStaticCast (U(&arr)[N])

TNamed *	RegisterClassTemplate (const char name, const char file, Int_t line)
	Global function to register the implementation file and line of a class template (i.e.

void	RemoveClass (const char cname, TClass cl)
	Global function called by the dtor of a class's init class (see the ClassImp macro).

void	RemoveClassAlternate (ROOT::TClassAlt *)

void	ResetClassVersion (TClass , const char , Short_t)
	Global function to update the version number.

template<class RootClass >
Short_t	SetClassVersion (RootClass *)

std::vector< std::string >	Split (std::string_view str, std::string_view delims, bool skipEmpty)
	Splits a string at each character in delims.

static void	StrReplace (std::string &proc, const std::string &pat, const std::string &tr)
	Replace all accurances of given string with other string.

template<typename value_type >
void	ToHumanReadableSize (value_type bytes, Bool_t si, Double_t coeff, const char *units)
	Return the size expressed in 'human readable' format.

static Bool_t	ValidateRule (const std::map< std::string, std::string > &rule, std::string &error_string)
	Validate if the user specified rules are correct.

static void	WriteAutoVariables (const std::list< std::string > &target, const SourceTypeList_t &source, MembersTypeMap_t &members, std::string &className, std::string &mappedName, std::ostream &output)
	Write down the sources.

void	WriteReadRawRuleFunc (SchemaRuleMap_t &rule, int index, std::string &mappedName, MembersTypeMap_t &members, std::ostream &output)
	Write the conversion function for ReadRaw rule, the function name is being written to rule["funcname"].

void	WriteReadRuleFunc (SchemaRuleMap_t &rule, int index, std::string &mappedName, MembersTypeMap_t &members, std::ostream &output)
	Write the conversion function for Read rule, the function name is being written to rule["funcname"].

void	WriteSchemaList (std::list< SchemaRuleMap_t > &rules, const std::string &listName, std::ostream &output)
	Write schema rules.

Variables
R__EXTERN TVirtualRWMutex *	gCoreMutex = nullptr

R__EXTERN SchemaRuleClassMap_t	gReadRawRules

R__EXTERN SchemaRuleClassMap_t	gReadRules

Detailed Description

This file contains a specialised ROOT message handler to test for diagnostic in unit tests.

Class RooRealSumFunc implements a PDF constructed from a sum of functions:

A space to attach TBranches.

Namespace for new ROOT classes and functions.

VSD Structures.

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

Author: Stephan Hageboeck steph.nosp@m.an.h.nosp@m.agebo.nosp@m.eck@.nosp@m.cern..nosp@m.ch

              Sum(i=1,n-1) coef_i * func_i(x) + [ 1 - (Sum(i=1,n-1) coef_i ] * func_n(x)
pdf(x) =    ------------------------------------------------------------------------------
          Sum(i=1,n-1) coef_i * Int(func_i)dx + [ 1 - (Sum(i=1,n-1) coef_i ] * Int(func_n)dx

where coef_i and func_i are RooAbsReal objects, and x is the collection of dependents. In the present version coef_i may not depend on x, but this limitation may be removed in the future

Difference between RooAddPdf / RooRealSum{Func|Pdf}

RooAddPdf is a PDF of PDFs, i.e. its components need to be normalised and non-negative.
RooRealSumPdf is a PDF of functions, i.e., its components can be negative, but their sum cannot be. The normalisation is computed automatically, unless the PDF is extended (see above).
RooRealSumFunc is a sum of functions. It is neither normalised, nor need it be positive.

Typedef Documentation

◆ ColumnNamesPtr_t

using ROOT::ColumnNamesPtr_t = typedef std::shared_ptr<const ColumnNames_t>

Definition at line 1362 of file RDataFrame.cxx.

◆ DelArrFunc_t

typedef void(* ROOT::DelArrFunc_t) (void *)

Definition at line 112 of file Rtypes.h.

◆ DelFunc_t

typedef void(* ROOT::DelFunc_t) (void *)

Definition at line 111 of file Rtypes.h.

◆ DesFunc_t

typedef void(* ROOT::DesFunc_t) (void *)

Definition at line 113 of file Rtypes.h.

◆ DirAutoAdd_t

typedef void(* ROOT::DirAutoAdd_t) (void *, TDirectory *)

Definition at line 114 of file Rtypes.h.

◆ Double_v

using ROOT::Double_v = typedef Double_t

Definition at line 56 of file Types.h.

◆ Float_v

using ROOT::Float_v = typedef Float_t

Definition at line 55 of file Types.h.

◆ Int32_v

using ROOT::Int32_v = typedef Int_t

Definition at line 58 of file Types.h.

◆ Int_v

using ROOT::Int_v = typedef Int_t

Definition at line 57 of file Types.h.

◆ MembersTypeMap_t

typedef std::map<std::string, ROOT::Internal::TSchemaType> ROOT::MembersTypeMap_t

Definition at line 27 of file RConversionRuleParser.h.

◆ MergeFunc_t

typedef Long64_t(* ROOT::MergeFunc_t) (void *, TCollection *, TFileMergeInfo *)

Definition at line 115 of file Rtypes.h.

◆ NewArrFunc_t

typedef void *(* ROOT::NewArrFunc_t) (Long_t size, void *arena)

Definition at line 110 of file Rtypes.h.

◆ NewFunc_t

typedef void *(* ROOT::NewFunc_t) (void *)

Definition at line 109 of file Rtypes.h.

◆ ResetAfterMergeFunc_t

typedef void(* ROOT::ResetAfterMergeFunc_t) (void *, TFileMergeInfo *)

Definition at line 116 of file Rtypes.h.

◆ RVecB

using ROOT::RVecB = typedef ROOT::VecOps::RVec<bool>

Definition at line 3295 of file RVec.hxx.

◆ RVecC

using ROOT::RVecC = typedef ROOT::VecOps::RVec<char>

Definition at line 3296 of file RVec.hxx.

◆ RVecD

using ROOT::RVecD = typedef ROOT::VecOps::RVec<double>

Definition at line 3297 of file RVec.hxx.

◆ RVecF

using ROOT::RVecF = typedef ROOT::VecOps::RVec<float>

Definition at line 3298 of file RVec.hxx.

◆ RVecI

using ROOT::RVecI = typedef ROOT::VecOps::RVec<int>

Definition at line 3299 of file RVec.hxx.

◆ RVecL

using ROOT::RVecL = typedef ROOT::VecOps::RVec<long int>

Definition at line 3300 of file RVec.hxx.

◆ RVecLL

using ROOT::RVecLL = typedef ROOT::VecOps::RVec<long long int>

Definition at line 3301 of file RVec.hxx.

◆ RVecU

using ROOT::RVecU = typedef ROOT::VecOps::RVec<unsigned int>

Definition at line 3302 of file RVec.hxx.

◆ RVecUL

using ROOT::RVecUL = typedef ROOT::VecOps::RVec<unsigned long int>

Definition at line 3303 of file RVec.hxx.

◆ RVecULL

using ROOT::RVecULL = typedef ROOT::VecOps::RVec<unsigned long long int>

Definition at line 3304 of file RVec.hxx.

◆ SchemaRuleClassMap_t

typedef std::map<std::string, std::list<SchemaRuleMap_t> > ROOT::SchemaRuleClassMap_t

Definition at line 23 of file RConversionRuleParser.h.

◆ SchemaRuleMap_t

typedef std::map<std::string, std::string> ROOT::SchemaRuleMap_t

Definition at line 22 of file RConversionRuleParser.h.

◆ SourceTypeList_t

typedef std::list<std::pair<ROOT::Internal::TSchemaType,std::string> > ROOT::SourceTypeList_t

Definition at line 51 of file RConversionRuleParser.cxx.

◆ TDataFrame

using ROOT::TDataFrame = typedef ROOT::RDataFrame

Definition at line 16 of file TDataFrame.hxx.

◆ TSeqI

using ROOT::TSeqI = typedef TSeq<int>

Definition at line 203 of file TSeq.hxx.

◆ TSeqL

using ROOT::TSeqL = typedef TSeq<long>

Definition at line 205 of file TSeq.hxx.

◆ TSeqU

using ROOT::TSeqU = typedef TSeq<unsigned int>

Definition at line 204 of file TSeq.hxx.

◆ TSeqUL

using ROOT::TSeqUL = typedef TSeq<unsigned long>

Definition at line 206 of file TSeq.hxx.

◆ UInt32_v

using ROOT::UInt32_v = typedef UInt_t

Definition at line 60 of file Types.h.

◆ UInt_v

using ROOT::UInt_v = typedef UInt_t

Definition at line 59 of file Types.h.

Enumeration Type Documentation

◆ ECompressionAlgorithm

enum ROOT::ECompressionAlgorithm

Enumerator
kUseGlobalCompressionSetting	Deprecated name, do not use:
kUseGlobalSetting	Deprecated name, do not use:
kZLIB	Deprecated name, do not use:
kLZMA	Deprecated name, do not use:
kOldCompressionAlgo	Deprecated name, do not use:
kLZ4	Deprecated name, do not use:
kZSTD	Deprecated name, do not use:
kUndefinedCompressionAlgorithm	Deprecated name, do not use:

Definition at line 105 of file Compression.h.

◆ EExecutionPolicy

enum class ROOT::EExecutionPolicy

strong

Enumerator
kSequential
kMultiThread
kMultiProcess

Definition at line 5 of file EExecutionPolicy.hxx.

◆ EFromHumanReadableSize

enum class ROOT::EFromHumanReadableSize

strong

Enumerator
kSuccess
kParseFail
kOverflow

Definition at line 69 of file StringConv.hxx.

◆ EFunctionMatchMode

enum ROOT::EFunctionMatchMode

Enumerator
kExactMatch
kConversionMatch

Definition at line 160 of file TDictionary.h.

◆ EIOFeatures

enum class ROOT::EIOFeatures

strong

Enumerator
kSupported

Definition at line 39 of file TIOFeatures.hxx.

◆ ESTLType

enum ROOT::ESTLType

Enumerator
kNotSTL
kSTLvector
kSTLlist
kSTLdeque
kSTLmap
kSTLmultimap
kSTLset
kSTLmultiset
kSTLbitset
kSTLforwardlist
kSTLunorderedset
kSTLunorderedmultiset
kSTLunorderedmap
kSTLunorderedmultimap
kROOTRVec
kSTLend
kSTLany
kSTLstring

Definition at line 28 of file ESTLType.h.

◆ EThreadSlotReservation

enum ROOT::EThreadSlotReservation

Enumerator
kMaxUserThreadSlot
kPadThreadSlot
kClassThreadSlot
kFileThreadSlot
kPerfStatsThreadSlot
kMaxThreadSlot

Definition at line 19 of file TThreadSlots.h.

Function Documentation

◆ _NAME2_() [1/3]

class ROOT::_NAME2_	(	_R__UNIQUE_(_NAME2_(R__dummyholder, default))	,
		_c
	)

Definition at line 1 of file TParameter.cxx.

◆ _NAME2_() [2/3]

class ROOT::_NAME2_	(	_R__UNIQUE_(R__dummyStreamer)	,
		_c
	)

Definition at line 25 of file String.cxx.

◆ _NAME2_() [3/3]

class ROOT::_NAME2_	(	_R__UNIQUE_(R__dummyVersionNumber)	,
		_c
	)

Definition at line 25 of file String.cxx.

◆ AddClass() [1/2]

void ROOT::AddClass	(	const char *	cname,
		Version_t	id,
		const std::type_info &	info,
		DictFuncPtr_t	dict,
		Int_t	pragmabits
	)

Global function called by the ctor of a class's init class (see the ClassImp macro).

Definition at line 903 of file TClassTable.cxx.

◆ AddClass() [2/2]

void ROOT::AddClass	(	const char *	cname,
		Version_t	id,
		DictFuncPtr_t	dict,
		Int_t	pragmabits
	)

◆ AddClassAlternate()

ROOT::TClassAlt * ROOT::AddClassAlternate	(	const char *	normName,
		const char *	alternate
	)

Global function called by GenerateInitInstance.

(see the ClassImp macro).

Definition at line 925 of file TClassTable.cxx.

◆ CallRecursiveRemoveIfNeeded()

void ROOT::CallRecursiveRemoveIfNeeded ( TObject & obj )

inline

call RecursiveRemove for obj if gROOT is valid and obj.TestBit(kMustCleanup) is true.

Note: this reset the kMustCleanup bit to allow harmless multiple call to this function.

Definition at line 394 of file TROOT.h.

◆ Class_ShowMembers()

void ROOT::Class_ShowMembers	(	TClass *	cl,
		const void *	obj,
		TMemberInspector &	insp
	)

Indirect call to the implementation of ShowMember allowing [forward] declaration with out a full definition of the TClass class.

Definition at line 546 of file TClass.cxx.

◆ ClassTableHash()

static UInt_t ROOT::ClassTableHash	(	const char *	name,
		UInt_t	size
	)

static

Definition at line 234 of file TClassTable.cxx.

◆ CompressionSettings() [1/2]

int ROOT::CompressionSettings	(	RCompressionSetting::EAlgorithm::EValues	algorithm,
		int	compressionLevel
	)

◆ CompressionSettings() [2/2]

int ROOT::CompressionSettings	(	ROOT::ECompressionAlgorithm	algorithm,
		int	compressionLevel
	)

Deprecated name, do not use:

◆ CreateClass() [1/2]

TClass * ROOT::CreateClass	(	const char *	cname,
		Version_t	id,
		const char *	dfil,
		const char *	ifil,
		Int_t	dl,
		Int_t	il
	)

Global function called by a class' static Dictionary() method (see the ClassDef macro).

Definition at line 5884 of file TClass.cxx.

◆ CreateClass() [2/2]

TClass * ROOT::CreateClass	(	const char *	cname,
		Version_t	id,
		const std::type_info &	info,
		TVirtualIsAProxy *	isa,
		const char *	dfil,
		const char *	ifil,
		Int_t	dl,
		Int_t	il
	)

Global function called by a class' static Dictionary() method (see the ClassDef macro).

Definition at line 5869 of file TClass.cxx.

◆ DisableImplicitMT()

void ROOT::DisableImplicitMT ( )

Disables the implicit multi-threading in ROOT (see EnableImplicitMT).

Definition at line 544 of file TROOT.cxx.

◆ EnableImplicitMT()

void ROOT::EnableImplicitMT ( UInt_t numthreads = 0 )

Enable ROOT's implicit multi-threading for all objects and methods that provide an internal parallelisation mechanism.

Parameters

[in] numthreads Number of threads to use. If not specified or set to zero, the number of threads is automatically decided by the implementation. Any other value is used as a hint.

ROOT must be built with the compilation flag imt=ON for this feature to be available. The following objects and methods automatically take advantage of multi-threading if a call to EnableImplicitMT has been made before usage:

RDataFrame internally runs the event-loop by parallelizing over clusters of entries
TTree::GetEntry reads multiple branches in parallel
TTree::FlushBaskets writes multiple baskets to disk in parallel
TTreeCacheUnzip decompresses the baskets contained in a TTreeCache in parallel
THx::Fit performs in parallel the evaluation of the objective function over the data
TMVA::DNN trains the deep neural networks in parallel
TMVA::BDT trains the classifier in parallel and multiclass BDTs are evaluated in parallel

EnableImplicitMT calls in turn EnableThreadSafety. The 'numthreads' parameter allows to control the number of threads to be used by the implicit multi-threading. However, this parameter is just a hint for ROOT: it will try to satisfy the request if the execution scenario allows it. For example, if ROOT is configured to use an external scheduler, setting a value for 'numthreads' might not have any effect.

Note: Use DisableImplicitMT() to disable multi-threading (some locks will remain in place as described in EnableThreadSafety()). EnableImplicitMT(1) creates a thread-pool of size 1.

Definition at line 527 of file TROOT.cxx.

◆ EnableThreadSafety()

void ROOT::EnableThreadSafety ( )

Enable support for multi-threading within the ROOT code in particular, enables the global mutex to make ROOT thread safe/aware.

Enables the global mutex to make ROOT thread safe/aware.

The following becomes safe:

concurrent construction and destruction of TObjects, including the ones registered in ROOT's global lists (e.g. gROOT->GetListOfCleanups(), gROOT->GetListOfFiles())
concurrent usage of different ROOT objects from different threads, including ones with global state (e.g. TFile, TTree, TChain) with the exception of graphics classes (e.g. TCanvas)
concurrent calls to ROOT's type system classes, e.g. TClass and TEnum
concurrent calls to the interpreter through gInterpreter
concurrent loading of ROOT plug-ins

In addition, gDirectory, gFile and gPad become a thread-local variable. In all threads, gDirectory defaults to gROOT, a singleton which supports thread-safe insertion and deletion of contents. gFile and gPad default to nullptr, as it is for single-thread programs.

The ROOT graphics subsystem is not made thread-safe by this method. In particular drawing or printing different canvases from different threads (and analogous operations such as invoking Draw on a TObject) is not thread-safe.

Note that there is no DisableThreadSafety(). ROOT's thread-safety features cannot be disabled once activated.

Definition at line 493 of file TROOT.cxx.

◆ FindEndSymbol()

static std::string::size_type ROOT::FindEndSymbol ( std::string & command )

static

Definition at line 62 of file RConversionRuleParser.cxx.

◆ FromHumanReadableSize() [1/2]

template<typename T >

EFromHumanReadableSize ROOT::FromHumanReadableSize	(	ROOT::Internal::TStringView	str,
		T &	value
	)

Definition at line 158 of file StringConv.hxx.

◆ FromHumanReadableSize() [2/2]

template<typename T >

EFromHumanReadableSize ROOT::FromHumanReadableSize	(	std::string_view	str,
		T &	value
	)

Convert strings like the following into byte counts 5MB, 5 MB, 5M, 3.7GB, 123b, 456kB, 3.7GiB, 5MiB with some amount of forgiveness baked into the parsing.

For this routine we use the official SI unit where the [i] is reserved for the 'legacy' power of two units. 1KB = 1000 bytes, 1KiB = 1024 bytes.

Parameters

str	the string to be parsed
value	will be updated with the result if and only if the parse is successful and does not overflow for the type of value.

Returns: return a EFromHumanReadableSize enum value indicating the success or failure of the parse.

Definition at line 86 of file StringConv.hxx.

◆ GetClass() [1/5]

template<typename T >

TClass * ROOT::GetClass ( const T * )

Definition at line 660 of file TClass.h.

◆ GetClass() [2/5]

template<typename T >

TClass * ROOT::GetClass ( const T ** )

Definition at line 665 of file TClass.h.

◆ GetClass() [3/5]

template<typename T >

TClass * ROOT::GetClass ( const T *const * )

Definition at line 667 of file TClass.h.

◆ GetClass() [4/5]

template<typename T >

TClass * ROOT::GetClass ( T * )

Definition at line 659 of file TClass.h.

◆ GetClass() [5/5]

template<typename T >

TClass * ROOT::GetClass ( T ** )

Definition at line 664 of file TClass.h.

◆ GetDelayedAddClass()

std::vector< std::unique_ptr< TClassRec > > & ROOT::GetDelayedAddClass ( )

Definition at line 245 of file TClassTable.cxx.

◆ GetDelayedAddClassAlternate()

std::vector< std::pair< const char *, const char * > > & ROOT::GetDelayedAddClassAlternate ( )

Definition at line 251 of file TClassTable.cxx.

◆ GetMacroPath()

TString & ROOT::GetMacroPath ( )

Definition at line 468 of file TROOT.cxx.

◆ GetROOT()

TROOT * ROOT::GetROOT ( )

Definition at line 464 of file TROOT.cxx.

◆ GetRuleIncludes()

void ROOT::GetRuleIncludes ( std::list< std::string > & result )

Get the list of includes specified in the shema rules.

Definition at line 841 of file RConversionRuleParser.cxx.

◆ GetThreadPoolSize()

UInt_t ROOT::GetThreadPoolSize ( )

Returns the size of ROOT's thread pool.

Definition at line 565 of file TROOT.cxx.

◆ HasValidDataMembers()

Bool_t ROOT::HasValidDataMembers	(	SchemaRuleMap_t &	rule,
		MembersTypeMap_t &	members,
		std::string &	error_string
	)

Check if given rule contains references to valid data members.

Definition at line 447 of file RConversionRuleParser.cxx.

◆ IsImplicitMTEnabled()

bool ROOT::IsImplicitMTEnabled ( )

Returns true if the implicit multi-threading in ROOT is enabled.

Definition at line 558 of file TROOT.cxx.

◆ MakeSeq() [1/2]

template<class T >

TSeq< T > ROOT::MakeSeq	(	T	begin,
		T	end,
		T	step = `1`
	)

Definition at line 215 of file TSeq.hxx.

◆ MakeSeq() [2/2]

template<class T >

TSeq< T > ROOT::MakeSeq ( T end )

Definition at line 209 of file TSeq.hxx.

◆ ParseRule()

Bool_t ROOT::ParseRule	(	std::string	rule,
		ROOT::Internal::MembersMap_t &	result,
		std::string &	error_string
	)

Parse the schema rule as specified in the LinkDef file.

Definition at line 103 of file RConversionRuleParser.cxx.

◆ ProcessReadPragma()

void ROOT::ProcessReadPragma	(	const char *	args,
		std::string &	error_string
	)

I am being called when a read pragma is encountered.

Definition at line 885 of file RConversionRuleParser.cxx.

◆ ProcessReadRawPragma()

void ROOT::ProcessReadRawPragma	(	const char *	args,
		std::string &	error_string
	)

I am being called then a readraw pragma is encountered.

Definition at line 921 of file RConversionRuleParser.cxx.

◆ RangeDynCast() [1/2]

template<typename T , typename Range_t >

RRangeCast< T, true, Range_t > ROOT::RangeDynCast ( Range_t && coll )

Takes any collection that can be used in range-based loops and applies dynamic_cast<T> to each element.

This function can be used for example to cast all objects in a RooAbsCollection when iterating over them. Example:

class ClassA {
public:
   virtual ~ClassA() {}
};
class ClassB : public ClassA {
};
 
A a1, a2;
B b1, b2, b3;
std::vector<A const*> vec{&b1, &a1, &b2, &a2, &b3};
 
for(auto *b : ROOT::RangeDynCast<B const*>(vec)) {
   if(b) {
      // do something with b
   }
}

Make sure to not use auto const& in the range-based loop, as this will cause a range-loop-bind-reference warning with the clang compiler.

Definition at line 217 of file RRangeCast.hxx.

◆ RangeDynCast() [2/2]

template<typename T , typename U , std::size_t N>

RRangeCast< T, true, std::span< U > > ROOT::RangeDynCast ( U(&) arr[N] )

Definition at line 225 of file RRangeCast.hxx.

◆ RangeStaticCast() [1/2]

template<typename T , typename Range_t >

RRangeCast< T, false, Range_t > ROOT::RangeStaticCast ( Range_t && coll )

Takes any collection that can be used in range-based loops and applies static_cast<T> to each element.

This function can be used for example to cast all objects in a RooAbsCollection when iterating over them. Example:

class ClassA {
public:
   virtual ~ClassA() {}
};
class ClassB : public ClassA {
};
 
B b1, b2, b3;
std::vector<A const*> vec{&b1, &b2, &b3};
 
for(auto *b : ROOT::RangeStaticCast<B const*>(vec)) {
   // do something with b
}

Make sure to not use auto const& in the range-based loop, as this will cause a range-loop-bind-reference warning with the clang compiler.

Definition at line 178 of file RRangeCast.hxx.

◆ RangeStaticCast() [2/2]

template<typename T , typename U , std::size_t N>

RRangeCast< T, false, std::span< U > > ROOT::RangeStaticCast ( U(&) arr[N] )

Definition at line 186 of file RRangeCast.hxx.

◆ RegisterClassTemplate()

TNamed * ROOT::RegisterClassTemplate	(	const char *	name,
		const char *	file,
		Int_t	line
	)

Global function to register the implementation file and line of a class template (i.e.

NOT a concrete class).

Definition at line 1012 of file TClassTable.cxx.

◆ RemoveClass()

void ROOT::RemoveClass	(	const char *	cname,
		TClass *	cl
	)

Global function called by the dtor of a class's init class (see the ClassImp macro).

Definition at line 992 of file TClassTable.cxx.

◆ RemoveClassAlternate()

void ROOT::RemoveClassAlternate ( ROOT::TClassAlt * alt )

Definition at line 938 of file TClassTable.cxx.

◆ ResetClassVersion()

void ROOT::ResetClassVersion	(	TClass *	cl,
		const char *	cname,
		Short_t	newid
	)

Global function to update the version number.

This is called via the RootClassVersion macro.

if cl!=0 and cname==-1, set the new class version if and only is greater than the existing one and greater or equal to 2; and also ignore the request if fVersionUsed is true.

Note on class version number:

If no class has been specified, TClass::GetVersion will return -1
The Class Version 0 request the whole object to be transient
The Class Version 1, unless specify via ClassDef indicates that the I/O should use the TClass checksum to distinguish the layout of the class

Definition at line 958 of file TClassTable.cxx.

◆ SetClassVersion()

template<class RootClass >

Short_t ROOT::SetClassVersion ( RootClass * )

◆ Split()

std::vector< std::string > ROOT::Split	(	std::string_view	str,
		std::string_view	delims,
		bool	skipEmpty
	)

Splits a string at each character in delims.

The behavior mimics str.split from Python,

Parameters

[in]	str	String to tokenise.
[in]	delims	One or more delimiters used to split the string.
[in]	skipEmpty	Strip empty strings from the output.

Definition at line 23 of file StringUtils.cxx.

◆ StrReplace()

static void ROOT::StrReplace	(	std::string &	proc,
		const std::string &	pat,
		const std::string &	tr
	)

static

Replace all accurances of given string with other string.

Definition at line 743 of file RConversionRuleParser.cxx.

◆ ToHumanReadableSize()

template<typename value_type >

void ROOT::ToHumanReadableSize	(	value_type	bytes,
		Bool_t	si,
		Double_t *	coeff,
		const char **	units
	)

Return the size expressed in 'human readable' format.

Parameters

bytes	the size in bytes to be converted
si	whether to use the SI units or not.
coeff	return the size expressed in the new unit.
units	return a pointer to the string representation of the new unit

Definition at line 38 of file StringConv.hxx.

◆ ValidateRule()

static Bool_t ROOT::ValidateRule	(	const std::map< std::string, std::string > &	rule,
		std::string &	error_string
	)

static

Validate if the user specified rules are correct.

Definition at line 277 of file RConversionRuleParser.cxx.

◆ WriteAutoVariables()

static void ROOT::WriteAutoVariables	(	const std::list< std::string > &	target,
		const SourceTypeList_t &	source,
		MembersTypeMap_t &	members,
		std::string &	className,
		std::string &	mappedName,
		std::ostream &	output
	)

static

Write down the sources.

Definition at line 476 of file RConversionRuleParser.cxx.

◆ WriteReadRawRuleFunc()

void ROOT::WriteReadRawRuleFunc	(	SchemaRuleMap_t &	rule,
		int	index,
		std::string &	mappedName,
		MembersTypeMap_t &	members,
		std::ostream &	output
	)

Write the conversion function for ReadRaw rule, the function name is being written to rule["funcname"].

Definition at line 694 of file RConversionRuleParser.cxx.

◆ WriteReadRuleFunc()

void ROOT::WriteReadRuleFunc	(	SchemaRuleMap_t &	rule,
		int	index,
		std::string &	mappedName,
		MembersTypeMap_t &	members,
		std::ostream &	output
	)

Write the conversion function for Read rule, the function name is being written to rule["funcname"].

Definition at line 641 of file RConversionRuleParser.cxx.

◆ WriteSchemaList()

void ROOT::WriteSchemaList	(	std::list< SchemaRuleMap_t > &	rules,
		const std::string &	listName,
		std::ostream &	output
	)

Write schema rules.

Definition at line 765 of file RConversionRuleParser.cxx.

Variable Documentation

◆ gCoreMutex

ROOT::TVirtualRWMutex * ROOT::gCoreMutex = nullptr

Definition at line 37 of file TVirtualRWMutex.h.

◆ gReadRawRules

SchemaRuleClassMap_t ROOT::gReadRawRules

Definition at line 25 of file RConversionRuleParser.h.

◆ gReadRules

SchemaRuleClassMap_t ROOT::gReadRules

Definition at line 24 of file RConversionRuleParser.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Difference between RooAddPdf / RooRealSum{Func|Pdf}

Typedef Documentation

◆ ColumnNamesPtr_t

◆ DelArrFunc_t

◆ DelFunc_t

◆ DesFunc_t

◆ DirAutoAdd_t

◆ Double_v

◆ Float_v

◆ Int32_v

◆ Int_v

◆ MembersTypeMap_t

◆ MergeFunc_t

◆ NewArrFunc_t

◆ NewFunc_t

◆ ResetAfterMergeFunc_t

◆ RVecB

◆ RVecC

◆ RVecD

◆ RVecF

◆ RVecI

◆ RVecL

◆ RVecLL

◆ RVecU

◆ RVecUL

◆ RVecULL

◆ SchemaRuleClassMap_t

◆ SchemaRuleMap_t

◆ SourceTypeList_t

◆ TDataFrame

◆ TSeqI

◆ TSeqL

◆ TSeqU

◆ TSeqUL

◆ UInt32_v

◆ UInt_v

Enumeration Type Documentation

◆ ECompressionAlgorithm

◆ EExecutionPolicy

◆ EFromHumanReadableSize

◆ EFunctionMatchMode

◆ EIOFeatures

◆ ESTLType

◆ EThreadSlotReservation

Function Documentation

◆ _NAME2_() [1/3]

◆ _NAME2_() [2/3]

◆ _NAME2_() [3/3]

◆ AddClass() [1/2]

◆ AddClass() [2/2]

◆ AddClassAlternate()

◆ CallRecursiveRemoveIfNeeded()

◆ Class_ShowMembers()

◆ ClassTableHash()

◆ CompressionSettings() [1/2]

◆ CompressionSettings() [2/2]

◆ CreateClass() [1/2]

◆ CreateClass() [2/2]

◆ DisableImplicitMT()

◆ EnableImplicitMT()

◆ EnableThreadSafety()

◆ FindEndSymbol()

◆ FromHumanReadableSize() [1/2]

◆ FromHumanReadableSize() [2/2]

◆ GetClass() [1/5]

◆ GetClass() [2/5]

◆ GetClass() [3/5]

◆ GetClass() [4/5]

◆ GetClass() [5/5]

◆ GetDelayedAddClass()

◆ GetDelayedAddClassAlternate()

◆ GetMacroPath()

◆ GetROOT()