root · as geant3, geant4 and fluka csc11 • root 15 . geometry ... exactly as fast as e.g....
TRANSCRIPT
![Page 1: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/1.jpg)
ROOT
Bertrand Bellenot, Axel Naumann
CERN
![Page 2: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/2.jpg)
WHAT IS ROOT?
CSC11 • ROOT 2
![Page 3: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/3.jpg)
CSC11 • ROOT
What's ROOT?
3
![Page 4: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/4.jpg)
ROOT: An Open Source Project
• Started in 1995
• 7 full time developers at CERN, plus Fermilab
• Large number of part-time developers: let users participate
• Available (incl. source) under GNU LGPL
CSC11 • ROOT 4
![Page 5: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/5.jpg)
ROOT in a Nutshell
Framework for large scale data handling
Provides, among others,
– an efficient data storage, access and query system (PetaBytes)
– advanced statistical analysis algorithms (multi dimensional histogramming, fitting, minimization and cluster finding)
– scientific visualization: 2D and 3D graphics, Postscript, PDF, LateX
– geometrical modeller
– PROOF parallel query engine
CSC11 • ROOT 5
![Page 6: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/6.jpg)
CSC11 • ROOT
Graphics
6
![Page 7: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/7.jpg)
Histogramming
• Histogram is just occurrence counting, i.e. how often they appear
• Example: {1,3,2,6,2,3,4,3,4,3,5}
CSC11 • ROOT 7
![Page 8: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/8.jpg)
CSC11 • ROOT
Histogramming
• How is a Real Histogram Made? Lets consider the age distribution of the CSC participants in 2008:
Binning:
Grouping ages of participants in several categories (bins)
8
![Page 9: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/9.jpg)
Histogramming
CSC11 • ROOT 9
Shows distribution of ages, total number of entries (57 participants) and average: 27 years 10 months 6 days…
Table of Ages (binned)
![Page 10: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/10.jpg)
Histograms
Analysis result: often a histogram
Menu: View / Editor
CSC11 • ROOT 10
![Page 11: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/11.jpg)
Fitting
Analysis result: often a fit of a histogram
CSC11 • ROOT 11
![Page 12: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/12.jpg)
Fit Panel
To fit a histogram:
right click histogram,
"Fit Panel"
Straightforward interface for fitting!
CSC11 • ROOT 12
![Page 13: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/13.jpg)
2D/3D
We have seen 1D histograms, but there are
also histograms in more dimensions.
CSC11 • ROOT 13
2D Histogram 3D Histogram
![Page 14: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/14.jpg)
OpenGL
OpenGL can be used to render 2D & 3D histograms, functions, parametric equations, and to visualize 3D objects (geometry)
CSC11 • ROOT 14
![Page 15: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/15.jpg)
Geometry
• Describes complex detector geometries
• Allows visualization of these detector geometries with e.g. OpenGL
• Optimized particle transport in complex geometries
• Working in correlation with simulation packages such as GEANT3, GEANT4 and FLUKA
CSC11 • ROOT 15
![Page 16: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/16.jpg)
Geometry
CSC11 • ROOT 16
![Page 17: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/17.jpg)
EVE (Event Visualization Environment)
• Event: Collection of data from a detector (hits, tracks, …)
Use EVE to:
• Visualize these physics objects together with detector geometry (OpenGL)
• Visually interact with the data, e.g. select a particular track and retrieve its physical properties
CSC11 • ROOT 17
![Page 18: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/18.jpg)
EVE
CSC11 • ROOT 18
![Page 19: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/19.jpg)
Math
CSC11 • ROOT 19
![Page 20: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/20.jpg)
RANDOM NUMBERS Math Example:
CSC11 • ROOT 20
![Page 21: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/21.jpg)
Quasi-Random Numbers
• Needed e.g. to simulate nature: will particle interact?
• Trivial example for random number generator function: last digit of n = n + 7, say start with 0: 0, 7, 4, 1, 8, 5, 2, 9, 6, 3, 0, 7, 4, 1, 8, 5, 2, 9, 6, 3, 0, 7, 4, 1, 8, 5
• Properties:
– identical frequency of all numbers 0..9
– “looks” random, but short period: 0, 7, 4, 1, 8, 5, 2, 9, 6, 3, 0, 7, 4, 1, 8, 5, 2, 9, 6, 3, 0, 7, 4, 1,
– numbers not independent!
CSC11 • ROOT 21
![Page 22: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/22.jpg)
Random Number Generator
• Solution: more complex function
– Mersenne Twister (TRandom3) is recommended generates random number between >0 and <= 1
– period 106000, fast!
• Flat probability distribution function good for dice, usually not for physics:
– measurement uncertainty: gaussian
– particle lifetime: N(t) = N0 exp(-t/τ) i.e. exponential
– energy loss of particles in matter: landau CSC11 • ROOT 22
TRandom3 myRnd; myRnd.Uniform();
![Page 23: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/23.jpg)
• Want to “sample” distribution y = 2x for 0 < x < 1
• Acceptance-rejection method
• Generate random x* and y* point: if y* <= 1 – x2, return as random number, else generate new x*, y*.
• Problem: waste of CPU, especially if function evaluation costs a lot of CPU time
Naïve Random Distribution
CSC11 • ROOT 23
![Page 24: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/24.jpg)
Random Distribution From Inverse
• Integral g(x) of distribution f(x) (probability density function “PDF”):
• and inverse i(y) of g(x)
• random number 0 < y* < 1
• return i(y*)
• i(y*) is distributed like f(x)
CSC11 • ROOT 24
f(x) g(x)
i(y)
![Page 25: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/25.jpg)
Smart Random Distribution
• Problem with inverse: must be known!
• Can combine rejection on f() and inverse of a() and b() with a(x) <= f(x) <= b(x) to reduce sampling overhead
• ROOT implements fast generators for random numbers distributed like Gauss, exp, Landau, Poisson…
CSC11 • ROOT 25
![Page 26: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/26.jpg)
Interlude: HELP!
ROOT is a framework – only as good as its documentation.
http://root.cern.ch
• User's Guide (it has your answers!)
• Reference Guide
What is TRandom? What functions does it have?
CSC11 • ROOT 26
![Page 27: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/27.jpg)
LET'S FIRE UP ROOT!
CSC11 • ROOT 27
![Page 28: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/28.jpg)
Setting Up ROOT
Before starting ROOT: setup environment variables $PATH, $LD_LIBRARY_PATH
(ba)sh:
(t)csh:
CSC11 • ROOT 28
$ source /PathToRoot/bin/thisroot.csh
$ source /PathToRoot/bin/thisroot.sh
![Page 29: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/29.jpg)
Starting Up ROOT
ROOT is prompt-based
Prompt speaks C++
CSC11 • ROOT 29
$ root
root [0] _
root [0] gROOT->GetVersion();
(const char* 0x5ef7e8)"5.27/04"
![Page 30: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/30.jpg)
ROOT As Pocket Calculator
Calculations:
Uses C++ Interpreter CINT
CSC11 • ROOT 30
root [0] sqrt(42)
(const double)6.48074069840786038e+00
root [1] double val = 0.17;
root [2] sin(val)
(const double)1.69182349066996029e-01
![Page 31: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/31.jpg)
CSC11 • ROOT
Running Code
To run function mycode() in file mycode.C:
Equivalent: load file and run function:
Quit:
All of CINT's commands (help):
31
root [0] .x mycode.C
root [0] .L mycode.C
root [1] mycode()
root [0] .h
root [0] .q
![Page 32: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/32.jpg)
ROOT Prompt
Why C++ and not a scripting language?!
You'll write your code in C++, too. Support for python, ruby,… exists.
Why a prompt instead of a GUI?
ROOT is a programming framework, not an office suite. Use GUIs where needed.
CSC11 • ROOT 32
![Page 33: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/33.jpg)
CSC11 • ROOT
Running Code
Macro: file that is interpreted by CINT (.x)
Execute with .x mymacro.C(42)
33
int mymacro(int value)
{
int ret = 42;
ret += value;
return ret;
}
![Page 34: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/34.jpg)
Compiling Code: ACLiC
Load code as shared lib, much faster:
Uses the system's compiler, takes seconds
Subsequent .x mymacro.C+(42) check for changes, only rebuild if needed
Exactly as fast as e.g. Makefile based stand-alone binary!
CINT knows types, functions in the file, e.g. call
CSC11 • ROOT 34
.x mymacro.C+(42)
mymacro(43)
![Page 35: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/35.jpg)
CSC11 • ROOT
Compiled versus Interpreted
Why compile?
Faster execution, CINT has limitations, validate code.
Why interpret?
Faster Edit → Run → Check result → Edit cycles ("rapid prototyping"). Scripting is sometimes just easier.
Are Makefiles dead?
Yes! ACLiC is even platform independent!
35
![Page 36: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/36.jpg)
A LITTLE C++
CSC11 • ROOT 36
![Page 37: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/37.jpg)
CSC11 • ROOT
A Little C++
Hopefully many of you know – but some don't.
• Object, constructor, assignment
• Pointers
• Scope, destructor
• Stack vs. heap
• Inheritance, virtual functions
If you use C++ you have to understand these concepts!
37
![Page 38: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/38.jpg)
Objects, Constructors, =
Look at this code:
CSC11 • ROOT 38
TNamed myObject("name", "title");
TNamed mySecond;
mySecond = myObject;
cout << mySecond.GetName() << endl;
![Page 39: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/39.jpg)
Objects, Constructors, =
Look at this code:
Creating objects:
1. Constructor TNamed::TNamed(const char*, const char*)
2. Default constructor TNamed::TNamed()
CSC11 • ROOT 39
TNamed myObject("name", "title");
TNamed mySecond;
mySecond = myObject;
cout << mySecond.GetName() << endl;
![Page 40: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/40.jpg)
Objects, Constructors, =
Look at this code:
3. Assignment:
CSC11 • ROOT 40
TNamed myObject("name", "title");
TNamed mySecond;
mySecond = myObject;
cout << mySecond.GetName() << endl;
TNamed:
fName "name" fTitle "title"
myObject TNamed: fName "" fTitle ""
mySecond
![Page 41: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/41.jpg)
Objects, Constructors, =
Look at this code:
3. Assignment: creating a twin
CSC11 • ROOT 41
=
TNamed: fName "name"
fTitle "title"
TNamed: fName "" fTitle ""
TNamed:
fName "name" fTitle "title"
TNamed myObject("name", "title");
TNamed mySecond;
mySecond = myObject;
cout << mySecond.GetName() << endl;
myObject mySecond
![Page 42: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/42.jpg)
Objects, Constructors, =
Look at this code:
4. New content
output:
CSC11 • ROOT 42
TNamed myObject("name", "title");
TNamed mySecond;
mySecond = myObject;
cout << mySecond.GetName() << endl;
TNamed:
fName "name" fTitle "title"
mySecond
"name"
![Page 43: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/43.jpg)
Pointers
Modified code:
Pointer declared with "*", initialize to 0
CSC11 • ROOT 43
TNamed myObject("name", "title");
TNamed* pMySecond = 0;
pMySecond = &myObject;
cout << pMySecond->GetName() << endl;
![Page 44: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/44.jpg)
[address]
Pointers
Modified code:
"&" gets address:
CSC11 • ROOT 44
TNamed myObject("name", "title");
TNamed* pMySecond = 0;
pMySecond = &myObject;
cout << pMySecond->GetName() << endl;
TNamed:
fName "name" fTitle "title"
myObject pMySecond
![Page 45: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/45.jpg)
TNamed:
fName "name" fTitle "title"
myObject
Pointers
Modified code:
Assignment: point to myObject; no copy
CSC11 • ROOT 45
TNamed myObject("name", "title");
TNamed* pMySecond = 0;
pMySecond = &myObject;
cout << pMySecond->GetName() << endl;
= & [address]
pMySecond
![Page 46: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/46.jpg)
Pointers
Modified code:
Access members of value pointed to by "->"
CSC11 • ROOT 46
TNamed myObject("name", "title");
TNamed* pMySecond = 0;
pMySecond = &myObject;
cout << pMySecond->GetName() << endl;
![Page 47: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/47.jpg)
Pointers
Changes propagated:
Pointer forwards to object
Name of object changed – prints "newname"!
CSC11 • ROOT 47
TNamed myObject("name", "title");
TNamed* pMySecond = 0;
pMySecond = &myObject;
pMySecond->SetName("newname");
cout << myObject.GetName() << endl;
![Page 48: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/48.jpg)
Object vs. Pointer
Compare object:
to pointer:
CSC11 • ROOT 48
TNamed myObject("name", "title");
TNamed mySecond = myObject;
cout << mySecond.GetName() << endl;
TNamed myObject("name", "title");
TNamed* pMySecond = &myObject;
cout << pMySecond->GetName() << endl;
![Page 49: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/49.jpg)
Object vs. Pointer: Parameters
Calling functions: object parameter obj gets copied for function call!
Pointer parameter: only address passed, no copy
CSC11 • ROOT 49
void funcO(TNamed obj);
TNamed myObject;
funcO(myObject);
void funcP(TNamed* ptr);
TNamed myObject;
funcP(&myObject);
![Page 50: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/50.jpg)
Object vs. Pointer: Parameters
Functions changing parameter: funcO can only access copy! caller not changed!
Using pointers (or references) funcP can change
caller
CSC11 • ROOT 50
void funcO(TNamed obj){ obj.SetName("nope"); }
funcO(caller);
void funcP(TNamed* ptr){ ptr->SetName("yes"); }
funcP(&caller);
![Page 51: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/51.jpg)
Scope
Scope: range of visibility and C++ "life".
Birth: constructor, death: destructor
Variables are valid / visible only in scopes:
CSC11 • ROOT 51
int a = 42;
{ int a = 0; }
cout << a << endl;
{ // birth: TNamed() called
TNamed n;
} // death: ~TNamed() called
![Page 52: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/52.jpg)
Scope
Functions are scopes:
must not return pointers to local variables!
CSC11 • ROOT 52
void func(){ TNamed obj; }
func();
cout << obj << end; // obj UNKNOWN!
TNamed* func(){
TNamed obj;
return &obj; // BAD!
}
![Page 53: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/53.jpg)
Stack vs. Heap
So far only stack:
Fast, but often < 10MB. Only survive in scope.
Heap: slower, GBs (RAM + swap), creation and destruction managed by user:
CSC11 • ROOT 53
TNamed myObj("n","t");
TNamed* pMyObj = new TNamed("n","t");
delete pMyObj; // or memory leak!
![Page 54: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/54.jpg)
Stack vs. Heap: Functions
Can return heap objects without copying:
ptr gone – but TNamed object still on the heap, address returned!
CSC11 • ROOT 54
TNamed* CreateNamed(){
// user must delete returned obj!
TNamed* ptr = new TNamed("n","t");
return ptr; }
TNamed* pMyObj = CreateNamed();
cout << pMyObj->GetName() << endl;
delete pMyObj; // or memory leak!
![Page 55: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/55.jpg)
Inheritance
Classes "of same kind" can re-use functionality
E.g. plate and bowl are both dishes:
Can implement common functions in TDish:
CSC11 • ROOT 55
class TPlate: public TDish {...};
class TBowl: public TDish {...};
class TDish {
public:
void Wash();
};
TPlate *a = new TPlate();
a->Wash();
![Page 56: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/56.jpg)
Inheritance: The Base
Use TPlate, TBowl as dishes: assign pointer of derived to pointer of base "every plate is a dish"
But not every dish is a plate, i.e. the inverse doesn't work. And a bowl is totally not a plate!
CSC11 • ROOT 56
TDish *a = new TPlate();
TDish *b = new TBowl();
TPlate* p = new TDish(); // NO!
TPlate* q = new TBowl(); // NO!
![Page 57: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/57.jpg)
Virtual Functions
Often derived classes behave differently:
CSC11 • ROOT 57
class TDish { ...
virtual bool ForSoup() const;
};
class TPlate: public TDish { ...
bool ForSoup() const { return false; }
};
class TBowl: public TDish { ...
bool ForSoup() const { return true; }
};
![Page 58: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/58.jpg)
Pure Virtual Functions
But TDish cannot know! Mark as "not implemented"
Only for virtual functions.
Cannot create object of TDish anymore (one function is missing!)
CSC11 • ROOT 58
class TDish { ...
virtual bool ForSoup() const = 0;
};
![Page 59: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/59.jpg)
Calling Virtual Functions
Call to virtual functions evaluated at runtime:
Works for any type as expected:
CSC11 • ROOT 59
TDish* a = new TPlate();
TDish* b = new TBowl();
FillWithSoup(a); // will not be full
FillWithSoup(b); // is now full
void FillWithSoup(TDish* dish) {
if (dish->ForSoup())
dish->SetFull();
}
![Page 60: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/60.jpg)
Virtual vs. Non-Virtual
So what happens if non-virtual?
Will now always call TDish::ForSoup(), i.e. false
CSC11 • ROOT 60
void FillWithSoup(TDish* dish) {
if (dish->ForSoup())
dish->SetFull();
}
class TDish { ...
bool ForSoup() const {return false;}
};
![Page 61: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/61.jpg)
You have earned yourself the CSC ROOT
C++ Diploma.
From now on you may use C++ without
feeling lost!
Congrats!
CSC11 • ROOT 61
![Page 62: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/62.jpg)
Summary
We know:
• why and how to start ROOT
• C++ basics
• that you run your code with ".x"
• can call functions in libraries
• can (mis-) use ROOT as a pocket calculator!
Lots for you to discover during next two lectures and especially the exercises!
CSC11 • ROOT 62
![Page 63: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/63.jpg)
SAVING DATA
Streaming, Reflection, TFile,
Schema Evolution
CSC11 • ROOT 63
![Page 64: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/64.jpg)
Saving Objects
Cannot do in C++:
E.g. LHC experiments use C++ to manage data
Need to write C++ objects and read them back
std::cout not an option: 15 PetaBytes / year of processed data (i.e. data that will be read)
CSC11 • ROOT 64
TNamed* o = new TNamed("name","title"); std::write("file.bin", "obj1", o); TNamed* p = std::read("file.bin", "obj1"); p->GetName();
![Page 65: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/65.jpg)
Saving Objects – Saving Types
What's needed?
Store data members of TNamed; need to know:
1) type of object
2) data members for the type
3) where data members are in memory
4) read their values from memory, write to disk
CSC11 • ROOT 65
TNamed* o = new TNamed("name", "title"); std::write("file.bin", "obj1", o);
![Page 66: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/66.jpg)
Serialization
Store data members of TNamed: serialization
1) type of object: runtime-type-information RTTI
2) data members for the type: reflection
3) where data members are in memory: introspection
4) read their values from memory, write to disk: raw I/O
Complex task, and C++ is not your friend.
CSC11 • ROOT 66
![Page 67: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/67.jpg)
Reflection
Need type description (aka reflection)
1. types, sizes, members
TMyClass is a class.
Members:
– "fFloat", type float, size 4 bytes
– "fLong", type Long64_t, size 8 bytes
CSC11 • ROOT 67
class TMyClass {
float fFloat;
Long64_t fLong;
};
![Page 68: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/68.jpg)
Platform Data Types
Fundamental data types (int, long,…): size is platform dependent
Store "long" on 64bit platform, writing 8 bytes: 00, 00, 00, 00, 00, 00, 00, 42
Read on 32bit platform, "long" only 4 bytes: 00, 00, 00, 00
Data loss, data corruption!
CSC11 • ROOT 68
![Page 69: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/69.jpg)
ROOT Basic Data Types
Solution: ROOT typedefs
CSC11 • ROOT 69
Signed Unsigned sizeof [bytes]
Char_t UChar_t 1
Short_t UShort_t 2
Int_t UInt_t 4
Long64_t ULong64_t 8
Double32_t float on disk, double in RAM
![Page 70: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/70.jpg)
Reflection
Need type description (platform dependent)
1. types, sizes, members
2. offsets in memory
CSC11 • ROOT 70
class TMyClass {
float fFloat;
Long64_t fLong;
};
TMyClass
Mem
ory
Ad
dre
ss
fLong
fFloat
– 16 – 14 – 12 – 10 – 8 – 6 – 4 – 2 – 0
PADDING "fFloat" is at offset 0
"fLong" is at offset 8
![Page 71: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/71.jpg)
I/O Using Reflection
members memory disk
CSC11 • ROOT 71
TMyClass
Mem
ory
Ad
dre
ss
fLong
fFloat
– 16 – 14 – 12 – 10 – 8 – 6 – 4 – 2 – 0
PADDING
![Page 72: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/72.jpg)
C++ Is Not Java
Lesson: need reflection!
Where from?
Java: get data members with
C++: get data members with – oops. Not part of C++.
CSC11 • ROOT 72
THIS LANGUAGE HAS NO BRAIN. USE YOUR OWN
CAREFUL
Class.forName("MyClass").getFields()
![Page 73: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/73.jpg)
ROOT And Reflection
Simply use ACLiC:
Creates library with reflection data ("dictionary") of all types in MyCode.cxx!
Dictionary needed for interpreter, too
ROOT has dictionary for all its types
CSC11 • ROOT 73
.L MyCode.cxx+
![Page 74: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/74.jpg)
Back To Saving Objects
Given a TFile:
Write an object deriving from TObject:
"optionalName" or TObject::GetName()
Write any object (with dictionary):
CSC11 • ROOT 74
object->Write("optionalName")
f->WriteObject(object, "name");
TFile* f = TFile::Open("file.root","RECREATE");
![Page 75: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/75.jpg)
TFile
ROOT stores objects in TFiles:
TFile behaves like file system:
TFile has a current directory:
TFile compresses data ("zip"):
CSC11 • ROOT 75
f->mkdir("dir");
f->cd("dir");
f->GetCompressionFactor() 2.6
TFile* f = TFile::Open("file.root", "NEW");
![Page 76: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/76.jpg)
"Where Is My Histogram?"
TFile owns histograms, graphs, trees (due to historical reasons):
h automatically deleted: owned by file.
o still there
even if saving o to file!
TFile acts like a scope for hists, graphs, trees!
CSC11 • ROOT 76
unique names!
TFile* f = TFile::Open("myfile.root"); TH1F* h = new TH1F("h","h",10,0.,1.); TNamed* o = new TNamed("name", "title"); o->Write(); delete f;
![Page 77: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/77.jpg)
Risks With I/O
Physicists can loop a lot:
For each particle collision
For each particle created
For each detector module
Do something.
Physicists can loose a lot:
Run for hours…
Crash.
Everything lost.
CSC11 • ROOT 77
![Page 78: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/78.jpg)
Name Cycles
Create snapshots regularly:
MyObject;1
MyObject;2
…
MyObject;5427
MyObject
Write() does not replace but append! but see documentation TObject::Write()
CSC11 • ROOT 78
![Page 79: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/79.jpg)
The "I" Of I/O
Reading is simple:
Remember: TFile owns histograms! file gone, histogram gone!
CSC11 • ROOT 79
TFile* f = TFile::Open("myfile.root"); TH1F* h = 0; f->GetObject("h", h); h->Draw(); delete f;
![Page 80: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/80.jpg)
Ownership And TFiles
Separate TFile and histograms:
… and h will stay around.
Put in root_logon.C in current directory to be executed when root starts
CSC11 • ROOT 80
TFile* f = TFile::Open("myfile.root"); TH1F* h = 0; TH1::AddDirectory(kFALSE); f->GetObject("h", h); h->Draw(); delete f;
![Page 81: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/81.jpg)
Changing Class – The Problem
Things change:
CSC11 • ROOT 81
class TMyClass { float fFloat; Long64_t fLong; };
![Page 82: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/82.jpg)
Changing Class – The Problem
Things change:
Inconsistent reflection data, mismatch in memory, on disk
Objects written with old version cannot be read
Need to store reflection with data to detect!
CSC11 • ROOT 82
class TMyClass { double fFloat; Long64_t fLong; };
![Page 83: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/83.jpg)
Schema Evolution
Simple rules to convert disk to memory layout
1. skip removed members
2. default-initialize added members
3. convert members where possible
CSC11 • ROOT 83
Long64_t fLong; float fFloat;
file.root float fFloat;
RAM ignore
float fFloat;
file.root Long64_t fLong; float fFloat;
RAM TMyClass(): fLong(0)
![Page 84: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/84.jpg)
Class Version
ClassDef() macro makes I/O faster, needed when deriving from TObject
Can have multiple class versions in same file
Use version number to identify layout:
CSC11 • ROOT 84
class TMyClass: public TObject { public: TMyClass(): fLong(0), fFloat(0.) {} virtual ~TMyClass() {} ... ClassDef(TMyClass,1); // example class };
![Page 85: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/85.jpg)
Reading Files
Files store reflection and data: need no library!
CSC11 • ROOT 85
function
call
![Page 86: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/86.jpg)
ROOT I/O Candy
• Nice viewer for TFile: new TBrowser
• Can even open TFile::Open("http://cern.ch/file.root") including read-what-you-need!
• Combine contents of TFiles with $ROOTSYS/bin/hadd
CSC11 • ROOT 86
![Page 87: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/87.jpg)
Summary
Big picture:
• you know ROOT files – for petabytes of data
• you learned that reflection is key for I/O
• you learned what schema evolution is
Small picture:
• you can write your own data to files
• you can read it back
• you can change the definition of your classes
CSC11 • ROOT 87
![Page 88: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/88.jpg)
ROOT COLLECTION CLASSES
![Page 89: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/89.jpg)
Collection Classes
ROOT collections polymorphic containers: hold pointers to TObject, so:
• Can only hold objects that inherit from TObject
• Return pointers to TObject, that have to be cast back to the correct subclass
CSC11 • ROOT 89
void DrawHist(TObjArray *vect, int at) { TH1F *hist = (TH1F*)vect->At(at); if (hist) hist->Draw(); }
![Page 90: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/90.jpg)
TClonesArray
Array of objects of the same class ("clones")
Designed for repetitive data analysis tasks: same type of objects created and deleted many times.
No comparable class in STL!
CSC11 • ROOT 90
The internal data structure of a TClonesArray
![Page 91: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/91.jpg)
while (next_event()) { };
while (next_event()) { };
TClonesArray
CSC11 • ROOT 91
TTrack for (int i=0;i<N;++i) a[i] = new TTrack(x,y,z); do_something(a);
a.clear();
TTrack TTrack TTrack TTrack TTrack TTrack TTrack TTrack TTrack
for (int i=0;i<N;++i) new(a[i]) TTrack(x,y,z); do_something(a);
a.Delete();
TTrack TTrack TTrack TTrack TTrack TTrack TTrack TTrack TTrack TTrack
Standard array:
TClonesArray:
![Page 92: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/92.jpg)
Traditional Arrays
Very large number of new and delete calls in large loops like this (Nevents x Ntracks times new/delete):
CSC11 • ROOT 92
TObjArray a(10000); while (TEvent *ev = (TEvent *)next()) { for (int i = 0; i < ev->Ntracks; ++i) { a[i] = new TTrack(x,y,z,...); ... } a.Delete(); }
Nevents
= 100000
Ntracks
= 10000
![Page 93: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/93.jpg)
Use of TClonesArray
You better use a TClonesArray which reduces the number of new/delete calls to only Ntracks:
• Pair of new / delete calls cost about 4 μs • Allocating / freeing memory Nevents*Ntracks = 109 times
costs about 1 hour!
CSC11 • ROOT 93
TClonesArray a("TTrack", 10000); while (TEvent *ev = (TEvent *)next()) { for (int i = 0; i < ev->Ntracks; ++i) { new(a[i]) TTrack(x,y,z,...); ... } a.Delete(); }
Nevents
= 100000
Ntracks
= 10000
![Page 94: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/94.jpg)
ROOT TREES
![Page 95: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/95.jpg)
Trees
CSC11 • ROOT 95
From: Simple data types (e.g. Excel tables)
To: Complex data types (e.g. Database tables)
Event
Particles
Pt Charge
Energy Track
Vertex
Position
Header Type
…
![Page 96: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/96.jpg)
Why Trees ?
• Extremely efficient write once, read many ("WORM")
• Designed to store >109 (HEP events) with same data structure
• Trees allow fast direct and random access to any entry (sequential access is the best)
• Optimized for network access (read-ahead)
CSC11 • ROOT 96
![Page 97: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/97.jpg)
Why Trees ?
object.Write() convenient for simple objects like histograms, inappropriate for saving collections of events containing complex objects
• Reading a collection: read all elements (all events)
• With trees: only one element in memory, or even only a part of it (less I/O)
• Trees buffered to disk (TFile); I/O is integral part of TTree concept
CSC11 • ROOT 97
![Page 98: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/98.jpg)
Tree Access
• Databases have row wise access
– Can only access the full object (e.g. full event)
• ROOT trees have column wise access
– Direct access to any event, any branch or any leaf even in the case of variable length structures
– Designed to access only a subset of the object attributes (e.g. only particles’ energy)
– Makes same members consecutive, e.g. for object with position in X, Y, Z, and energy E, all X are consecutive, then come Y, then Z, then E. A lot higher zip efficiency!
CSC11 • ROOT 98
![Page 99: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/99.jpg)
Branch Creation from Class
CSC11 • ROOT 99
float a; int b; double c[5]; int N; float* x; //[N] float* y; //[N] Class1 c1; Class2 c2; //! Class3 *c3; std::vector<T> v1; std::vector<S*> v2; TClonesArray *tc;
a
yyyyyy
c1
c3
v1
v2
tc
c
N
xxxxxx
b
Class1::a
T::a
S::a
X::a X::b X::c
X::d
S::b
T::b T::c
Class1::b
Branches
![Page 100: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/100.jpg)
ObjectWise/MemberWise Streaming
CSC11 • ROOT 100
a b c d
a1a2..anb1b2..bnc1c2..cnd1d2..dn
a1a2…an
b1b2…bn
c1c2…cn
d1d2…dn
3 modes to stream an object
member-wise gives
better compression
member-wise streaming of
collections default since 5.27
a1b1c1d1a2b2c2d2…anbncndn
![Page 101: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/101.jpg)
Building ROOT Trees
Overview of
– Trees
– Branches
5 steps to build a TTree
CSC11 • ROOT 101
![Page 102: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/102.jpg)
Tree structure
CSC11 • ROOT 102
![Page 103: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/103.jpg)
Tree structure
• Branches: directories
• Leaves: data containers
• Can read a subset of all branches – speeds up considerably the data analysis processes
• Branches of the same TTree can be written to separate files
CSC11 • ROOT 103
![Page 104: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/104.jpg)
Memory ↔ Tree
• Each Node is a branch in the Tree
CSC11 • ROOT 104
0
T.Fill()
T
Memory
![Page 105: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/105.jpg)
Memory ↔ Tree
• Each Node is a branch in the Tree
CSC11 • ROOT 105
0 1 2 3 4 5 6
T.GetEntry(6)
T
Memory
![Page 106: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/106.jpg)
Five Steps to Build a Tree
Steps:
1. Create a TFile
2. Create a TTree
3. Add TBranch to the TTree
4. Fill the tree
5. Write the file
CSC11 • ROOT 106
![Page 107: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/107.jpg)
Example macro
void WriteTree() { Event *myEvent = new Event(); TFile f("AFile.root", "RECREATE"); TTree *t = new TTree("myTree","A Tree"); t->Branch("EventBranch", &myEvent); for (int e=0;e<100000;++e) { myEvent->Generate(); // hypothetical t->Fill(); } t->Write(); }
CSC11 • ROOT 107
![Page 108: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/108.jpg)
Step 1: Create a TFile Object
Trees can be huge need file for swapping filled entries
CSC11 • ROOT 108
TFile *hfile = TFile::Open("AFile.root", "RECREATE");
![Page 109: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/109.jpg)
Step 2: Create a TTree Object
The TTree constructor:
– Tree name (e.g. "myTree")
– Tree title
CSC11 • ROOT 109
TTree *tree = new TTree("myTree","A Tree");
![Page 110: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/110.jpg)
Step 3: Adding a Branch
• Branch name
• Address of pointer to the object
CSC11 • ROOT 110
Event *myEvent = new Event(); myTree->Branch("eBranch", &myEvent);
![Page 111: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/111.jpg)
Step 4: Fill the Tree
• Create a for loop
• Assign values to the object contained in each branch
• TTree::Fill() creates a new entry in the tree: snapshot of values of branches’ objects
CSC11 • ROOT 111
for (int e=0;e<100000;++e) { myEvent->Generate(e); // fill event myTree->Fill(); // fill the tree }
![Page 112: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/112.jpg)
Step 5: Write Tree To File
CSC11 • ROOT 112
myTree->Write();
![Page 113: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/113.jpg)
Reading a TTree
• Looking at a tree
• How to read a tree
• Friends and chains
CSC11 • ROOT 113
![Page 114: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/114.jpg)
Example macro void ReadTree() { TFile f("AFile.root"); TTree *T = (TTree*)f->Get("T"); Event *myE = 0; TBranch* brE = 0; T->SetBranchAddress("EvBranch", &myE, brE); T->SetCacheSize(10000000); T->AddBranchToCache("EvBranch"); Long64_t nbent = T->GetEntries(); for (Long64_t e = 0;e < nbent; ++e) { brE->GetEntry(e); myE->Analyze(); } }
CSC11 • ROOT 114
Data pointers (e.g. myE) MUST be set to 0
![Page 115: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/115.jpg)
How to Read a TTree
Example:
1. Open the Tfile
2. Get the TTree
CSC11 • ROOT 115
TFile f("AFile.root")
TTree *myTree = 0;
f.GetObject("myTree",myTree)
or
![Page 116: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/116.jpg)
How to Read a TTree
3. Create a variable pointing to the data root [] Event *myEvent = 0;
4. Associate a branch with the variable: root [] myTree->SetBranchAddress("eBranch", &myEvent);
5. Read one entry in the TTree root [] myTree->GetEntry(0)
root [] myEvent->GetTracks()->First()->Dump()
==> Dumping object at: 0x0763aad0, name=Track, class=Track
fPx 0.651241 X component of the momentum
fPy 1.02466 Y component of the momentum
fPz 1.2141 Z component of the momentum
[...]
CSC11 • ROOT 116
![Page 117: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/117.jpg)
Branch Access Selection
• Use TTree::SetBranchStatus() or TBranch::GetEntry() to select branches to be read
• Speed up considerably the reading phase
CSC11 • ROOT 117
TClonesArray* myMuons = 0; // disable all branches myTree->SetBranchStatus("*", 0); // re-enable the "muon" branches myTree->SetBranchStatus("muon*", 1); myTree->SetBranchAddress("muon", &myMuons); // now read (access) only the "muon" branches myTree->GetEntry(0);
![Page 118: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/118.jpg)
Looking at the Tree
TTree::Print() shows the data layout root [] TFile f("AFile.root") root [] myTree->Print(); ****************************************************************************** *Tree :myTree : A ROOT tree * *Entries : 10 : Total = 867935 bytes File Size = 390138 * * : : Tree compression factor = 2.72 * ****************************************************************************** *Branch :eBranch * *Entries : 10 : BranchElement (see below) * *............................................................................* *Br 0 :fUniqueID : * *Entries : 10 : Total Size= 698 bytes One basket in memory * *Baskets : 0 : Basket Size= 64000 bytes Compression= 1.00 * *............................................................................* … …
CSC11 • ROOT 118
![Page 119: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/119.jpg)
Looking at the Tree
TTree::Scan("leaf:leaf:….") shows the values
root [] myTree->Scan("fNseg:fNtrack"); > scan.txt root [] myTree->Scan("fEvtHdr.fDate:fNtrack:fPx:fPy","", "colsize=13 precision=3 col=13:7::15.10"); ****************************************************************************** * Row * Instance * fEvtHdr.fDate * fNtrack * fPx * fPy * ****************************************************************************** * 0 * 0 * 960312 * 594 * 2.07 * 1.459911346 * * 0 * 1 * 960312 * 594 * 0.903 * -0.4093382061 * * 0 * 2 * 960312 * 594 * 0.696 * 0.3913401663 * * 0 * 3 * 960312 * 594 * -0.638 * 1.244356871 * * 0 * 4 * 960312 * 594 * -0.556 * -0.7361358404 * * 0 * 5 * 960312 * 594 * -1.57 * -0.3049036264 * * 0 * 6 * 960312 * 594 * 0.0425 * -1.006743073 * * 0 * 7 * 960312 * 594 * -0.6 * -1.895804524 *
CSC11 • ROOT 119
![Page 120: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/120.jpg)
TTree Selection Syntax
Print the first 8 variables of the tree:
Prints all the variables of the tree:
Prints the values of var1, var2 and var3.
A selection can be applied in the second argument:
Prints the values of var1, var2 and var3 for the entries where var1 is greater than 0
Use the same syntax for TTree::Draw()
CSC11 • ROOT 120
MyTree->Scan();
MyTree->Scan("*");
MyTree->Scan("var1:var2:var3");
MyTree->Scan("var1:var2:var3", "var1>0");
![Page 121: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/121.jpg)
Looking at the Tree
TTree::Show(entry_number) shows values for one entry root [] myTree->Show(0); ======> EVENT:0 eBranch = NULL fUniqueID = 0 fBits = 50331648 [...] fNtrack = 594 fNseg = 5964 [...] fEvtHdr.fRun = 200 [...] fTracks.fPx = 2.066806, 0.903484, 0.695610,-0.637773,… fTracks.fPy = 1.459911, -0.409338, 0.391340, 1.244357,…
CSC11 • ROOT 121
![Page 122: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/122.jpg)
TChain: the Forest
• Collection of TTrees: list of ROOT files containing the same tree
• Same semantics as TTree
As an example, assume we have three files called file1.root, file2.root, file3.root. Each contains tree called "T". Create a chain:
CSC11 • ROOT 122
TChain chain("T"); // argument: tree name chain.Add("file1.root"); chain.Add("file2.root"); chain.Add("file3.root");
Now we can use the TChain like a TTree!
![Page 123: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/123.jpg)
T(3) file3.root
TChain
CSC11 • ROOT 123
chain files together
T(2) file2.root
T(1) file1.root
![Page 124: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/124.jpg)
Data Volume & Organisation
• A TFile typically contains 1 TTree
• A TChain is a collection of TTrees or/and TChains
CSC11 • ROOT 124
100MB 1GB 10GB 1TB 100GB 100TB 1PB 10TB
1 1 50000 5000 500 50 5
TTree TChain
![Page 125: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/125.jpg)
CSC11 • ROOT
Tree Friends
• Trees are designed to be read only
• Often, people want to add branches to existing trees and write their data into it
• Using tree friends is the solution:
– Create a new file holding the new tree
– Create a new Tree holding the branches for the user data
– Fill the tree/branches with user data
– Add this new file/tree as friend of the original tree
125
![Page 126: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/126.jpg)
Tree Friends
CSC11 • ROOT 126
TFile f1("tree.root"); tree.AddFriend("tree_1", "tree1.root") tree.AddFriend("tree_2", "tree2.root"); tree.Draw("x:a", "k<c"); tree.Draw("x:tree_2.x");
tree_1 tree_2
tree
a b c
n x
o p
q r
i j
k l x
![Page 127: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/127.jpg)
Splitting
CSC11 • ROOT 127
Split level = 0 Split level = 99
![Page 128: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/128.jpg)
Splitting
• Creates one branch per member – recursively
• Allows to browse objects that are stored in trees, even without their library
• Fine grained branches allow fine-grained I/O - read only members that are needed
• Supports STL containers too, even vector<T*>!
CSC11 • ROOT 128
![Page 129: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/129.jpg)
Splitting
Setting the split level (default = 99)
CSC11 • ROOT 129
Split level = 0 Split level = 99
tree->Branch("EvBr", &event, 64000, 0 );
![Page 130: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/130.jpg)
Performance Considerations
A split branch is:
• Faster to read – if you only want a subset of data members
• Slower to write due to the large number of branches
CSC11 • ROOT 130
![Page 131: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/131.jpg)
Summary: Trees
• TTree is one of the most powerful collections available for HEP
• Extremely efficient for huge number of data sets with identical layout
• Very easy to look at TTree - use TBrowser!
• Write once, read many (WORM) ideal for experiments' data; use friends to extend
• Branches allow granular access; use splitting to create branch for each member, even through collections
CSC11 • ROOT 131
![Page 132: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/132.jpg)
ANALYZING TREES Selectors, Analysis, PROOF
CSC11 • ROOT 132
![Page 133: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/133.jpg)
Recap
TTree efficient storage and access for huge amounts of structured data
Allows selective access of data
TTree knows its layout
Almost all HEP analyses based on TTree
CSC11 • ROOT 133
![Page 134: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/134.jpg)
TTree Data Access
TSelector: generic "TTree based analysis"
Derive from it ("TMySelector")
ROOT invokes TSelector's functions,
Used e.g. by tree->Process(TSelector*,…), PROOF
Functions called are virtual, thus TMySelector's functions called.
CSC11 • ROOT 134
![Page 135: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/135.jpg)
TTree Data Access
E.g.
CSC11 • ROOT 135
SlaveBegin()
Process(i)
Terminate()
Init(tree)
next entry? no
yes
tree->Process("MySelector.C+")
![Page 136: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/136.jpg)
TSelector
Steps of ROOT using a TSelector:
1. setup TMySelector::Init(TTree *tree) fChain = tree; fChain->SetBranchAddress()
2. start TMySelector::SlaveBegin() create histograms
3. run TMySelector::Process(Long64_t) fChain->GetTree()->GetEntry(entry);
analyze data, fill histograms,…
4. end TMySelector::Terminate() fit histograms, write them to files,…
CSC11 • ROOT 136
![Page 137: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/137.jpg)
Analysis
TSelector gives the structure of analyses
Content of data analysis:
science by itself
covered by Ivica Puljak
CSC11 • ROOT 137
![Page 138: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/138.jpg)
FITTING Example for a common ROOT analysis ingredient
CSC11 • ROOT 138
![Page 139: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/139.jpg)
Fitting
Sampling "known" distribution
Influenced by statistics
CSC11 • ROOT 139
Not monotonic!
Missing data
![Page 140: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/140.jpg)
Fit
Combine our knowledge with statistics / data by fitting a distribution:
1. Find appropriate function with parameters
1. Fit function to distribution
CSC11 • ROOT 140
![Page 141: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/141.jpg)
Fitting: The Math
Fitting = finding parameters such that |f(x) – hist(x)|
minimal for all points x [or any similar measure]
Histogram with errors:
|f(x) – hist(x)| / err(x) or similar
CSC11 • ROOT 141
![Page 142: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/142.jpg)
Fitting: The Function
Finding the proper function involves:
• behavioral analysis: starts at 0, goes to constant, monotonic,…
• physics interpretation: "E proportional to sin^2(phi)"
• having a good knowledge of typical functions (see TMath)
• finding a good compromise between generalization ("constant") and precision ("polynomial 900th degree")
CSC11 • ROOT 142
![Page 143: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/143.jpg)
Let's take "erf"
Free parameters:
[0]: x @ center of the slope
[1]: ½ width of the slope
[2]: maximum efficiency
Define fit function:
TF1* f = new TF1("myfit", "(TMath::Erf((x-[0])/[1])/2.+0.5)*[2]" 0., 100.);
Fitting: Parameters
CSC11 • ROOT 143
erf(x)/2.+0.5
[0]
[1]
[2]
![Page 144: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/144.jpg)
Fitting: Parameter Init
A must!
Sensible values:
CSC11 • ROOT 144
[0]
[1]
[2]
f->SetParameter(0, 35.); f->SetParameter(1, 10.); f->SetParameter(2, 1.);
![Page 145: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/145.jpg)
Fitting Result
Result of is printed, or use
[0]: 34.9
[1]: 12.1
[2]: 0.98
which means:
Get efficiency at pT=42GeV:
CSC11 • ROOT 145
(TMath::Erf((x-34.9)/12.1)/2.+0.5)*0.98
f->GetParameter(0)
f->Eval(42.)
hist->Fit(f);
![Page 146: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/146.jpg)
Fitting: Recap
You now know
• why large samples are relevant
• what fitting is, how it works, when to do it, and how it's done with ROOT.
CSC11 • ROOT 146
![Page 147: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/147.jpg)
INTERACTIVE DATA ANALYSIS WITH PROOF
Bleeding Edge Physics with Bleeding Edge Computing
![Page 148: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/148.jpg)
Parallel Analysis: PROOF
Some numbers (from Alice experiment)
• 1.5 PB (1.5 * 1015) of raw data per year
• 360 TB of ESD+AOD* per year (20% of raw)
• One pass at 15 MB/s will take 9 months!
CSC11 • ROOT 148
Parallelism is the only way out!
* ESD: Event Summary Data AOD: Analysis Object Data
![Page 149: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/149.jpg)
CAF Usage Statistics
CSC11 • ROOT 149
![Page 150: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/150.jpg)
PROOF
Huge amounts of events, hundreds of CPUs
Split the job into N events / CPU!
PROOF for TSelector based analysis:
• start analysis locally ("client"),
• PROOF distributes data and code,
• lets CPUs ("workers") run the analysis,
• collects and combines (merges) data,
• shows analysis results locally
CSC11 • ROOT 150
![Page 151: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/151.jpg)
Interactive!
• Start analysis
• Watch status while running
• Forgot to create a histogram?
– Interrupt the process
– Modify the selector
– Re-start the analysis
• More dynamic than a batch system
CSC11 • ROOT 151
![Page 152: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/152.jpg)
PROOF
CSC11 • ROOT 152
PROOF farm
Storage
MASTER
commands, scripts
list of output objects
(histograms, …)
Client
Workers
![Page 153: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/153.jpg)
Scheduling
• Decides where to run which (part of) the jobs
• E.g. simple batch system
• Can autonomously split jobs into parts (“packets”)
• Involves
– resource management (CPU, I/O, memory)
– data locality
– priorities (jobs / users)
– and whatever other criteria are deemed relevant
• Often optimizing jobs’ distribution towards overall goal: maximum CPU utilization (Grid), minimum time to result (PROOF)
CSC11 • ROOT 153
![Page 154: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/154.jpg)
Packetizer Role and Goals
• Distributes units of work (“packets”) to workers
• Grid’s packet: >=1 file
• Result arrives when last resource has processed last file: tinit, tfinal: time to initialize / finalize the jobs Ri: processing rate of job i Ni
files: number of files for job i
• Result:
– slowest job defines running time
– large tail in CPU utilization versus time
CSC11 • ROOT 154
t = tinit + maxjobs(Ri . Ni
files) + tfinal
![Page 155: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/155.jpg)
Static…
• Example: 24 files on 4 worker nodes, one under-performing
CSC11 • ROOT 155
The slowest worker node sets the processing time
![Page 156: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/156.jpg)
PROOF’s Dynamic Packetizer
• PROOF packetizer’s goal: results as early as possible
• All workers should finish at the same time: ideally, Ri
. Nifiles equal for all jobs
• Cannot reliably predict performance (Ri) of workers
– job interaction, e.g. number of jobs accessing the same disk
– CPU versus I/O duty of jobs
• Instead: update prediction based on real-time past performance while running
• Pull architecture: workers ask for new packets
CSC11 • ROOT 156
t = tinit + maxjobs(Ri . Ni
files) + tfinal
![Page 157: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/157.jpg)
Dynamic Packet Distribution
CSC11 • ROOT 157
The slowest worker node gets less work to do: the processing time is less affected by its under performance
![Page 158: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/158.jpg)
PROOF Packetizer Live
CSC11 • ROOT 158
![Page 159: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/159.jpg)
Creating a session
To create a PROOF session from the ROOT
prompt, just type:
where "master" is the hostname of the master
machine on the PROOF cluster
CSC11 • ROOT 159
TProof::Open("master")
![Page 160: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/160.jpg)
PROOF Lite
CSC11 • ROOT 160
commands, scripts
list of output objects
(histograms, …)
Client
Multi-core Desktop/Laptop
![Page 161: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/161.jpg)
What is PROOF Lite?
• PROOF optimized for single many-core machines
• Zero configuration setup
– No config files and no daemons
• Like PROOF it can exploit fast disks, SSD’s, lots of RAM, fast networks and fast CPU’s
• If your code works on PROOF, then it works on PROOF Lite and vice versa
CSC11 • ROOT 161
![Page 162: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/162.jpg)
Creating a session
To create a PROOF Lite session from the
ROOT prompt, just type:
Then you can use your multicore computer as
a PROOF cluster!
CSC11 • ROOT 162
TProof::Open("")
![Page 163: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/163.jpg)
PROOF Analysis
• Example of local TChain analysis
CSC11 • ROOT 163
PROOF
// Create a chain of trees root[0] TChain *c = new TChain("myTree"); root[1] c->Add("http://www.any.where/file1.root"); root[2] c->Add("http://www.any.where/file2.root"); // MySelector is a TSelector root[3] c->Process("MySelector.C+");
![Page 164: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/164.jpg)
PROOF Analysis
• Same example with PROOF
CSC11 • ROOT 164
// Create a chain of trees root[0] TChain *c = new TChain("myTree"); root[1] c->Add("http://www.any.where/file1.root"); root[2] c->Add("http://www.any.where/file2.root"); // Start PROOF and tell the chain to use it root[3] TProof::Open(""); root[4] c->SetProof(); // Process goes via PROOF root[5] c->Process("MySelector.C+");
![Page 165: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/165.jpg)
TSelector & PROOF
• Begin() called on the client only
• SlaveBegin() called on each worker: create histograms
• SlaveTerminate() rarely used; post processing of partial results before they are sent to master and merged
• Terminate() runs on the client: save results, display histograms, …
CSC11 • ROOT 165
![Page 166: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/166.jpg)
PROOF Analysis
CSC11 • ROOT 166
SlaveBegin() •Create histos, …
•Define output list
Process()
preselection analysis
output list Selector (worker)
loop over events
OK
event
branch
branch
leaf
leaf leaf
branch
leaf leaf
1 2 n last
n
Chain
branch
leaf leaf
Begin() Terminate() •Final analysis
(fitting, saving …)
SlaveTerminate() •Post-processing
Selector (client)
![Page 167: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/167.jpg)
Output List (result of the query)
• Each worker has a partial output list
• Objects have to be added to the list in TSelector::SlaveBegin() e.g.:
• At the end of processing the output list gets sent to the master
• The Master merges objects and returns them to the client. Merging is e.g. "Add()" for histograms, appending for lists and trees
CSC11 • ROOT 167
fHist = new TH1F("h1", "h1", 100, -3., 3.); fOutput->Add(fHist);
![Page 168: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/168.jpg)
Example
CSC11 • ROOT 168
void MySelector::SlaveBegin(TTree *tree) { // create histogram and add it to the output list fHist = new TH1F("MyHist","MyHist",40,0.13,0.17); GetOutputList()->Add(fHist); } Bool_t MySelector::Process(Long64_t entry) { my_branch->GetEntry(entry); // read branch fHist->Fill(my_data); // fill the histogram return kTRUE; } void MySelector::Terminate() { fHist->Draw(); // display histogram }
![Page 169: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/169.jpg)
Results
At the end of Process(), the output list is accessible via gProof->GetOutputList()
CSC11 • ROOT 169
// Get the output list root[0] TList *output = gProof->GetOutputList(); // Retrieve 2D histogram "h2" root[1] TH2F *h2 = (TH2F*)output->FindObject("h2"); // Display the histogram root[2] h2->Draw();
![Page 170: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/170.jpg)
PROOF GUI Session
Starting a PROOF GUI session is trivial:
Opens GUI:
CSC11 • ROOT 170
TProof::Open()
![Page 171: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/171.jpg)
PROOF GUI Session – Results
Results accessible via TSessionViewer, too:
CSC11 • ROOT 171
![Page 172: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/172.jpg)
PROOF Documentation
Documentation available online at
http://root.cern.ch/drupal/content/proof
But of course you need a little cluster of CPUs
Like your multi-core
game console!
CSC11 • ROOT 172
![Page 173: ROOT · as GEANT3, GEANT4 and FLUKA CSC11 • ROOT 15 . Geometry ... Exactly as fast as e.g. Makefile based stand-alone binary! CINT knows types, functions in the file, e.g. call](https://reader030.vdocuments.net/reader030/viewer/2022021802/5b811e507f8b9ae97b8b96f8/html5/thumbnails/173.jpg)
Summary
You've learned:
• analyzing a TTree can be easy and efficient
• integral part of physics is counting
• ROOT provides histogramming and fitting
• > 1 CPU: use PROOF!
Looking forward to hearing from you:
• as a user (help! bug! suggestion!)
• and as a developer!
CSC11 • ROOT 173