Logo ROOT   6.21/01
Reference Guide
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
13 This class is automatically called by TFile::DrawMap.
14 It draws a canvas showing the internal structure of a ROOT file.
15 Each key or basket in a file is shown with a fill area drawn
16 at the byte position of the key/basket in the file.
17 The Y axis of the canvas shows the number of Kbytes/Mbytes.
18 The X axis shows the bytes between y(i) and y(i+1).
19 A color corresponding to the class in the key/basket is automatically
20 selected using the class unique identifier.
21 
22 When moving the mouse in the canvas, the "Event Status" panels
23 shows the object corresponding to the mouse position.
24 if the object is a key, it shows the class and object name as well as
25 the file directory name if the file has sub-directories.
26 
27 if 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 
33 Special keys like the StreamerInfo record, the Keys List Record
34 and the Free Blocks Record are also shown.
35 
36 When clicking the right mouse button, a pop-up menu is shown
37 with 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 
44 The normal axis zoom functionality can be used to zoom or unzoom
45 One can also use the TCanvas context menu SetCanvasSize to make
46 a larger canvas and use the canvas scroll bars.
47 
48 When the class is built, it is possible to identify a subset of the
49 objects to be shown. For example, to view only the keys with
50 names starting with "abc", set the argument keys to "abc*".
51 The default is to view all the objects.
52 The argument options can also be used (only one option currently)
53 When the option "same" is given, the new picture is suprimposed.
54 The option "same" is useful, eg:
55 to draw all keys with names = "abc" in a first pass
56 then 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 "TStyle.h"
69 #include "TH1.h"
70 #include "TBox.h"
71 #include "TKey.h"
72 #include "TRegexp.h"
73 #include "TSystem.h"
74 
76 
77 ////////////////////////////////////////////////////////////////////////////////
78 /// Default TreeFileMap constructor.
79 
81 {
82  fFile = 0;
83  fFrame = 0;
84  fXsize = 1000;
85  fYsize = 1000;
86 }
87 
88 ////////////////////////////////////////////////////////////////////////////////
89 /// TFileDrawMap normal constructor.
90 /// see descriptions of arguments above
91 
92 TFileDrawMap::TFileDrawMap(const TFile *file, const char *keys, Option_t *option)
93  : TNamed("TFileDrawMap","")
94 {
95  fFile = (TFile*)file;
96  fKeys = keys;
97  fOption = option;
98  fOption.ToLower();
100 
101  //create histogram used to draw the map frame
102 
103  if (file->GetEND() > 1000000) {
104  fXsize = 1000000;
105  } else {
106  fXsize = 1000;
107  }
108  fFrame = new TH1D("hmapframe","",1000,0,fXsize);
109  fFrame->SetDirectory(0);
112  fFrame->SetMinimum(0);
113  if (fXsize > 1000) {
114  fFrame->GetYaxis()->SetTitle("MBytes");
115  } else {
116  fFrame->GetYaxis()->SetTitle("KBytes");
117  }
118  fFrame->GetXaxis()->SetTitle("Bytes");
119  fYsize = 1 + Int_t(file->GetEND()/fXsize);
122 
123  //Bool_t show = kFALSE;
124  if (gPad) {
125  gPad->Clear();
126  //show = gPad->GetCanvas()->GetShowEventStatus();
127  }
128  Draw();
129  if (gPad) {
130  //if (!show) gPad->GetCanvas()->ToggleEventStatus();
131  gPad->Update();
132  }
133 }
134 
135 ////////////////////////////////////////////////////////////////////////////////
136 /// Tree destructor.
137 
139 {
140  //delete fFrame; //should not be deleted (kCanDelete set)
141 }
142 
143 ////////////////////////////////////////////////////////////////////////////////
144 /// Show sequence of baskets reads for the list of baskets involved
145 /// in the list of branches (separated by ",")
146 /// - if branches="", the branch pointed by the mouse is taken.
147 /// - if branches="*", all branches are taken
148 /// Example:
149 ///
150 /// AnimateTree("x,y,u");
151 
152 void TFileDrawMap::AnimateTree(const char *branches)
153 {
154  TString ourbranches( GetName() );
155  Ssiz_t pos = ourbranches.Index(", basket=");
156  if (pos == kNPOS) return;
157  ourbranches.Remove(pos);
158  pos = ourbranches.Index(", branch=");
159  if (pos == kNPOS) return;
160  ourbranches[pos] = 0;
161 
162  TTree *tree = (TTree*)fFile->Get(ourbranches.Data());
163  if (!tree) return;
164  TString info;
165  if (strlen(branches) > 0) info = branches;
166  else info = ourbranches.Data()+pos+9;
167  printf("Animating tree, branches=%s\n",info.Data());
168 
169  // create list of branches
170  Int_t nzip = 0;
171  TBranch *branch;
172  TObjArray list;
173  char *comma;
174  while((comma = strrchr((char*)info.Data(),','))) {
175  *comma = 0;
176  comma++;
177  while (*comma == ' ') comma++;
178  branch = tree->GetBranch(comma);
179  if (branch) {
180  nzip += (Int_t)branch->GetZipBytes();
181  branch->SetUniqueID(0);
182  list.Add(branch);
183  }
184  }
185  comma = (char*)info.Data();
186  while (*comma == ' ') comma++;
187  branch = tree->GetBranch(comma);
188  if (branch) {
189  nzip += (Int_t)branch->GetZipBytes();
190  branch->SetUniqueID(0);
191  list.Add(branch);
192  }
193  Double_t fractionRead = Double_t(nzip)/Double_t(fFile->GetEND());
194  Int_t nbranches = list.GetEntries();
195 
196  // loop on all tree entries
197  Int_t nentries = (Int_t)tree->GetEntries();
198  Int_t sleep = 1;
199  Int_t stime = (Int_t)(100./(nentries*fractionRead));
200  if (stime < 10) {stime=1; sleep = nentries/400;}
201  gPad->SetDoubleBuffer(0); // turn off double buffer mode
202  gVirtualX->SetDrawMode(TVirtualX::kInvert); // set the drawing mode to XOR mode
203  for (Int_t entry=0;entry<nentries;entry++) {
204  for (Int_t ib=0;ib<nbranches;ib++) {
205  branch = (TBranch*)list.At(ib);
206  Int_t nbaskets = branch->GetListOfBaskets()->GetSize();
207  Int_t basket = TMath::BinarySearch(nbaskets,branch->GetBasketEntry(), (Long64_t) entry);
208  Int_t nbytes = branch->GetBasketBytes()[basket];
209  Int_t bseek = branch->GetBasketSeek(basket);
210  Int_t entry0 = branch->GetBasketEntry()[basket];
211  Int_t entryn = branch->GetBasketEntry()[basket+1];
212  Int_t eseek = (Int_t)(bseek + nbytes*Double_t(entry-entry0)/Double_t(entryn-entry0));
213  DrawMarker(ib,branch->GetUniqueID());
214  DrawMarker(ib,eseek);
215  branch->SetUniqueID(eseek);
217  if (entry%sleep == 0) gSystem->Sleep(stime);
218  }
219  }
220 }
221 
222 ////////////////////////////////////////////////////////////////////////////////
223 /// Compute distance from point px,py to this TreeFileMap.
224 /// Find the closest object to the mouse, save its path in the TFileDrawMap name.
225 
227 {
228  Int_t pxmin = gPad->XtoAbsPixel(gPad->GetUxmin());
229  Int_t pxmax = gPad->XtoAbsPixel(gPad->GetUxmax());
230  Int_t pymin = gPad->YtoAbsPixel(gPad->GetUymin());
231  Int_t pymax = gPad->YtoAbsPixel(gPad->GetUymax());
232  if (px > pxmin && px < pxmax && py > pymax && py < pymin) {
233  SetName(GetObjectInfo(px,py));
234  return 0;
235  }
236  return fFrame->DistancetoPrimitive(px,py);
237 }
238 
239 ////////////////////////////////////////////////////////////////////////////////
240 /// Draw marker.
241 
243 {
244  Int_t iy = gPad->YtoAbsPixel(eseek/fXsize);
245  Int_t ix = gPad->XtoAbsPixel(eseek%fXsize);
246  Int_t d;
247  Int_t mark = marker%4;
248  switch (mark) {
249  case 0 :
250  d = 6; //arrow
251  gVirtualX->DrawLine(ix-3*d,iy,ix,iy);
252  gVirtualX->DrawLine(ix-d,iy+d,ix,iy);
253  gVirtualX->DrawLine(ix-d,iy-d,ix,iy);
254  gVirtualX->DrawLine(ix-d,iy-d,ix-d,iy+d);
255  break;
256  case 1 :
257  d = 5; //up triangle
258  gVirtualX->DrawLine(ix-d,iy-d,ix+d,iy-d);
259  gVirtualX->DrawLine(ix+d,iy-d,ix,iy+d);
260  gVirtualX->DrawLine(ix,iy+d,ix-d,iy-d);
261  break;
262  case 2 :
263  d = 5; //open square
264  gVirtualX->DrawLine(ix-d,iy-d,ix+d,iy-d);
265  gVirtualX->DrawLine(ix+d,iy-d,ix+d,iy+d);
266  gVirtualX->DrawLine(ix+d,iy+d,ix-d,iy+d);
267  gVirtualX->DrawLine(ix-d,iy+d,ix-d,iy-d);
268  break;
269  case 3 :
270  d = 8; //cross
271  gVirtualX->DrawLine(ix-d,iy,ix+d,iy);
272  gVirtualX->DrawLine(ix,iy-d,ix,iy+d);
273  break;
274  }
275 }
276 
277 ////////////////////////////////////////////////////////////////////////////////
278 /// Draw object at the mouse position.
279 
281 {
282  TVirtualPad *padsave = gROOT->GetSelectedPad();
283  if (padsave == gPad) {
284  //must create a new canvas
285  gROOT->MakeDefCanvas();
286  } else {
287  padsave->cd();
288  }
289 
290  // case of a TTree
291  char *info = new char[fName.Length()+1];
292  strlcpy(info,fName.Data(),fName.Length()+1);
293  char *cbasket = (char*)strstr(info,", basket=");
294  if (cbasket) {
295  *cbasket = 0;
296  char *cbranch = (char*)strstr(info,", branch=");
297  if (!cbranch) { delete [] info; return; }
298  *cbranch = 0;
299  cbranch += 9;
300  TTree *tree = (TTree*)fFile->Get(info);
301  if (tree) tree->Draw(cbranch);
302  delete [] info;
303  return;
304  }
305 
306  delete [] info;
307 
308  // other objects
309  TObject *obj = GetObject();
310  if (obj) obj->Draw();
311 }
312 
313 
314 ////////////////////////////////////////////////////////////////////////////////
315 /// Dump object at the mouse position.
316 
318 {
319  TObject *obj = GetObject();
320  if (obj) {
321  obj->Dump();
322  return;
323  }
324  char *centry = (char*)strstr(GetName(),"entry=");
325  if (!centry) return;
326  Int_t entry = 0;
327  sscanf(centry+6,"%d",&entry);
328  TString info(GetName());
329  char *colon = (char*)strstr((char*)info.Data(),"::");
330  if (!colon) return;
331  colon--;
332  *colon = 0;
333  TTree *tree; fFile->GetObject(info.Data(),tree);
334  if (tree) tree->Show(entry);
335 }
336 
337 ////////////////////////////////////////////////////////////////////////////////
338 /// Execute action corresponding to one event.
339 
341 {
342  fFrame->ExecuteEvent(event,px,py);
343 }
344 
345 ////////////////////////////////////////////////////////////////////////////////
346 /// Retrieve object at the mouse position in memory.
347 
349 {
350  if (strstr(GetName(),"entry=")) return 0;
351  char *info = new char[fName.Length()+1];
352  strlcpy(info,fName.Data(),fName.Length()+1);
353  char *colon = strstr(info,"::");
354  if (!colon) {
355  delete [] info;
356  return nullptr;
357  }
358  colon--;
359  *colon = 0;
360  auto res = fFile->Get(info);
361  delete [] info;
362  return res;
363 }
364 
365 ////////////////////////////////////////////////////////////////////////////////
366 /// Redefines TObject::GetObjectInfo.
367 /// Displays the keys info in the file corresponding to cursor position px,py
368 /// in the canvas status bar info panel
369 
371 {
372  // Thread safety: this solution is not elegant, but given the action performed
373  // by the method, this construct can be considered nonproblematic.
374  static TString info;
375  GetObjectInfoDir(fFile, px, py, info);
376  return (char*)info.Data();
377 }
378 
379 ////////////////////////////////////////////////////////////////////////////////
380 /// Redefines TObject::GetObjectInfo.
381 /// Displays the keys info in the directory
382 /// corresponding to cursor position px,py
383 
385 {
386  Double_t x = gPad->AbsPixeltoX(px);
387  Double_t y = gPad->AbsPixeltoY(py);
388  Int_t iy = (Int_t)y;
389  Long64_t pbyte = (Long64_t)(fXsize*iy+x);
390  Int_t nbytes;
391  Long64_t bseek;
392  TDirectory *dirsav = gDirectory;
393  dir->cd();
394 
395  TIter next(dir->GetListOfKeys());
396  TKey *key;
397  while ((key = (TKey*)next())) {
398  TDirectory *curdir = gDirectory;
399  TClass *cl = TClass::GetClass(key->GetClassName());
400  // a TDirectory ?
401  if (cl && cl == TDirectoryFile::Class()) {
402  curdir->cd(key->GetName());
403  TDirectory *subdir = gDirectory;
404  Bool_t gotInfo = GetObjectInfoDir(subdir, px, py, info);
405  if (gotInfo) {
406  dirsav->cd();
407  return kTRUE;
408  }
409  curdir->cd();
410  continue;
411  }
412  // a TTree ?
413  if (cl && cl->InheritsFrom(TTree::Class())) {
414  TTree *tree = (TTree*)gDirectory->Get(key->GetName());
415  TIter nextb(tree->GetListOfLeaves());
416  TLeaf *leaf;
417  while ((leaf = (TLeaf*)nextb())) {
418  TBranch *branch = leaf->GetBranch();
419  Int_t nbaskets = branch->GetMaxBaskets();
420  Int_t offsets = branch->GetEntryOffsetLen();
421  Int_t len = leaf->GetLen();
422  for (Int_t i=0;i<nbaskets;i++) {
423  bseek = branch->GetBasketSeek(i);
424  if (!bseek) break;
425  nbytes = branch->GetBasketBytes()[i];
426  if (pbyte >= bseek && pbyte < bseek+nbytes) {
427  Int_t entry = branch->GetBasketEntry()[i];
428  if (!offsets) entry += (pbyte-bseek)/len;
429  if (curdir == (TDirectory*)fFile) {
430  info.Form("%s%s, branch=%s, basket=%d, entry=%d",curdir->GetPath(),key->GetName(),branch->GetName(),i,entry);
431  } else {
432  info.Form("%s/%s, branch=%s, basket=%d, entry=%d",curdir->GetPath(),key->GetName(),branch->GetName(),i,entry);
433  }
434  return kTRUE;
435  }
436  }
437  }
438  }
439  nbytes = key->GetNbytes();
440  bseek = key->GetSeekKey();
441  if (pbyte >= bseek && pbyte < bseek+nbytes) {
442  if (curdir == (TDirectory*)fFile) {
443  info.Form("%s%s ::%s, nbytes=%d",curdir->GetPath(),key->GetName(),key->GetClassName(),nbytes);
444  } else {
445  info.Form("%s/%s ::%s, nbytes=%d",curdir->GetPath(),key->GetName(),key->GetClassName(),nbytes);
446  }
447  dirsav->cd();
448  return kTRUE;
449  }
450  }
451  // Are we in the Keys list
452  if (pbyte >= dir->GetSeekKeys() && pbyte < dir->GetSeekKeys()+dir->GetNbytesKeys()) {
453  info.Form("%sKeys List, nbytes=%d",dir->GetPath(),dir->GetNbytesKeys());
454  dirsav->cd();
455  return kTRUE;
456  }
457  if (dir == (TDirectory*)fFile) {
458  // Are we in the TStreamerInfo
459  if (pbyte >= fFile->GetSeekInfo() && pbyte < fFile->GetSeekInfo()+fFile->GetNbytesInfo()) {
460  info.Form("%sStreamerInfo List, nbytes=%d",dir->GetPath(),fFile->GetNbytesInfo());
461  dirsav->cd();
462  return kTRUE;
463  }
464  // Are we in the Free Segments
465  if (pbyte >= fFile->GetSeekFree() && pbyte < fFile->GetSeekFree()+fFile->GetNbytesFree()) {
466  info.Form("%sFree List, nbytes=%d",dir->GetPath(),fFile->GetNbytesFree());
467  dirsav->cd();
468  return kTRUE;
469  }
470  }
471  info.Form("(byte=%lld)",pbyte);
472  dirsav->cd();
473  return kFALSE;
474 }
475 
476 ////////////////////////////////////////////////////////////////////////////////
477 /// Inspect object at the mouse position.
478 
480 {
481  TObject *obj = GetObject();
482  if (obj) obj->Inspect();
483 }
484 
485 ////////////////////////////////////////////////////////////////////////////////
486 /// Paint this TFileDrawMap.
487 
489 {
490  // draw map frame
491  if (!fOption.Contains("same")) {
492  gPad->Clear();
493  //just in case axis Y has been unzoomed
494  if (fFrame->GetMaximumStored() < -1000) {
496  fFrame->SetMinimum(0);
497  fFrame->GetYaxis()->SetLimits(0,fYsize+1);
498  }
499  fFrame->Paint("a");
500  }
501 
502  //draw keys
503  PaintDir(fFile, fKeys.Data());
504 
505  fFrame->Draw("sameaxis");
506 }
507 
508 ////////////////////////////////////////////////////////////////////////////////
509 /// Paint the object at bseek with nbytes using the box object.
510 
512 {
513  Int_t iy = bseek/fXsize;
514  Int_t ix = bseek%fXsize;
515  Int_t ny = 1+(nbytes+ix)/fXsize;
517  for (Int_t j=0;j<ny;j++) {
518  if (j == 0) xmin = (Double_t)ix;
519  else xmin = 0;
520  xmax = xmin + nbytes;
521  if (xmax > fXsize) xmax = fXsize;
522  ymin = iy+j;
523  ymax = ymin+1;
524  nbytes -= (Int_t)(xmax-xmin);
525  if (xmax < gPad->GetUxmin()) continue;
526  if (xmin > gPad->GetUxmax()) continue;
527  if (xmin < gPad->GetUxmin()) xmin = gPad->GetUxmin();
528  if (xmax > gPad->GetUxmax()) xmax = gPad->GetUxmax();
529  if (ymax < gPad->GetUymin()) continue;
530  if (ymin > gPad->GetUymax()) continue;
531  if (ymin < gPad->GetUymin()) ymin = gPad->GetUymin();
532  if (ymax > gPad->GetUymax()) ymax = gPad->GetUymax();
533  //box.TAttFill::Modify();
534  box.PaintBox(xmin,ymin,xmax,ymax);
535  }
536 }
537 
538 ////////////////////////////////////////////////////////////////////////////////
539 /// Paint keys in a directory.
540 
541 void TFileDrawMap::PaintDir(TDirectory *dir, const char *keys)
542 {
543  TDirectory *dirsav = gDirectory;
544  TIter next(dir->GetListOfKeys());
545  TKey *key;
546  Int_t color = 0;
547  TBox box;
548  TRegexp re(keys,kTRUE);
549  while ((key = (TKey*)next())) {
550  Int_t nbytes = key->GetNbytes();
551  Long64_t bseek = key->GetSeekKey();
552  TClass *cl = TClass::GetClass(key->GetClassName());
553  if (cl) {
554  color = (Int_t)(cl->GetUniqueID()%20);
555  } else {
556  color = 1;
557  }
558  box.SetFillColor(color);
559  box.SetFillStyle(1001);
560  TString s = key->GetName();
561  if (strcmp(fKeys.Data(),key->GetName()) && s.Index(re) == kNPOS) continue;
562  // a TDirectory ?
563  if (cl && cl == TDirectoryFile::Class()) {
564  TDirectory *curdir = gDirectory;
565  gDirectory->cd(key->GetName());
566  TDirectory *subdir = gDirectory;
567  PaintDir(subdir,"*");
568  curdir->cd();
569  }
570  PaintBox(box,bseek,nbytes);
571  // a TTree ?
572  if (cl && cl->InheritsFrom(TTree::Class())) {
573  TTree *tree = (TTree*)gDirectory->Get(key->GetName());
574  TIter nextb(tree->GetListOfLeaves());
575  TLeaf *leaf;
576  while ((leaf = (TLeaf*)nextb())) {
577  TBranch *branch = leaf->GetBranch();
578  color = branch->GetFillColor();
579  if (color == 0) color = 1;
580  box.SetFillColor(color);
581  Int_t nbaskets = branch->GetMaxBaskets();
582  for (Int_t i=0;i<nbaskets;i++) {
583  bseek = branch->GetBasketSeek(i);
584  if (!bseek) break;
585  nbytes = branch->GetBasketBytes()[i];
586  PaintBox(box,bseek,nbytes);
587  }
588  }
589  }
590  }
591  // draw the box for Keys list
592  box.SetFillColor(50);
593  box.SetFillStyle(1001);
594  PaintBox(box,dir->GetSeekKeys(),dir->GetNbytesKeys());
595  if (dir == (TDirectory*)fFile) {
596  // draw the box for TStreamerInfo
597  box.SetFillColor(6);
598  box.SetFillStyle(3008);
600  // draw the box for Free Segments
601  box.SetFillColor(1);
602  box.SetFillStyle(1001);
604  }
605  dirsav->cd();
606 }
virtual void PaintDir(TDirectory *dir, const char *keys)
Paint keys in a directory.
virtual void DrawMarker(Int_t marker, Long64_t eseek)
Draw marker.
TString fOption
Definition: TFileDrawMap.h:38
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
virtual Double_t GetMaximumStored() const
Definition: TH1.h:284
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition: TLeaf.h:49
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition: TObject.cxx:375
virtual TObject * GetObject()
Retrieve object at the mouse position in memory.
virtual void Paint(Option_t *option="")
Control routine to paint any kind of histograms.
Definition: TH1.cxx:5808
An array of TObjects.
Definition: TObjArray.h:37
Long64_t * GetBasketEntry() const
Definition: TBranch.h:209
float xmin
Definition: THbookFile.cxx:93
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
Definition: TSystem.cxx:410
virtual Bool_t GetObjectInfoDir(TDirectory *dir, Int_t px, Int_t py, TString &info) const
Redefines TObject::GetObjectInfo.
virtual TList * GetListOfKeys() const
Definition: TDirectory.h:160
long long Long64_t
Definition: RtypesCore.h:69
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:394
virtual void SetLimits(Double_t xmin, Double_t xmax)
Definition: TAxis.h:154
TObjArray * GetListOfBaskets()
Definition: TBranch.h:238
virtual Long64_t GetSeekInfo() const
Definition: TFile.h:240
virtual void SetDirectory(TDirectory *dir)
By default when an histogram is created, it is added to the list of histogram objects in the current ...
Definition: TH1.cxx:8359
const char Option_t
Definition: RtypesCore.h:62
void GetObject(const char *namecycle, T *&ptr)
Definition: TDirectory.h:149
float ymin
Definition: THbookFile.cxx:93
Create a Box.
Definition: TBox.h:24
Long64_t GetZipBytes(Option_t *option="") const
Return total number of zip bytes in the branch if option ="*" includes all sub-branches of this branc...
Definition: TBranch.cxx:2052
const Ssiz_t kNPOS
Definition: RtypesCore.h:111
virtual ~TFileDrawMap()
Tree destructor.
#define mark(osub)
Definition: triangle.c:1206
virtual void InspectObject()
Inspect object at the mouse position.
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:140
virtual void PaintBox(TBox &box, Long64_t bseek, Int_t nbytes)
Paint the object at bseek with nbytes using the box object.
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Redefines TObject::GetObjectInfo.
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format...
Definition: TFile.h:48
TFile * fFile
Definition: TFileDrawMap.h:35
Regular expression class.
Definition: TRegexp.h:31
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:395
#define gROOT
Definition: TROOT.h:415
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:634
virtual void DrawObject()
Draw object at the mouse position.
Basic string class.
Definition: TString.h:131
virtual Int_t GetNbytesKeys() const
Definition: TDirectory.h:163
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1125
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
Definition: TObject.cxx:195
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
Compute distance from point px,py to this TreeFileMap.
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition: fillpatterns.C:1
Int_t GetEntryOffsetLen() const
Definition: TBranch.h:221
virtual TVirtualPad * cd(Int_t subpadnumber=0)=0
don&#39;t draw stats box
Definition: TH1.h:160
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:694
if object in a list can be deleted
Definition: TObject.h:58
virtual Long64_t GetSeekFree() const
Definition: TFile.h:239
TFileDrawMap()
Default TreeFileMap constructor.
Double_t x[n]
Definition: legend1.C:17
Int_t * GetBasketBytes() const
Definition: TBranch.h:208
void Class()
Definition: Class.C:29
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
Definition: TSystem.cxx:431
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
static constexpr double s
Book space in a file, create I/O buffers, to fill them, (un)compress them.
Definition: TKey.h:24
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition: TVirtualPad.h:49
virtual Long64_t GetSeekKeys() const
Definition: TDirectory.h:167
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
Definition: TObject.cxx:705
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
Compute distance from point px,py to a line.
Definition: TH1.cxx:2719
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute action corresponding to one event.
Definition: TH1.cxx:3154
float ymax
Definition: THbookFile.cxx:93
TString fKeys
Definition: TFileDrawMap.h:37
R__EXTERN TSystem * gSystem
Definition: TSystem.h:557
virtual void Draw(Option_t *option="")
Draw this histogram with options.
Definition: TH1.cxx:2981
virtual void Inspect() const
Dump contents of this object in a graphics canvas.
Definition: TObject.cxx:464
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2289
virtual void DumpObject()
Dump object at the mouse position.
Ssiz_t Length() const
Definition: TString.h:405
Int_t GetMaxBaskets() const
Definition: TBranch.h:241
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:75
TAxis * GetYaxis()
Definition: TH1.h:317
TObject * Get(const char *namecycle) override
Return pointer to object identified by namecycle.
float xmax
Definition: THbookFile.cxx:93
Bool_t InheritsFrom(const char *cl) const
Return kTRUE if this class inherits from a class with name "classname".
Definition: TClass.cxx:4753
virtual Bool_t cd(const char *path=nullptr)
Change current directory to "this" directory.
Definition: TDirectory.cxx:497
1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:614
virtual const char * GetPath() const
Returns the full path of the directory.
Definition: TDirectory.cxx:987
TString fName
Definition: TNamed.h:32
virtual void AnimateTree(const char *branches="")
Show sequence of baskets reads for the list of baskets involved in the list of branches (separated by...
virtual void Paint(Option_t *option)
Paint this TFileDrawMap.
#define gVirtualX
Definition: TVirtualX.h:345
virtual Long64_t GetBasketSeek(Int_t basket) const
Return address of basket in the file.
Definition: TBranch.cxx:1279
const Bool_t kFALSE
Definition: RtypesCore.h:88
TString & Remove(Ssiz_t pos)
Definition: TString.h:668
virtual Int_t GetNbytesFree() const
Definition: TFile.h:236
int Ssiz_t
Definition: RtypesCore.h:63
#define d(i)
Definition: RSha256.hxx:102
virtual Int_t GetNbytesInfo() const
Definition: TFile.h:235
#define ClassImp(name)
Definition: Rtypes.h:365
double Double_t
Definition: RtypesCore.h:55
Describe directory structure in memory.
Definition: TDirectory.h:34
virtual void Dump() const
Dump contents of object on stdout.
Definition: TObject.cxx:266
int nentries
Definition: THbookFile.cxx:89
Double_t y[n]
Definition: legend1.C:17
virtual Color_t GetFillColor() const
Return the fill area color.
Definition: TAttFill.h:30
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:619
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:2906
R__EXTERN C unsigned int sleep(unsigned int seconds)
Mother of all ROOT objects.
Definition: TObject.h:37
virtual Long64_t GetEND() const
Definition: TFile.h:218
Definition: file.py:1
Int_t GetEntries() const
Return the number of objects in array (i.e.
Definition: TObjArray.cxx:522
#define gPad
Definition: TVirtualPad.h:286
Definition: tree.py:1
void Add(TObject *obj)
Definition: TObjArray.h:74
A TTree represents a columnar dataset.
Definition: TTree.h:72
#define gDirectory
Definition: TDirectory.h:223
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
A TTree is a list of TBranches.
Definition: TBranch.h:90
This class is automatically called by TFile::DrawMap.
Definition: TFileDrawMap.h:32
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
const Bool_t kTRUE
Definition: RtypesCore.h:87
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute action corresponding to one event.
Long64_t BinarySearch(Long64_t n, const T *array, T value)
Definition: TMathBase.h:278
TAxis * GetXaxis()
Get the behaviour adopted by the object about the statoverflows. See EStatOverflows for more informat...
Definition: TH1.h:316
const char * Data() const
Definition: TString.h:364