Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
ROOT Namespace Reference

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

Namespaces

namespace  Browsable
 
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  Details
 
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  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

class  RBrowser
 Web-based ROOT files and objects browser. More...
 
class  RBrowserCatchedWidget
 
class  RBrowserData
 Way to browse (hopefully) everything in ROOT. More...
 
class  RBrowserDataCleanup
 
class  RBrowserEditorWidget
 
class  RBrowserInfoWidget
 
class  RBrowserReply
 Reply on browser request. More...
 
class  RBrowserRequest
 Request send from client to get content of path element. More...
 
class  RBrowserTimer
 
class  RBrowserWidget
 Abstract Web-based widget, which can be used in the RBrowser Used to embed canvas, geometry viewer and potentially any other widgets. More...
 
class  RBrowserWidgetProvider
 
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  RFileDialog
 Web-based FileDialog. More...
 
class  RGeoItem
 Representation of single item in the geometry browser. More...
 
class  RGeomBrowserIter
 Iterator of hierarchical geometry structures. More...
 
class  RGeomConfig
 Configuration parameters which can be configured on the client Send as is to-from client. More...
 
class  RGeomDescription
 
class  RGeomDrawing
 Object with full description for drawing geometry It includes list of visible items and list of nodes required to build them. More...
 
class  RGeomHierarchy
 
class  RGeomNode
 Full node description including matrices and other attributes. More...
 
class  RGeomNodeBase
 Base description of geometry node, required only to build hierarchy. More...
 
class  RGeomNodeInfo
 Node information including rendering data. More...
 
class  RGeomNodeVisibility
 Custom settings for physical Node visibility. More...
 
class  RGeomRawRenderInfo
 Render info with raw data. More...
 
class  RGeomRenderInfo
 Base class for render info block. More...
 
class  RGeomShapeRenderInfo
 Render info with shape itself - client can produce shape better. More...
 
class  RGeomViewer
 
class  RGeomVisible
 RGeomVisible contains description of visible node It is path to the node plus reference to shape rendering data. More...
 
class  RGeoPainter
 
class  ROpaqueTaskArena
 
struct  RQt5CreatorReg
 
class  RQt5WebDisplayHandle
 
struct  RQt6CreatorReg
 
class  RQt6WebDisplayHandle
 
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  RTreeDrawInvokeTimer
 
class  RTreeDrawMonitoring
 
class  RTreeViewer
 
class  RWebBrowserHandle
 Specialized handle to hold information about running browser process Used to correctly cleanup all processes and temporary directories. More...
 
class  RWebBrowserImp
 
class  RWebDisplayArgs
 Holds different arguments for starting browser with RWebDisplayHandle::Display() method. More...
 
class  RWebDisplayHandle
 Handle of created web-based display Depending from type of web display, holds handle of started browser process or other display-specific information to correctly stop and cleanup display. More...
 
class  RWebWindow
 Represents web window, which can be shown in web browser or any other supported environment. More...
 
class  RWebWindowsManager
 Central instance to create and show web-based windows like Canvas or FitPanel. More...
 
class  RWebWindowWSHandler
 just wrapper to deliver websockets call-backs to the RWebWindow class 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::TSchemaTypeMembersTypeMap_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 RFileDialogCallback_t = std::function< void(const std::string &)>
 function signature for file dialog call-backs argument is selected file name
 
using RGeomScanFunc_t = std::function< bool(RGeomNode &, std::vector< int > &, bool, int)>
 
using RGeomSignalFunc_t = std::function< void(const std::string &)>
 
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
 
using WebWindowConnectCallback_t = std::function< void(unsigned)>
 function signature for connect/disconnect call-backs argument is connection id
 
using WebWindowDataCallback_t = std::function< void(unsigned, const std::string &)>
 function signature for call-backs from the window clients first argument is connection id, second is received data
 
using WebWindowShowCallback_t = std::function< bool(RWebWindow &, const RWebDisplayArgs &)>
 function signature for catching show calls of arbitrary RWebWindow if returns true, normal show procedure will not be invoked
 
using WebWindowWaitFunc_t = std::function< int(double)>
 function signature for waiting call-backs Such callback used when calling thread need to waits for some special data, but wants to run application event loop As argument, spent time in second will be provided Waiting will be performed until function returns non-zero value
 

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::TClassAltAddClassAlternate (const char *normName, const char *alternate)
 Global function called by GenerateInitInstance.
 
ROOT::Experimental::RLogChannelBrowsableLog ()
 Log channel for Browsable diagnostics.
 
ROOT::Experimental::RLogChannelBrowserLog ()
 Log channel for Browser diagnostics.
 
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:
 
TClassCreateClass (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).
 
TClassCreateClass (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 (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 >
TClassGetClass (const T *)
 
template<typename T >
TClassGetClass (const T **)
 
template<typename T >
TClassGetClass (const T *const *)
 
template<typename T >
TClassGetClass (T *)
 
template<typename T >
TClassGetClass (T **)
 
std::vector< std::unique_ptr< TClassRec > > & GetDelayedAddClass ()
 
std::vector< std::pair< const char *, const char * > > & GetDelayedAddClassAlternate ()
 
TStringGetMacroPath ()
 
TROOTGetROOT ()
 
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 StringCollection_t >
std::string Join (const std::string &sep, StringCollection_t &&strings)
 Concatenate a list of strings with a separator \tparm Any container of strings (vector, initializer_list, ...)
 
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])
 
TNamedRegisterClassTemplate (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.
 
Experimental::RLogChannelRGeomLog ()
 Log channel for Geomviewer diagnostics.
 
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.
 
ROOT::Experimental::RLogChannelWebGUILog ()
 Log channel for WebGUI diagnostics.
 
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 TVirtualRWMutexgCoreMutex = nullptr
 
R__EXTERN SchemaRuleClassMap_t gReadRawRules
 
R__EXTERN SchemaRuleClassMap_t gReadRules
 
struct ROOT::RQt5CreatorReg newRQt5CreatorReg
 
struct ROOT::RQt6CreatorReg newRQt6CreatorReg
 

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:

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
Double_t x[n]
Definition legend1.C:17
const Int_t n
Definition legend1.C:16

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 1529 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 55 of file Types.h.

◆ Float_v

using ROOT::Float_v = typedef Float_t

Definition at line 54 of file Types.h.

◆ Int32_v

using ROOT::Int32_v = typedef Int_t

Definition at line 57 of file Types.h.

◆ Int_v

using ROOT::Int_v = typedef Int_t

Definition at line 56 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.

◆ RFileDialogCallback_t

using ROOT::RFileDialogCallback_t = typedef std::function<void(const std::string &)>

function signature for file dialog call-backs argument is selected file name

Definition at line 36 of file RFileDialog.hxx.

◆ RGeomScanFunc_t

using ROOT::RGeomScanFunc_t = typedef std::function<bool(RGeomNode &, std::vector<int> &, bool, int)>

Definition at line 206 of file RGeomData.hxx.

◆ RGeomSignalFunc_t

using ROOT::RGeomSignalFunc_t = typedef std::function<void(const std::string &)>

Definition at line 208 of file RGeomData.hxx.

◆ RVecB

Definition at line 3387 of file RVec.hxx.

◆ RVecC

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

Definition at line 3388 of file RVec.hxx.

◆ RVecD

Definition at line 3389 of file RVec.hxx.

◆ RVecF

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

Definition at line 3390 of file RVec.hxx.

◆ RVecI

Definition at line 3391 of file RVec.hxx.

◆ RVecL

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

Definition at line 3392 of file RVec.hxx.

◆ RVecLL

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

Definition at line 3393 of file RVec.hxx.

◆ RVecU

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

Definition at line 3394 of file RVec.hxx.

◆ RVecUL

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

Definition at line 3395 of file RVec.hxx.

◆ RVecULL

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

Definition at line 3396 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

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 59 of file Types.h.

◆ UInt_v

using ROOT::UInt_v = typedef UInt_t

Definition at line 58 of file Types.h.

◆ WebWindowConnectCallback_t

using ROOT::WebWindowConnectCallback_t = typedef std::function<void(unsigned)>

function signature for connect/disconnect call-backs argument is connection id

Definition at line 35 of file RWebWindow.hxx.

◆ WebWindowDataCallback_t

using ROOT::WebWindowDataCallback_t = typedef std::function<void(unsigned, const std::string &)>

function signature for call-backs from the window clients first argument is connection id, second is received data

Definition at line 39 of file RWebWindow.hxx.

◆ WebWindowShowCallback_t

using ROOT::WebWindowShowCallback_t = typedef std::function<bool(RWebWindow &, const RWebDisplayArgs &)>

function signature for catching show calls of arbitrary RWebWindow if returns true, normal show procedure will not be invoked

Definition at line 34 of file RWebWindowsManager.hxx.

◆ WebWindowWaitFunc_t

using ROOT::WebWindowWaitFunc_t = typedef std::function<int(double)>

function signature for waiting call-backs Such callback used when calling thread need to waits for some special data, but wants to run application event loop As argument, spent time in second will be provided Waiting will be performed until function returns non-zero value

Definition at line 46 of file RWebWindow.hxx.

Enumeration Type Documentation

◆ 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 109 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

Enumerator
kExactMatch 
kConversionMatch 

Definition at line 161 of file TDictionary.h.

◆ EIOFeatures

enum class ROOT::EIOFeatures
strong
Enumerator
kSupported 

Definition at line 39 of file TIOFeatures.hxx.

◆ 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

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 896 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 918 of file TClassTable.cxx.

◆ BrowsableLog()

ROOT::Experimental::RLogChannel & ROOT::BrowsableLog ( )

Log channel for Browsable diagnostics.

Definition at line 20 of file RElement.cxx.

◆ BrowserLog()

ROOT::Experimental::RLogChannel & ROOT::BrowserLog ( )

Log channel for Browser diagnostics.

Definition at line 35 of file RBrowserData.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 395 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 237 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 554 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]numthreadsNumber 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. The maximum number of threads can be influenced by the environment variable ROOT_MAX_THREADS: export ROOT_MAX_THREADS=2 will try to set the maximum number of active threads to 2, if the scheduling library (such as tbb) "permits".

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 537 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 499 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()

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
strthe string to be parsed
valuewill 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 248 of file TClassTable.cxx.

◆ GetDelayedAddClassAlternate()

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

Definition at line 254 of file TClassTable.cxx.

◆ GetMacroPath()

TString & ROOT::GetMacroPath ( )

Definition at line 474 of file TROOT.cxx.

◆ GetROOT()

TROOT * ROOT::GetROOT ( )

Definition at line 470 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 855 of file RConversionRuleParser.cxx.

◆ GetThreadPoolSize()

UInt_t ROOT::GetThreadPoolSize ( )

Returns the size of ROOT's thread pool.

Definition at line 575 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 461 of file RConversionRuleParser.cxx.

◆ IsImplicitMTEnabled()

bool ROOT::IsImplicitMTEnabled ( )

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

Definition at line 568 of file TROOT.cxx.

◆ Join()

template<class StringCollection_t >
std::string ROOT::Join ( const std::string &  sep,
StringCollection_t &&  strings 
)

Concatenate a list of strings with a separator \tparm Any container of strings (vector, initializer_list, ...)

Parameters
[in]sepSeparator inbetween the strings.
[in]stringscontainer of strings
Returns
the sep-delimited concatenation of strings

Definition at line 35 of file StringUtils.hxx.

◆ MakeSeq() [1/2]

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

Definition at line 215 of file TSeq.hxx.

◆ MakeSeq() [2/2]

template<class T >
TSeq< T > ROOT::MakeSeq ( 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 899 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 935 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
}
}
#define b(i)
Definition RSha256.hxx:100
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
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 elemen...

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
}
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...

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 1005 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 985 of file TClassTable.cxx.

◆ RemoveClassAlternate()

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

Definition at line 931 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 951 of file TClassTable.cxx.

◆ RGeomLog()

ROOT::Experimental::RLogChannel & ROOT::RGeomLog ( )

Log channel for Geomviewer diagnostics.

Definition at line 49 of file RGeomData.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]strString to tokenise.
[in]delimsOne or more delimiters used to split the string.
[in]skipEmptyStrip 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 757 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
bytesthe size in bytes to be converted
siwhether to use the SI units or not.
coeffreturn the size expressed in the new unit.
unitsreturn 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 291 of file RConversionRuleParser.cxx.

◆ WebGUILog()

ROOT::Experimental::RLogChannel & ROOT::WebGUILog ( )

Log channel for WebGUI diagnostics.

Definition at line 24 of file RWebDisplayArgs.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 490 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 708 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 655 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 779 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.

◆ newRQt5CreatorReg

struct ROOT::RQt5CreatorReg ROOT::newRQt5CreatorReg

◆ newRQt6CreatorReg

struct ROOT::RQt6CreatorReg ROOT::newRQt6CreatorReg