Presentation is loading. Please wait.

Presentation is loading. Please wait.

Introduction to ROOT1 Summer Students Lecture 10 July 2007 Ren é Brun CERN/PH/SFT Introduction to ROOT

Similar presentations


Presentation on theme: "Introduction to ROOT1 Summer Students Lecture 10 July 2007 Ren é Brun CERN/PH/SFT Introduction to ROOT"— Presentation transcript:

1 Introduction to ROOT1 Summer Students Lecture 10 July 2007 Ren é Brun CERN/PH/SFT Introduction to ROOT http://root.cern.ch

2 Introduction to ROOT2 ROOT in a Nutshell The ROOT system is an Object Oriented framework for large scale data handling applications. It is written in C++. Provides, among others, an efficient data storage and access system designed to support structured data sets (PetaBytes) a query system to extract data from these data sets a C++ interpreter advanced statistical analysis algorithms (multi dimensional histogramming, fitting, minimization and cluster finding) scientific visualization tools with 2D and 3D graphics an advanced Graphical User Interface The user interacts with ROOT via a graphical user interface, the command line or scripts The command and scripting language is C++, thanks to the embedded CINT C++ interpreter, and large scripts can be compiled and dynamically loaded. A Python shell is also provided.

3 Introduction to ROOT3 The ROOT Libraries Over 1500 classes 1,550,000 lines of code CORE (8 Mbytes) CINT (2 Mbytes) Green libraries linked on demand via plug-in manager (only a subset shown) 100 shared libs

4 Introduction to ROOT4 ROOT: An Open Source Project The project was started in 1995. The project is developed as a collaboration between: Full time developers: 11 people full time at CERN (PH/SFT) +4 developers at Fermilab/USA, Protvino, JINR/Dubna (Russia) Large number of part-time contributors (155 in CREDITS file) A long list of users giving feedback, comments, bug fixes and many small contributions 2400 registered to RootForum 10,000 posts per year An Open Source Project, source available under the LGPL license

5 Introduction to ROOT5 Object Oriented Concepts Members: a “has a” relationship to the class. Inheritance: an “is a” relationship to the class.  Class: the description of a “thing” in the system  Object: instance of a class  Methods: functions for a class TObject JetsTracksEvNum Momentum Segments Charge Event IsA HasA

6 Introduction to ROOT6 ROOT: a Framework and a Library User classes User can define new classes interactively Either using calling API or sub-classing API These classes can inherit from ROOT classes Dynamic linking Interpreted code can call compiled code Compiled code can call interpreted code Macros can be dynamically compiled & linked This is the normal operation mode Interesting feature for GUIs & event displays Script Compiler root >.x file.C++

7 Introduction to ROOT7 ROOT Application Domains Data Storage: Local, Network Data Analysis & Visualization General Framework

8 Introduction to ROOT8 Three User Interfaces GUI windows, buttons, menus Command line CINT (C++ interpreter) Macros, applications, libraries (C++ compiler and interpreter)

9 Introduction to ROOT9 CINT Interpreter

10 Introduction to ROOT10 CINT in ROOT CINT is used in ROOT: As command line interpreter As script interpreter To generate class dictionaries To generate function/method calling stubs Signals/Slots with the GUI The command line, script and programming language become the same Large scripts can be compiled for optimal performance

11 Introduction to ROOT11 Compiled versus Interpreted  Why compile? ! Faster execution, CINT has limitations…  Why interpret? ! Faster Edit → Run → Check result → Edit cycles ("rapid prototyping"). Scripting is sometimes just easier.  Are Makefiles dead? ! No! if you build/compile a very large application ! Yes! ACLiC is even platform independent!

12 Introduction to ROOT12 Running Code To run function mycode() in file mycode.C: root [0].x mycode.C Equivalent: load file and run function: root [1].L mycode.C root [2] mycode() All of CINT's commands (help): root [3].h

13 Introduction to ROOT13 Running Code Macro: file that is interpreted by CINT (.x ) Execute with.x mymacro.C(42) Unnamed macro: no function, just statements – e.g. cannot have arguments..x myunnamed.C int mymacro(int value) { int ret = 42; ret += value; return ret; }

14 Introduction to ROOT14 Unnamed Macros No functions, just statements Execute with.x mymacro.C No functions thus no arguments! Named macro recommended! Compiler prefers it, too… { float ret = 0.42; return sin(ret); }

15 Introduction to ROOT15 Running Code – Libraries "Library": compiled code, shared library CINT can call its functions! Building a library from a macro: ACLiC! (Automatic Compiler of Libraries for CINT) +.x mymacro.C(42)+ Use "+" instead of writing a Makefile… CINT knows all functions in mymacro_C.so/.dll mymacro(42)

16 Introduction to ROOT16 My first session root [0] 344+76.8 (const double)4.20800000000000010e+002 root [1] float x=89.7; root [2] float y=567.8; root [3] x+sqrt(y) (double)1.13528550991510710e+002 root [4] float z = x+2*sqrt(y/6); root [5] z (float)1.09155929565429690e+002 root [6].q root root [0] try up and down arrows See file $HOME/.root_hist

17 Introduction to ROOT17 My second session root [0].x session2.C for N=100000, sum= 45908.6 root [1] sum (double)4.59085828512453370e+004 Root [2] r.Rndm() (Double_t)8.29029321670533560e-001 root [3].q root { int N = 100000; TRandom r; double sum = 0; for (int i=0;i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.com/26/8439784/slides/slide_17.jpg", "name": "Introduction to ROOT17 My second session root [0].x session2.C for N=100000, sum= 45908.6 root [1] sum (double)4.59085828512453370e+004 Root [2] r.Rndm() (Double_t)8.29029321670533560e-001 root [3].q root { int N = 100000; TRandom r; double sum = 0; for (int i=0;i

18 Introduction to ROOT18 My third session root [0].x session3.C for N=100000, sum= 45908.6 root [1] sum Error: Symbol sum is not defined in current scope *** Interpreter error recovered *** Root [2].x session3.C(1000) for N=1000, sum= 460.311 root [3].q root void session3 (int N=100000) { TRandom r; double sum = 0; for (int i=0;i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.com/26/8439784/slides/slide_18.jpg", "name": "Introduction to ROOT18 My third session root [0].x session3.C for N=100000, sum= 45908.6 root [1] sum Error: Symbol sum is not defined in current scope *** Interpreter error recovered *** Root [2].x session3.C(1000) for N=1000, sum= 460.311 root [3].q root void session3 (int N=100000) { TRandom r; double sum = 0; for (int i=0;i

19 Introduction to ROOT19 My third session with ACLIC root [0] gROOT->Time(); root [1].x session4.C(10000000) for N=10000000, sum= 4.59765e+006 Real time 0:00:06, CP time 6.890 root [2].x session4.C+(10000000) for N=10000000, sum= 4.59765e+006 Real time 0:00:09, CP time 1.062 root [3] session4(10000000) for N=10000000, sum= 4.59765e+006 Real time 0:00:01, CP time 1.052 root [4].q #include “TRandom.h” void session4 (int N) { TRandom r; double sum = 0; for (int i=0;i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.com/26/8439784/slides/slide_19.jpg", "name": "Introduction to ROOT19 My third session with ACLIC root [0] gROOT->Time(); root [1].x session4.C(10000000) for N=10000000, sum= 4.59765e+006 Real time 0:00:06, CP time 6.890 root [2].x session4.C+(10000000) for N=10000000, sum= 4.59765e+006 Real time 0:00:09, CP time 1.062 root [3] session4(10000000) for N=10000000, sum= 4.59765e+006 Real time 0:00:01, CP time 1.052 root [4].q #include TRandom.h void session4 (int N) { TRandom r; double sum = 0; for (int i=0;i

20 Introduction to ROOT20 Macros with more than one function root [0].x session5.C >session5.log root [1].q void session5(int N=100) { session5a(N); session5b(N); gROOT->ProcessLine(“.x session4.C+(1000)”); } void session5a(int N) { for (int i=0;isession5.log root [2] session5b(3) sum(0) = 0 sum(1) = 1 sum(2) = 3 root [3].q use gROOT->ProcessLine to execute a macro from a macro or from compiled code

21 R.Brun ROOT Overview21 Root prompt At the Root prompt, you can execute a C/C++ statement a CINT command (start with “.”).? Show list of CINT commands.q to quit the application.x file.C.L file.C.T trace mode for macros.!system_command, eg.!ls

22 Introduction to ROOT22 Graphics & GUI

23 Introduction to ROOT23 Gui/Graphics strategy TVirtualX TGWin32TGX11TGWin32GDKTGQt TVirtualPad TPad User/Root GUI and Graphics classes Applications see only Abstract Interfaces Low level screen graphics and GUI High level pad graphics TG??

24 Introduction to ROOT24 TPad: main graphics container Hello Root > TLine line(.1,.9,.6,.6) Root > line.Draw() Root > TText text(.5,.2,”Hello”) Root > text.Draw() The Draw function adds the object to the list of primitives of the current pad. If no pad exists, a pad is automatically created with a default range [0,1]. When the pad needs to be drawn or redrawn, the object Paint function is called. Only objects deriving from TObject may be drawn in a pad Root Objects or User objects

25 Introduction to ROOT25 Canvas pixmaps 600x400 1200x800 Scroll bars Need Help?

26 Introduction to ROOT26 Saving a pad/canvas A pad/canvas may be saved in many formats using the GUI menu or via TPad::SaveAs canvas.C : a C++ script is automatically generated. The canvas may be generated again via.x canvas.C canvas.ps(eps) Postscript or encapsulated ps canvas.svg : scalable vector graphics canvas.gif canvas.root: keep objects in a compressed and portable format.

27 Introduction to ROOT27 Full LateX support on screen and postscript TCurlyArc TCurlyLine TWavyLine and other building blocks for Feynmann diagrams Formula or diagrams can be edited with the mouse Feynman.C latex3.C

28 Introduction to ROOT28 Graphs TGraph(n,x,y) TCutG(n,x,y) TGraphErrors(n,x,y,ex,ey) TGraphAsymmErrors(n,x,y,exl,exh,eyl,eyh) TMultiGraph gerrors2.C

29 Introduction to ROOT29 Graphs zdemo.C

30 Introduction to ROOT30 The Histogram Package

31 Introduction to ROOT31 The Histogram Classes Structure 1-Dim 2-Dim 3-Dim

32 Introduction to ROOT32 Histograms

33 Introduction to ROOT33 Peak Finder + Deconvolutions TSpectrum

34 Introduction to ROOT34 Fitting TVirtualFitter TFitter TMinuit TH1::Fit bin chisquare bin likelihood TGraph::Fit unbinned chisquare User TTree::Fit unbinned likelihood TFumili

35 Introduction to ROOT35 Fitting histograms Histograms (1-D,2-D,3-D and Profiles) can be fitted with a user specified function via TH1::Fit. Two Fitting algorithms are supported: Chisquare method and Log Likelihood The user functions may be of the following types: standard functions: gaus, landau, expo, poln combination of standard functions; poln + gaus A C++ interpreted function or a C++ precompiled function An option is provided to compute the integral of the function bin by bin instead of simply compute the function value at the center of the bin. When an histogram is fitted, the resulting function with its parameters is added to the list of functions of this histogram. If the histogram is made persistent, the list of associated functions is also persistent. One can retrieve the function/fit parameters with calls such as: Double_t chi2 = myfunc->GetChisquare(); Double_t par0 = myfunc->GetParameter(0); //value of 1st parameter Double_t err0 = myfunc->GetParError(0); //error on first parameter

36 Introduction to ROOT36 Fitting Example

37 Introduction to ROOT37 Random Numbers and Histograms TH1::FillRandom can be used to randomly fill an histogram using the contents of an existing TF1 analytic function anothe r histogram (for all dimensions). For example the following two statements create and fill an histogram 10000 times with a default gaussian distribution of mean 0 and sigma 1: TH1F h1("h1","histo from a gaussian",100,-3,3); h1.FillRandom("gaus",10000); TH1::GetRandom can be used to return a random number distributed according the contents of an histogram.

38 Introduction to ROOT38 1-D drawing Options Any object in the canvas is clickable and editable

39 Introduction to ROOT39

40 Introduction to ROOT40 2-D drawing options

41 Introduction to ROOT41 2-D drawing options

42 Introduction to ROOT42 2-D drawing Options All these plots can be rotated with the mouse

43 Introduction to ROOT43 2-D drawing Options Same output on the screen and with vector Postscript

44 Introduction to ROOT44 Input/Output

45 Introduction to ROOT45 I/O Object in Memory Streamer: No need for transient / persistent classes http sockets File on disk Net File Web File XML XML File SQL DataBase Local Buffer

46 Introduction to ROOT46 TFile / TDirectory A TFile object may be divided in a hierarchy of directories, like a Unix file system. Two I/O modes are supported Key-mode (TKey). An object is identified by a name (key), like files in a Unix directory. OK to support up to a few thousand objects, like histograms, geometries, mag fields, etc. TTree-mode to store event data, when the number of events may be millions, billions.

47 Introduction to ROOT47 Self-describing files Dictionary for persistent classes written to the file. ROOT files can be read by foreign readers Support for Backward and Forward compatibility Files created in 2001 must be readable in 2015 Classes (data objects) for all objects in a file can be regenerated via TFile::MakeProject Root >TFile f(“demo.root”); Root > f.MakeProject(“dir”,”*”,”new++”);

48 Introduction to ROOT48 Example of key mode void keywrite() { TFile f(“keymode.root”,”new”); TH1F h(“hist”,”test”,100,-3,3); h.FillRandom(“gaus”,1000); h.Write() } void keyRead() { TFile f(“keymode.root”); TH1F *h = (TH1F*)f.Get(“hist”);; h.Draw(); }

49 Introduction to ROOT49 A Root file pippa.root with two levels of directories Objects in directory /pippa/DM/CJ eg: /pippa/DM/CJ/h15

50 Introduction to ROOT50 1 billion people surfing the Web LHC: How Much Data? 10 5 10 4 10 3 10 2 Level 1 Rate (Hz) High Level-1 Trigger (1 MHz) High No. Channels High Bandwidth (500 Gbit/s) High Data Archive (5 PetaBytes/year) 10 Gbits/s in Data base LHCB KLOE HERA-B CDF II CDF H1 ZEUS UA1 LEP NA49 ALICE Event Size (bytes) 10 4 10 5 10 6 ATLAS CMS 10 6 10 7 STAR

51 Introduction to ROOT51 ROOT Trees

52 Introduction to ROOT52 Why Trees ?  Trees have been designed to support very large collections of objects. The overhead in memory is in general less than 4 bytes per entry.  Trees allow direct and random access to any entry (sequential access is the best)  Trees have branches and leaves. One can read a subset of all branches.  High level functions like TTree::Draw loop on all entries with selection expressions.  Trees can be browsed via TBrowser  Trees can be analyzed via TTreeViewer

53 Introduction to ROOT53 Memory Tree Each Node is a branch in the Tree tr 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 T.Fill() T.GetEntry(6) T Memory

54 Introduction to ROOT54 ROOT I/O -- Split/Cluster Tree version Streamer File Branches Tree in memory Tree entries

55 Introduction to ROOT55 Writing/Reading a Tree class Event : public Something { Header fHeader; std::list fVertices; std::vector fTracks; TOF fTOF; Calor *fCalor; } main() { Event *event = 0; TFile f(“demo.root”,”recreate”); int split = 99; //maximum split TTree *T = new TTree(“T”,”demo Tree”); T->Branch(“event”,&event,split); for (int ev=0;ev<1000;ev++) { event = new Event(…); T->Fill(); delete event; } t->AutoSave(); } main() { Event *event = 0; TFile f(“demo.root”); TTree *T = (TTree*)f.Get”T”); T->SetBranchAddress(“event”,&event); Long64_t N = T->GetEntries(); for (Long64_t ev=0;evGetEntry(ev); // do something with event } Event.h Write.CRead.C

56 Introduction to ROOT56 8 Branches of T 8 leaves of branch Electrons A double-click to histogram the leaf Browsing a TTree with TBrowser

57 Introduction to ROOT57 The TTreeViewer

58 Introduction to ROOT58 TTree Selection Syntax Prints the first 8 variables of the tree. Prints all the variables of the tree. Specific variables of the tree can be explicit selected by list them in column separated list: 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 exactly 0. MyTree->Scan(); MyTree->Scan("*"); MyTree->Scan("var1:var2:var3"); MyTree->Scan("var1:var2:var3", "var1==0");

59 Introduction to ROOT59 Data Volume & Organisation 100MB1GB10GB1TB100GB100TB1PB10TB 1110000010000100010010 TTree TChain A TChain is a collection of TTrees or/and TChains A TFile typically contains 1 TTree A TChain is typically the result of a query to the file catalogue 1000000

60 Introduction to ROOT60 Chains of Trees A TChain is a collection of Trees. Same semantics for TChains and TTrees root >.x h1chain.C root > chain.Process(“h1analysis.C”) { //creates a TChain to be used by the h1analysis.C class //the symbol H1 must point to a directory where the H1 data sets //have been installed TChain chain("h42"); chain.Add("$H1/dstarmb.root"); chain.Add("$H1/dstarp1a.root"); chain.Add("$H1/dstarp1b.root"); chain.Add("$H1/dstarp2.root"); }

61 Introduction to ROOT61 Tree Friends 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Public read Public read User Write Entry # 8

62 Introduction to ROOT62 --------------- END -----------------

63 Introduction to ROOT63 Graphics & GUI

64 Introduction to ROOT64 TPad: main graphics container Hello Root > TLine line(.1,.9,.6,.6) Root > line.Draw() Root > TText text(.5,.2,”Hello”) Root > text.Draw() The Draw function adds the object to the list of primitives of the current pad. If no pad exists, a pad is automatically created with a default range [0,1]. When the pad needs to be drawn or redrawn, the object Paint function is called. Only objects deriving from TObject may be drawn in a pad Root Objects or User objects

65 Introduction to ROOT65 Basic Primitives TButton TLineTArrow TEllipse TCurvyLine TPaveLabel TPave TDiamond TPavesText TPolyLine TLatex TCrown TMarker TText TCurlyArc TBox

66 Introduction to ROOT66 Full LateX support on screen and postscript TCurlyArc TCurlyLine TWavyLine and other building blocks for Feynmann diagrams Formula or diagrams can be edited with the mouse Feynman.C latex3.C

67 Introduction to ROOT67 Graphs TGraph(n,x,y) TCutG(n,x,y) TGraphErrors(n,x,y,ex,ey) TGraphAsymmErrors(n,x,y,exl,exh,eyl,eyh) TMultiGraph gerrors2.C

68 Introduction to ROOT68 Graphics examples

69 Introduction to ROOT69

70 Introduction to ROOT70

71 Introduction to ROOT71

72 Introduction to ROOT72 Graphics (2D-3D) “SURF” “LEGO” TF3 TH3 TGLParametric

73 Introduction to ROOT73 ASImage: Image processor

74 Introduction to ROOT74 GUI (Graphical User Interface)

75 Introduction to ROOT75 Canvas tool bar/menus/help

76 Introduction to ROOT76 Object editor Click on any object to show its editor

77 Introduction to ROOT77 RIDE widget (future default browser) see $ROOTSYS/test/RootIDE

78 Introduction to ROOT78 RIDE widget (future default browser)

79 Introduction to ROOT79 GUI C++ code generator When pressing ctrl+S on any widget it is saved as a C++ macro file thanks to the SavePrimitive methods implemented in all GUI classes. The generated macro can be edited and then executed via CINT Executing the macro restores the complete original GUI as well as all created signal/slot connections in a global way // transient frame TGTransientFrame *frame2 = new TGTransientFrame(gClient- >GetRoot(),760,590); // group frame TGGroupFrame *frame3 = new TGGroupFrame(frame2,"curve"); TGRadioButton *frame4 = new TGRadioButton(frame3,"gaus",10); frame3->AddFrame(frame4); root [0].x example.C

80 Introduction to ROOT80 The GUI builder provides GUI tools for developing user interfaces based on the ROOT GUI classes. It includes over 30 advanced widgets and an automatic C++ code generator. The GUI Builder

81 Introduction to ROOT81 More GUI Examples $ROOTSYS/tutorials/gui $ROOTSYS/test/RootShower $ROOTSYS/test/RootIDE

82 Introduction to ROOT82 Geometry The GEOMetry package is used to model very complex detectors (LHC). It includes -a visualization system -a navigator (where am I, distances, overlaps, etc)

83 Introduction to ROOT83 OpenGL see $ROOTSYS/tutorials/geom

84 Introduction to ROOT84 Math libraries

85 Introduction to ROOT85 Peak Finder + Deconvolutions TSpectrum

86 Introduction to ROOT86 Fitters Minuit Fumili LinearFitter RobustFitter Roofit

87 Introduction to ROOT87 Fit Panel

88 Introduction to ROOT88 Roofit: a powerful fitting framework see $ROOTSYS/tutorials/fit/RoofitDemo.C

89 Introduction to ROOT89 GRIDs & PROOF

90 Introduction to ROOT90 From the desktop to the GRID Desktop Local/remote Storage Online/Offline Farms GRID New data analysis tools must be able to use in parallel remote CPUS, storage elements and networks in a transparent way for a user at a desktop

91 Introduction to ROOT91 GRID: Interactive Analysis Case 1 Data transfer to user’s laptop Optional Run/File catalog Optional GRID software Optional run/File Catalog Remote file server eg xrootd Trees Analysis scripts are interpreted or compiled on the local machine

92 Introduction to ROOT92 GRID: Interactive Analysis Case 2 Remote data processing Optional Run/File catalog Optional GRID software Optional run/File Catalog Remote data analyzer eg proofd Trees Commands, scripts histograms Analysis scripts are interpreted or compiled on the remote machine

93 Introduction to ROOT93 GRID: Interactive Analysis Case 3 Remote data processing Run/File catalog Full GRID software Run/File Catalog Remote data analyzer eg proofd Trees Commands, scripts Histograms,trees Trees slave Analysis scripts are interpreted or compiled on the remote master(s)

94 Introduction to ROOT94 Parallel ROOT Facility The PROOF system allows: Parallel analysis of trees in a set of files Parallel analysis of objects in a set of files Parallel execution of scripts on clusters of heterogeneous machines Its design goals are: Transparency, scalability, adaptability

95 Introduction to ROOT95 PROOF Storage PROOF farm MASTER  farm perceived as extension of local PC  same syntax as in local session  more dynamic use of resources  real time feedback  automated splitting and merging commands,scripts list of output objects (histograms, …)

96 Introduction to ROOT96 Sample of analysis activity G. Ganis, CHEP06, 15 Feb 2006 AQ1: 1s query produces a local histogram AQ2: a 10mn query submitted to PROOF1 AQ3->AQ7: short queries AQ8: a 10h query submitted to PROOF2 BQ1: browse results of AQ2 BQ2: browse temporary results of AQ8 BQ3->BQ6: submit 4 10mn queries to PROOF1 CQ1: Browse results of AQ8, BQ3->BQ6 Monday at 10h15 ROOT session on my laptop Monday at 16h25 ROOT session on my laptop Wednesday at 8h40 Browse from any web browser

97 Introduction to ROOT97 ROOT is MORE…. In this talk, I presented the most basic classes typically used during Physics Analysis. ROOT contains many more libraries, eg FFT library Oracle, MySQL, etc interfaces XML drivers TMVA (Multi Variate Analysis) GRID and networking classes, threads Interfaces to Castor, Dcache, GFAL, xrootd Interfaces to Pythia, Geant3, Geant4, gdml Matrix packages, Fitting packages, etc

98 Introduction to ROOT98 Documentation Users Guide and Reference Manuals are available at http://root.cern.chhttp://root.cern.ch Printed copies of the Users Guide are available in Building 32-R-C13 or 32-R-C16 Enjoy Reading Now Demo


Download ppt "Introduction to ROOT1 Summer Students Lecture 10 July 2007 Ren é Brun CERN/PH/SFT Introduction to ROOT"

Similar presentations


Ads by Google