Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TFileDrawMap.cxx
Go to the documentation of this file.
1// @(#)root/treeplayer:$Id$
2// Author: Rene Brun 15/01/2003
3
4/*************************************************************************
5 * Copyright (C) 1995-2003, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12/** \class TFileDrawMap
13This class is automatically called by TFile::DrawMap.
14It draws a canvas showing the internal structure of a ROOT file.
15Each key or basket in a file is shown with a fill area drawn
16at the byte position of the key/basket in the file.
17The Y axis of the canvas shows the number of Kbytes/Mbytes.
18The X axis shows the bytes between y(i) and y(i+1).
19A color corresponding to the class in the key/basket is automatically
20selected using the class unique identifier.
21
22When moving the mouse in the canvas, the "Event Status" panels
23shows the object corresponding to the mouse position.
24if the object is a key, it shows the class and object name as well as
25the file directory name if the file has sub-directories.
26
27if the object is a basket, it shows:
28 - the name of the Tree
29 - the name of the branch
30 - the basket number
31 - the entry number in the basket
32
33Special keys like the StreamerInfo record, the Keys List Record
34and the Free Blocks Record are also shown.
35
36When clicking the right mouse button, a pop-up menu is shown
37with its title identifying the picked object and with the items:
38 - DrawObject: in case of a key, the Draw function of the object is called
39 in case of a basket, the branch is drawn for all entries
40 - DumpObject: in case of a key, the Dump function of the object is called
41 in case of a basket, tree->Show(entry) is called
42 - InspectObject: the Inspect function is called for the object.
43
44The normal axis zoom functionality can be used to zoom or unzoom
45One can also use the TCanvas context menu SetCanvasSize to make
46a larger canvas and use the canvas scroll bars.
47
48When the class is built, it is possible to identify a subset of the
49objects to be shown. For example, to view only the keys with
50names starting with "abc", set the argument keys to "abc*".
51The default is to view all the objects.
52The argument options can also be used (only one option currently)
53When the option "same" is given, the new picture is superimposed.
54The option "same" is useful, eg:
55to draw all keys with names = "abc" in a first pass
56then all keys with names = "uv*" in a second pass, etc.
57*/
58
59#include "TFileDrawMap.h"
60#include "TROOT.h"
61#include "TClass.h"
62#include "TFile.h"
63#include "TTree.h"
64#include "TBranch.h"
65#include "TLeaf.h"
66#include "TMath.h"
67#include "TVirtualPad.h"
68#include "TVirtualX.h"
69#include "TH2.h"
70#include "TBox.h"
71#include "TKey.h"
72#include "TRegexp.h"
73#include "TSystem.h"
74#include "strlcpy.h"
75
76
77////////////////////////////////////////////////////////////////////////////////
78/// Default TreeFileMap constructor.
79
81{
82 fFile = nullptr;
83 fFrame = nullptr;
84 fXsize = 1000;
85 fYsize = 1000;
86}
87
88////////////////////////////////////////////////////////////////////////////////
89/// TFileDrawMap normal constructor.
90/// see descriptions of arguments above
91
92TFileDrawMap::TFileDrawMap(const TFile *file, const char *keys, Option_t *)
93 : TNamed("TFileDrawMap","")
94{
95 fFile = (TFile*) file;
96 fKeys = keys;
98
99 //create histogram used to draw the map frame
100
101 if (file->GetEND() > 1000000) {
102 fXsize = 1000000;
103 } else {
104 fXsize = 1000;
105 }
106 fYsize = 1 + Int_t(file->GetEND()/fXsize);
107
108 fFrame = new TH2D("hmapframe","",100,0,fXsize,100,0,fYsize);
109 fFrame->SetDirectory(nullptr);
112 if (fXsize > 1000) {
113 fFrame->GetYaxis()->SetTitle("MBytes");
114 } else {
115 fFrame->GetYaxis()->SetTitle("KBytes");
116 }
117 fFrame->GetXaxis()->SetTitle("Bytes");
118
119 if (gPad)
120 gPad->Clear();
121
122 fFrame->Draw("axis");
123 Draw();
124
125 if (gPad)
126 gPad->Update();
127}
128
129////////////////////////////////////////////////////////////////////////////////
130/// Tree destructor.
131
133{
134 //delete fFrame; //should not be deleted (kCanDelete set)
135}
136
137////////////////////////////////////////////////////////////////////////////////
138/// Returns info which corresponds to recent mouse position
139/// In case of normal graphics it is object name
140/// In case of web canvas use stored click event position
141
143{
145 if (gPad && gPad->IsWeb()) {
146 // in case of web canvas one can try to use last click event
147 GetObjectInfoDir(fFile, gPad->GetEventX(), gPad->GetEventY(), info);
148 } else {
149 // last selected place stored as name
150 info = GetName();
151 }
152 return info;
153}
154
155
156////////////////////////////////////////////////////////////////////////////////
157/// Show sequence of baskets reads for the list of baskets involved
158/// in the list of branches (separated by ",")
159/// - if branches="", the branch pointed by the mouse is taken.
160/// - if branches="*", all branches are taken
161/// Example:
162///
163/// AnimateTree("x,y,u");
164
166{
168
169 auto pos = info.Index(", basket=");
170 if (pos == kNPOS)
171 return;
172 info.Remove(pos);
173
174 pos = info.Index(", branch=");
175 if (pos == kNPOS)
176 return;
177 TString select_branches = info(pos + 9, info.Length() - pos - 9);
178
179 auto colon = info.Index("::");
180 if (colon == kNPOS)
181 return;
182
183 info.Resize(colon - 1);
184
185 auto tree = fFile->Get<TTree>(info);
186 if (!tree)
187 return;
188 if (branches && *branches)
190
191 // create list of branches
192 Int_t nzip = 0;
194 TObjArray list;
195 char *comma;
196 while((comma = strrchr((char*)select_branches.Data(),','))) {
197 *comma = 0;
198 comma++;
199 while (*comma == ' ') comma++;
200 branch = tree->GetBranch(comma);
201 if (branch) {
202 nzip += (Int_t)branch->GetZipBytes();
203 branch->SetUniqueID(0);
204 list.Add(branch);
205 }
206 }
207 comma = (char*)select_branches.Data();
208 while (*comma == ' ') comma++;
209 branch = tree->GetBranch(comma);
210 if (branch) {
211 nzip += (Int_t)branch->GetZipBytes();
212 branch->SetUniqueID(0);
213 list.Add(branch);
214 }
216 Int_t nbranches = list.GetEntries();
217
218 // loop on all tree entries
219 Int_t nentries = (Int_t)tree->GetEntries();
220 Int_t sleep = 1;
222 if (stime < 10) {stime=1; sleep = nentries/400;}
223 gPad->SetDoubleBuffer(0); // turn off double buffer mode
224 gVirtualX->SetDrawMode(TVirtualX::kInvert); // set the drawing mode to XOR mode
225 for (Int_t entry=0;entry<nentries;entry++) {
226 for (Int_t ib=0;ib<nbranches;ib++) {
227 branch = (TBranch*)list.At(ib);
228 Int_t nbaskets = branch->GetListOfBaskets()->GetSize();
230 Int_t nbytes = branch->GetBasketBytes()[basket];
231 Int_t bseek = branch->GetBasketSeek(basket);
232 Int_t entry0 = branch->GetBasketEntry()[basket];
233 Int_t entryn = branch->GetBasketEntry()[basket+1];
235 DrawMarker(ib,branch->GetUniqueID());
237 branch->SetUniqueID(eseek);
239 if (entry%sleep == 0) gSystem->Sleep(stime);
240 }
241 }
242}
243
244////////////////////////////////////////////////////////////////////////////////
245/// Compute distance from point px,py to this TreeFileMap.
246/// Find the closest object to the mouse, save its path in the TFileDrawMap name.
247
249{
250 Int_t pxmin = gPad->XtoAbsPixel(gPad->GetUxmin());
251 Int_t pxmax = gPad->XtoAbsPixel(gPad->GetUxmax());
252 Int_t pymin = gPad->YtoAbsPixel(gPad->GetUymin());
253 Int_t pymax = gPad->YtoAbsPixel(gPad->GetUymax());
254 if (px > pxmin && px < pxmax && py > pymax && py < pymin) {
255 SetName(GetObjectInfo(px,py));
256 return 0;
257 }
258 return fFrame->DistancetoPrimitive(px,py);
259}
260
261////////////////////////////////////////////////////////////////////////////////
262/// Draw marker.
263
265{
266 Int_t iy = gPad->YtoAbsPixel(eseek/fXsize);
267 Int_t ix = gPad->XtoAbsPixel(eseek%fXsize);
268 Int_t d;
269 Int_t mark = marker%4;
270 switch (mark) {
271 case 0 :
272 d = 6; //arrow
273 gVirtualX->DrawLine(ix-3*d,iy,ix,iy);
274 gVirtualX->DrawLine(ix-d,iy+d,ix,iy);
275 gVirtualX->DrawLine(ix-d,iy-d,ix,iy);
276 gVirtualX->DrawLine(ix-d,iy-d,ix-d,iy+d);
277 break;
278 case 1 :
279 d = 5; //up triangle
280 gVirtualX->DrawLine(ix-d,iy-d,ix+d,iy-d);
281 gVirtualX->DrawLine(ix+d,iy-d,ix,iy+d);
282 gVirtualX->DrawLine(ix,iy+d,ix-d,iy-d);
283 break;
284 case 2 :
285 d = 5; //open square
286 gVirtualX->DrawLine(ix-d,iy-d,ix+d,iy-d);
287 gVirtualX->DrawLine(ix+d,iy-d,ix+d,iy+d);
288 gVirtualX->DrawLine(ix+d,iy+d,ix-d,iy+d);
289 gVirtualX->DrawLine(ix-d,iy+d,ix-d,iy-d);
290 break;
291 case 3 :
292 d = 8; //cross
293 gVirtualX->DrawLine(ix-d,iy,ix+d,iy);
294 gVirtualX->DrawLine(ix,iy-d,ix,iy+d);
295 break;
296 }
297}
298
299////////////////////////////////////////////////////////////////////////////////
300/// Draw object at the mouse position.
301
303{
304 TVirtualPad *padsave = gROOT->GetSelectedPad();
305 if ((padsave == gPad) || (gPad && gPad->IsWeb())) {
306 //must create a new canvas
307 gROOT->MakeDefCanvas();
308 } else if (padsave) {
309 padsave->cd();
310 }
311
313
314 // case of a TTree
315 auto pbasket = info.Index(", basket=");
316 if (pbasket != kNPOS) {
317 info.Resize(pbasket);
318 auto pbranch = info.Index(", branch=");
319 if (pbranch == kNPOS)
320 return;
321
322 TString cbranch = info(pbranch + 9, info.Length() - pbranch - 9);
323
324 auto colon = info.Index("::");
325 if (colon == kNPOS)
326 return;
327
328 info.Resize(colon - 1);
329
330 auto tree = fFile->Get<TTree>(info);
331 if (tree)
332 tree->Draw(cbranch);
333 } else {
334 // other objects
335 auto obj = GetObject();
336 if (obj)
337 obj->Draw();
338 }
339}
340
341
342////////////////////////////////////////////////////////////////////////////////
343/// Dump object at the mouse position.
344
346{
347 TObject *obj = GetObject();
348 if (obj) {
349 obj->Dump();
350 return;
351 }
352
354
355 auto indx = info.Index("entry=");
356 if (indx == kNPOS)
357 return;
358
359 Int_t entry = 0;
360 sscanf(info.Data() + indx + 6, "%d", &entry);
361
362 auto colon = info.Index("::");
363 if (colon == kNPOS)
364 return;
365
366 info.Resize(colon - 1);
367
368 auto tree = fFile->Get<TTree>(info);
369 if (tree)
370 tree->Show(entry);
371}
372
373////////////////////////////////////////////////////////////////////////////////
374/// Retrieve object at the mouse position in memory.
375
377{
379
380 if (info.Contains("entry="))
381 return nullptr;
382
383 auto colon = info.Index("::");
384 if (colon == kNPOS)
385 return nullptr;
386
387 info.Resize(colon - 1);
388
389 return fFile->Get(info);
390}
391
392////////////////////////////////////////////////////////////////////////////////
393/// Redefines TObject::GetObjectInfo.
394/// Displays the keys info in the file corresponding to cursor position px,py
395/// in the canvas status bar info panel
396
398{
399 // Thread safety: this solution is not elegant, but given the action performed
400 // by the method, this construct can be considered non-problematic.
401 static TString info;
402 GetObjectInfoDir(fFile, px, py, info);
403 return (char*)info.Data();
404}
405
406////////////////////////////////////////////////////////////////////////////////
407/// Redefines TObject::GetObjectInfo.
408/// Displays the keys info in the directory
409/// corresponding to cursor position px,py
410
412{
413 Double_t x = gPad->AbsPixeltoX(px);
414 Double_t y = gPad->AbsPixeltoY(py);
415 Int_t iy = (Int_t)y;
420 dir->cd();
421
422 TIter next(dir->GetListOfKeys());
423 TKey *key;
424 while ((key = (TKey*)next())) {
427 // a TDirectory ?
428 if (cl && cl == TDirectoryFile::Class()) {
429 curdir->cd(key->GetName());
431 bool gotInfo = GetObjectInfoDir(subdir, px, py, info);
432 if (gotInfo) {
433 dirsav->cd();
434 return true;
435 }
436 curdir->cd();
437 continue;
438 }
439 // a TTree ?
440 if (cl && cl->InheritsFrom(TTree::Class())) {
441 TTree *tree = (TTree*)gDirectory->Get(key->GetName());
442 TIter nextb(tree->GetListOfLeaves());
443 while (auto leaf = (TLeaf *)nextb()) {
444 TBranch *branch = leaf->GetBranch();
445 Int_t nbaskets = branch->GetMaxBaskets();
446 Int_t offsets = branch->GetEntryOffsetLen();
447 Int_t len = leaf->GetLen();
448 for (Int_t i = 0; i < nbaskets; i++) {
449 bseek = branch->GetBasketSeek(i);
450 if (!bseek)
451 break;
452 nbytes = branch->GetBasketBytes()[i];
453 if (pbyte >= bseek && pbyte < bseek + nbytes) {
454 Int_t entry = branch->GetBasketEntry()[i];
455 if (!offsets) entry += (pbyte-bseek)/len;
456 if (curdir == (TDirectory*)fFile) {
457 info.Form("%s%s ::%s, branch=%s, basket=%d, entry=%d",curdir->GetPath(),key->GetName(),key->GetClassName(),branch->GetName(),i,entry);
458 } else {
459 info.Form("%s/%s ::%s, branch=%s, basket=%d, entry=%d",curdir->GetPath(),key->GetName(),key->GetClassName(),branch->GetName(),i,entry);
460 }
461 return true;
462 }
463 }
464 }
465 }
466 nbytes = key->GetNbytes();
467 bseek = key->GetSeekKey();
468 if (pbyte >= bseek && pbyte < bseek+nbytes) {
469 if (curdir == (TDirectory*)fFile) {
470 info.Form("%s%s ::%s, nbytes=%d",curdir->GetPath(),key->GetName(),key->GetClassName(),nbytes);
471 } else {
472 info.Form("%s/%s ::%s, nbytes=%d",curdir->GetPath(),key->GetName(),key->GetClassName(),nbytes);
473 }
474 dirsav->cd();
475 return true;
476 }
477 }
478 // Are we in the Keys list
479 if (pbyte >= dir->GetSeekKeys() && pbyte < dir->GetSeekKeys()+dir->GetNbytesKeys()) {
480 info.Form("%sKeys List, nbytes=%d",dir->GetPath(),dir->GetNbytesKeys());
481 dirsav->cd();
482 return true;
483 }
484 if (dir == (TDirectory*)fFile) {
485 // Are we in the TStreamerInfo
487 info.Form("%sStreamerInfo List, nbytes=%d",dir->GetPath(),fFile->GetNbytesInfo());
488 dirsav->cd();
489 return true;
490 }
491 // Are we in the Free Segments
493 info.Form("%sFree List, nbytes=%d",dir->GetPath(),fFile->GetNbytesFree());
494 dirsav->cd();
495 return true;
496 }
497 }
498 info.Form("(byte=%lld)",pbyte);
499 dirsav->cd();
500 return false;
501}
502
503////////////////////////////////////////////////////////////////////////////////
504/// Inspect object at the mouse position.
505
507{
508 TObject *obj = GetObject();
509 if (obj) obj->Inspect();
510}
511
512////////////////////////////////////////////////////////////////////////////////
513/// Paint this TFileDrawMap.
514
516{
517 //draw keys
519}
520
521////////////////////////////////////////////////////////////////////////////////
522/// Paint the object at bseek with nbytes using the box object.
523
525{
526 Int_t iy = bseek/fXsize;
527 Int_t ix = bseek%fXsize;
528 Int_t ny = 1+(nbytes+ix)/fXsize;
530 for (Int_t j=0;j<ny;j++) {
531 if (j == 0) xmin = (Double_t)ix;
532 else xmin = 0;
533 xmax = xmin + nbytes;
534 if (xmax > fXsize) xmax = fXsize;
535 ymin = iy+j;
536 ymax = ymin+1;
537 nbytes -= (Int_t)(xmax-xmin);
538 if (xmax < gPad->GetUxmin()) continue;
539 if (xmin > gPad->GetUxmax()) continue;
540 if (xmin < gPad->GetUxmin()) xmin = gPad->GetUxmin();
541 if (xmax > gPad->GetUxmax()) xmax = gPad->GetUxmax();
542 if (ymax < gPad->GetUymin()) continue;
543 if (ymin > gPad->GetUymax()) continue;
544 if (ymin < gPad->GetUymin()) ymin = gPad->GetUymin();
545 if (ymax > gPad->GetUymax()) ymax = gPad->GetUymax();
546 //box.TAttFill::Modify();
547 box.PaintBox(xmin,ymin,xmax,ymax);
548 }
549}
550
551////////////////////////////////////////////////////////////////////////////////
552/// Paint keys in a directory.
553
554void TFileDrawMap::PaintDir(TDirectory *dir, const char *keys)
555{
557 TIter next(dir->GetListOfKeys());
558 TKey *key;
559 Int_t color = 0;
560 TBox box;
561 TRegexp re(keys,true);
562 while ((key = (TKey*)next())) {
563 Int_t nbytes = key->GetNbytes();
564 Long64_t bseek = key->GetSeekKey();
566 if (cl) {
567 color = (Int_t)(cl->GetUniqueID()%20);
568 } else {
569 color = 1;
570 }
571 box.SetFillColor(color);
572 box.SetFillStyle(1001);
573 TString s = key->GetName();
574 if (strcmp(fKeys.Data(),key->GetName()) && s.Index(re) == kNPOS) continue;
575 // a TDirectory ?
576 if (cl && cl == TDirectoryFile::Class()) {
578 gDirectory->cd(key->GetName());
580 PaintDir(subdir,"*");
581 curdir->cd();
582 }
584 // a TTree ?
585 if (cl && cl->InheritsFrom(TTree::Class())) {
586 TTree *tree = (TTree*)gDirectory->Get(key->GetName());
587 TIter nextb(tree->GetListOfLeaves());
588 while (auto leaf = (TLeaf*)nextb()) {
589 TBranch *branch = leaf->GetBranch();
590 color = branch->GetFillColor();
591 if (color == 0) {
592 if (fBranchColors.find(branch) == fBranchColors.end()) {
593 gPad->IncrementPaletteColor(1, "pfc");
594 fBranchColors[branch] = gPad->NextPaletteColor();
595 }
596 color = fBranchColors[branch];
597 }
598 box.SetFillColor(color);
599 Int_t nbaskets = branch->GetMaxBaskets();
600 for (Int_t i=0;i<nbaskets;i++) {
601 bseek = branch->GetBasketSeek(i);
602 if (!bseek) break;
603 nbytes = branch->GetBasketBytes()[i];
605 }
606 }
607 }
608 }
609
610 // draw the box for Keys list
611 box.SetFillColor(50);
612 box.SetFillStyle(1001);
613 PaintBox(box,dir->GetSeekKeys(),dir->GetNbytesKeys());
614 if (dir == (TDirectory*)fFile) {
615 // draw the box for TStreamerInfo
616 box.SetFillColor(6);
617 box.SetFillStyle(3008);
619 // draw the box for Free Segments
620 box.SetFillColor(1);
621 box.SetFillStyle(1001);
623 }
624 dirsav->cd();
625}
#define d(i)
Definition RSha256.hxx:102
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:59
double Double_t
Double 8 bytes.
Definition RtypesCore.h:73
constexpr Ssiz_t kNPOS
The equivalent of std::string::npos for the ROOT class TString.
Definition RtypesCore.h:131
long long Long64_t
Portable signed long integer 8 bytes.
Definition RtypesCore.h:83
const char Option_t
Option string (const char)
Definition RtypesCore.h:80
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
#define gDirectory
Definition TDirectory.h:385
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
float xmin
int nentries
float ymin
float xmax
float ymax
R__EXTERN C unsigned int sleep(unsigned int seconds)
#define gROOT
Definition TROOT.h:411
R__EXTERN TSystem * gSystem
Definition TSystem.h:572
#define gPad
#define gVirtualX
Definition TVirtualX.h:337
Create a Box.
Definition TBox.h:22
A TTree is a list of TBranches.
Definition TBranch.h:93
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:84
Bool_t InheritsFrom(const char *cl) const override
Return kTRUE if this class inherits from a class with name "classname".
Definition TClass.cxx:4901
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition TClass.cxx:2973
static TClass * Class()
TObject * Get(const char *namecycle) override
Return pointer to object identified by namecycle.
Describe directory structure in memory.
Definition TDirectory.h:45
virtual Int_t GetNbytesKeys() const
Definition TDirectory.h:227
virtual const char * GetPath() const
Returns the full path of the directory.
virtual Bool_t cd()
Change current directory to "this" directory.
virtual Long64_t GetSeekKeys() const
Definition TDirectory.h:231
virtual TList * GetListOfKeys() const
Definition TDirectory.h:224
virtual bool GetObjectInfoDir(TDirectory *dir, Int_t px, Int_t py, TString &info) const
Redefines TObject::GetObjectInfo.
TFile * fFile
! Pointer to the file, cannot be persistent
virtual void DrawObject()
Draw object at the mouse position.
virtual void DrawMarker(Int_t marker, Long64_t eseek)
Draw marker.
Int_t fYsize
Size in K/Mbytes of Y axis.
TString fKeys
List of keys.
~TFileDrawMap() override
Tree destructor.
virtual void PaintDir(TDirectory *dir, const char *keys)
Paint keys in a directory.
Int_t fXsize
Size in bytes of X axis.
virtual void DumpObject()
Dump object at the mouse position.
virtual void InspectObject()
Inspect object at the mouse position.
TFileDrawMap()
Default TreeFileMap constructor.
TString GetRecentInfo()
Returns info which corresponds to recent mouse position In case of normal graphics it is object name ...
char * GetObjectInfo(Int_t px, Int_t py) const override
Redefines TObject::GetObjectInfo.
TH2 * fFrame
Histogram used to draw the map frame.
virtual void PaintBox(TBox &box, Long64_t bseek, Int_t nbytes)
Paint the object at bseek with nbytes using the box object.
virtual TObject * GetObject()
Retrieve object at the mouse position in memory.
virtual void AnimateTree(const char *branches="")
Show sequence of baskets reads for the list of baskets involved in the list of branches (separated by...
std::map< TBranch *, Int_t > fBranchColors
! map of generated colors for the branches
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Compute distance from point px,py to this TreeFileMap.
void Paint(Option_t *option) override
Paint this TFileDrawMap.
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
Definition TFile.h:131
virtual Long64_t GetSeekFree() const
Definition TFile.h:331
virtual Long64_t GetEND() const
Definition TFile.h:310
virtual Long64_t GetSeekInfo() const
Definition TFile.h:332
virtual Int_t GetNbytesFree() const
Definition TFile.h:328
virtual Int_t GetNbytesInfo() const
Definition TFile.h:327
virtual void SetDirectory(TDirectory *dir)
By default, when a histogram is created, it is added to the list of histogram objects in the current ...
Definition TH1.cxx:8978
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Compute distance from point px,py to a line.
Definition TH1.cxx:2805
@ kNoStats
Don't draw stats box.
Definition TH1.h:404
TAxis * GetXaxis()
Definition TH1.h:572
TAxis * GetYaxis()
Definition TH1.h:573
void Draw(Option_t *option="") override
Draw this histogram with options.
Definition TH1.cxx:3048
2-D histogram with a double per channel (see TH1 documentation)
Definition TH2.h:356
Book space in a file, create I/O buffers, to fill them, (un)compress them.
Definition TKey.h:28
virtual Long64_t GetSeekKey() const
Definition TKey.h:89
Int_t GetNbytes() const
Definition TKey.h:86
virtual const char * GetClassName() const
Definition TKey.h:75
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition TLeaf.h:57
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:173
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:149
An array of TObjects.
Definition TObjArray.h:31
Mother of all ROOT objects.
Definition TObject.h:41
virtual void Inspect() const
Dump contents of this object in a graphics canvas.
Definition TObject.cxx:564
virtual void Dump() const
Dump contents of object on stdout.
Definition TObject.cxx:366
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition TObject.cxx:475
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:864
@ kCanDelete
if object in a list can be deleted
Definition TObject.h:68
Regular expression class.
Definition TRegexp.h:31
Basic string class.
Definition TString.h:138
const char * Data() const
Definition TString.h:384
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:659
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
Definition TSystem.cxx:435
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
Definition TSystem.cxx:414
A TTree represents a columnar dataset.
Definition TTree.h:89
static TClass * Class()
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition TVirtualPad.h:51
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition fillpatterns.C:1
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
Long64_t BinarySearch(Long64_t n, const T *array, T value)
Binary search in an array of n values to locate value.
Definition TMathBase.h:348
th1 Draw()