Logo ROOT   6.19/01
Reference Guide
THbookFile.cxx
Go to the documentation of this file.
1 // @(#)root/hbook:$Id$
2 // Author: Rene Brun 18/02/2002
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2002, 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 THbookFile
13  \ingroup Hist
14  This class is an interface to the Hbook objects in Hbook files.
15  Any Hbook object (1-D, 2-D, Profile, RWN or CWN can be read
16 
17  NB: a THbookFile can only be used in READ mode
18  Use the utility in $ROOTSYS/bin/h2root to convert Hbook to Root
19 
20  Example of use:
21 
22  gSystem->Load("libHbook");
23  THbookFile f("myfile.hbook");
24  f.ls();
25  TH1F *h1 = (TH1F*)f.Get(1); //import histogram ID=1 in h1
26  h1->Fit("gaus");
27  THbookTree *T = (THbookTree*)f.Get(111); //import ntuple header
28  T->Print(); //show the Hbook ntuple variables
29  T->Draw("x","y<0"); // as in normal TTree::Draw
30 
31  THbookFile can be browsed via TBrowser.
32 */
33 
34 #include <stdlib.h>
35 #include <string.h>
36 #include <ctype.h>
37 
38 #include "TROOT.h"
39 #include "THbookFile.h"
40 #include "TH2.h"
41 #include "THbookTree.h"
42 #include "THbookBranch.h"
43 #include "THbookKey.h"
44 #include "TGraph.h"
45 #include "TProfile.h"
46 #include "TTreeFormula.h"
47 #include "TLeafI.h"
48 #include "TBrowser.h"
49 #include "TSystem.h"
50 #include "TMath.h"
51 
52 // NOTE: THe following comments and declarations are a duplicate
53 // of those in main/src/h2root.cxx
54 
55 // Note that with gcc3.4 or above the size of PAWC_SIZE must be the same
56 // as in the Fortran definition in hbook.f and zebra
57 // Also, the arrays must be declared extern like on Windows
58 #define PAWC_SIZE 4000000
59 
60 // Define the names of the Fortran common blocks for the different OSs
61 
62 #ifndef WIN32
63 # define pawc pawc_
64 # define quest quest_
65 # define hcbits hcbits_
66 # define hcbook hcbook_
67 # define rzcl rzcl_
68 extern "C" int pawc[PAWC_SIZE];
69 extern "C" int quest[100];
70 extern "C" int hcbits[37];
71 extern "C" int hcbook[51];
72 extern "C" int rzcl[11];
73 #else
74 # define pawc PAWC
75 # define quest QUEST
76 # define hcbits HCBITS
77 # define hcbook HCBOOK
78 # define rzcl RZCL
79 extern "C" int pawc[PAWC_SIZE];
80 extern "C" int quest[100];
81 extern "C" int hcbits[37];
82 extern "C" int hcbook[51];
83 extern "C" int rzcl[11];
84 #endif
85 
86 int *iq, *lq;
87 float *q;
88 char idname[128];
90 char chtitl[128];
91 int ncx,ncy,nwt,idb;
94 const Int_t kNRH = 6;
95 const Int_t kMIN1 = 7;
96 const Int_t kMAX1 = 8;
97 
98 static Int_t gLastEntry = -1;
99 
100 // Define the names of the Fortran subroutine and functions for the different OSs
101 
102 #ifndef WIN32
103 # define hlimit hlimit_
104 # define hldir hldir_
105 # define hropen hropen_
106 # define hrend hrend_
107 # define hrin hrin_
108 # define hnoent hnoent_
109 # define hgive hgive_
110 # define hgiven hgiven_
111 # define hgnpar hgnpar_
112 # define hgnf hgnf_
113 # define hgnt hgnt_
114 # define hgntf hgntf_
115 # define hgnt1 hgnt1_
116 # define rzink rzink_
117 # define hdcofl hdcofl_
118 # define hmaxim hmaxim_
119 # define hminim hminim_
120 # define hdelet hdelet_
121 # define hntvar2 hntvar2_
122 # define hntvar3 hntvar3_
123 # define hbname hbname_
124 # define hbnamc hbnamc_
125 # define hbnam hbnam_
126 # define hi hi_
127 # define hie hie_
128 # define hif hif_
129 # define hij hij_
130 # define hix hix_
131 # define hijxy hijxy_
132 # define hije hije_
133 # define hcdir hcdir_
134 
135 # define type_of_call
136 # define DEFCHAR const char*
137 # define PASSCHAR(string) string
138 #else
139 # define hlimit HLIMIT
140 # define hldir HLDIR
141 # define hropen HROPEN
142 # define hrend HREND
143 # define hrin HRIN
144 # define hnoent HNOENT
145 # define hgive HGIVE
146 # define hgiven HGIVEN
147 # define hgnpar HGNPAR
148 # define hgnf HGNF
149 # define hgnt HGNT
150 # define hgntf HGNTF
151 # define hgnt1 HGNT1
152 # define rzink RZINK
153 # define hdcofl HDCOFL
154 # define hmaxim HMAXIM
155 # define hminim HMINIM
156 # define hdelet HDELET
157 # define hntvar2 HNTVAR2
158 # define hntvar3 HNTVAR3
159 # define hbname HBNAME
160 # define hbnamc HBNAMC
161 # define hbnam HBNAM
162 # define hi HI
163 # define hie HIE
164 # define hif HIF
165 # define hij HIJ
166 # define hix HIX
167 # define hijxy HIJXY
168 # define hije HIJE
169 # define hcdir HCDIR
170 # define type_of_call _stdcall
171 # define DEFCHAR const char*, const int
172 # define PASSCHAR(string) string, strlen(string)
173 #endif
174 
175 extern "C" void type_of_call hlimit(const int&);
176 #ifndef WIN32
177 extern "C" void type_of_call hropen(const int&,DEFCHAR,DEFCHAR,DEFCHAR,
178  const int&,const int&,const int,const int,const int);
179 extern "C" void type_of_call hrend(DEFCHAR,const int);
180 #else
181 extern "C" void type_of_call hropen(const int&,DEFCHAR,DEFCHAR,DEFCHAR,
182  const int&,const int&);
183 extern "C" void type_of_call hrend(DEFCHAR);
184 #endif
185 
186 extern "C" void type_of_call hrin(const int&,const int&,const int&);
187 extern "C" void type_of_call hnoent(const int&,const int&);
188 #ifndef WIN32
189 extern "C" void type_of_call hgive(const int&,DEFCHAR,const int&,const float&,const float&,
190  const int&,const float&,const float&,const int&,const int&,const int);
191 #else
192 extern "C" void type_of_call hgive(const int&,DEFCHAR,const int&,const float&,const float&,
193  const int&,const float&,const float&,const int&,const int&);
194 #endif
195 
196  //SUBROUTINE HGNT1(IDD,BLKNA1,VAR,IOFFST,NVAR,IDNEVT,IERROR)
197 #ifndef WIN32
198 extern "C" void type_of_call hgiven(const int&,DEFCHAR,const int&,DEFCHAR,
199  const float&,const float&,const int,const int);
200 extern "C" void type_of_call hgnt1(const int&,DEFCHAR,DEFCHAR,const int&,const int&,const int&,const int&,const int,const int);
201 #else
202 extern "C" void type_of_call hgiven(const int&,DEFCHAR,const int&,DEFCHAR,
203  const float&,const float&);
204 extern "C" void type_of_call hgnt1(const int&,DEFCHAR,DEFCHAR,const int&,const int&,const int&,const int&);
205 #endif
206 
207 #ifndef WIN32
208 extern "C" void type_of_call hntvar2(const int&,const int&,DEFCHAR,DEFCHAR,DEFCHAR,int&,int&,int&,int&,int&,const int,const int, const int);
209 extern "C" void type_of_call hntvar3(const int&,const int&,DEFCHAR, const int);
210 #else
211 extern "C" void type_of_call hntvar2(const int&,const int&,DEFCHAR,DEFCHAR,DEFCHAR,int&,int&,int&,int&,int&);
212 extern "C" void type_of_call hntvar3(const int&,const int&,DEFCHAR);
213 #endif
214 
215 #ifndef WIN32
216 extern "C" void type_of_call hbnam(const int&,DEFCHAR,const int&,DEFCHAR,const int&,const int, const int);
217 #else
218 extern "C" void type_of_call hbnam(const int&,DEFCHAR,const int&,DEFCHAR,const int&);
219 #endif
220 
221 extern "C" void type_of_call hgnpar(const int&,const char *,const int);
222 extern "C" void type_of_call hgnf(const int&,const int&,const float&,const int&);
223 extern "C" void type_of_call hgnt(const int&,const int&,const int&);
224 extern "C" void type_of_call hgntf(const int&,const int&,const int&);
225 extern "C" void type_of_call rzink(const int&,const int&,const char *,const int);
226 extern "C" void type_of_call hdcofl();
227 extern "C" void type_of_call hmaxim(const int&,const float&);
228 extern "C" void type_of_call hminim(const int&,const float&);
229 extern "C" void type_of_call hdelet(const int&);
230 extern "C" float type_of_call hi(const int&,const int&);
231 extern "C" float type_of_call hie(const int&,const int&);
232 extern "C" float type_of_call hif(const int&,const int&);
233 extern "C" float type_of_call hij(const int&,const int&,const int&);
234 extern "C" void type_of_call hix(const int&,const int&,const float&);
235 extern "C" void type_of_call hijxy(const int&,const int&,const int&,const float&,const float&);
236 extern "C" float type_of_call hije(const int&,const int&,const int&);
237 #ifndef WIN32
238 extern "C" void type_of_call hcdir(DEFCHAR,DEFCHAR ,const int,const int);
239 extern "C" void type_of_call hldir(DEFCHAR,DEFCHAR ,const int,const int);
240 #else
241 extern "C" void type_of_call hcdir(DEFCHAR,DEFCHAR);
242 extern "C" void type_of_call hldir(DEFCHAR,DEFCHAR);
243 #endif
244 
247 
249 
250 ////////////////////////////////////////////////////////////////////////////////
251 ///the constructor
252 
253 THbookFile::THbookFile() : TNamed(),fLun(0),fLrecl(0)
254 {
255  fList = new TList();
256  fKeys = new TList();
257 }
258 
259 ////////////////////////////////////////////////////////////////////////////////
260 /// Constructor for an HBook file object
261 
262 THbookFile::THbookFile(const char *fname, Int_t lrecl)
263  :TNamed(fname,"")
264 {
265  // Initialize the Hbook/Zebra store
266  Int_t i;
267  if (!fgPawInit) {
268  fgPawInit = kTRUE;
269  lq = &pawc[9];
270  iq = &pawc[17];
271  void *qq = iq;
272  q = (float*)qq;
273  int pawc_size = PAWC_SIZE;
274  hlimit(pawc_size);
275  fgLuns = new Int_t[10];
276  for (i=0;i<10;i++) fgLuns[i] = 0;
277  }
278 
279  //find a free logical unit (max 10)
280  fLun = 0;
281  for (i=0;i<10;i++) {
282  if (fgLuns[i] == 0) {
283  fLun = 10+i;
284  fgLuns[i] = 1;
285  break;
286  }
287  }
288  if (fLun == 0) {
289  Error("THbookFile","Too many HbookFiles\n");
290  return;
291  }
292  char topdir[20];
293  snprintf(topdir,19,"lun%d",fLun);
294 
295  Int_t ier = 0;
296 #ifndef WIN32
297  hropen(fLun,PASSCHAR(topdir),PASSCHAR(fname),PASSCHAR("p"),lrecl,ier,strlen(topdir),strlen(fname),1);
298 #else
299  hropen(fLun,PASSCHAR(topdir),PASSCHAR(fname),PASSCHAR("p"),lrecl,ier);
300 #endif
301  fLrecl = lrecl;
302  SetTitle(topdir);
303  snprintf(topdir,19,"//lun%d",fLun);
304  fCurDir = topdir;
305 
306  if (ier) printf (" Error on hropen was %d \n", ier);
307  if (quest[0]) {
308  printf("Error cannot open input file: %s\n",fname);
309  }
310  if (ier || quest[0]) {
311  fgLuns[fLun-10]=0;
312  fLun = 0;
313  fList = 0;
314  fKeys = 0;
315  MakeZombie();
316  return;
317  }
318 
319  gROOT->GetListOfBrowsables()->Add(this,fname);
320 
321  fList = new TList();
322  fKeys = new TList();
323  for (Int_t key=1;key<1000000;key++) {
324  int z0 = 0;
325  rzink(key,z0,"S",1);
326  if (quest[0]) break;
327  if (quest[13] & 8) continue;
328  Int_t id = quest[20];
329  THbookKey *akey = new THbookKey(id,this);
330  fKeys->Add(akey);
331  }
332 }
333 
334 ////////////////////////////////////////////////////////////////////////////////
335 ///destructor
336 
338 {
339  if (!fList) return;
340  Close();
341  delete fList;
342  delete fKeys;
343 }
344 
345 ////////////////////////////////////////////////////////////////////////////////
346 /// to be implemented
347 
349 {
350  if( b ) {
351  b->Add(fList, "memory");
352  b->Add(fKeys, "IDs on disk");
353  }
354  cd();
355 }
356 
357 ////////////////////////////////////////////////////////////////////////////////
358 /// change directory to dirname
359 
360 Bool_t THbookFile::cd(const char *dirname)
361 {
362  Int_t nch = strlen(dirname);
363  if (nch == 0) {
364 #ifndef WIN32
366 #else
368 #endif
369  return kTRUE;
370  }
371 
372  char cdir[512];
373  Int_t i;
374  for (i=0;i<512;i++) cdir[i] = ' ';
375  cdir[511] = 0;
376 #ifndef WIN32
377  hcdir(PASSCHAR(dirname),PASSCHAR(" "),nch,1);
378  hcdir(PASSCHAR(cdir),PASSCHAR("R"),511,1);
379 #else
380  hcdir(PASSCHAR(dirname),PASSCHAR(" "));
381  hcdir(PASSCHAR(cdir),PASSCHAR("R"));
382 #endif
383  for (i=510;i>=0;i--) {
384  if (cdir[i] != ' ') break;
385  cdir[i] = 0;
386  }
387  fCurDir = cdir;
388  printf("fCurdir=%s\n",fCurDir.Data());
389 
390  return kTRUE;
391 }
392 
393 ////////////////////////////////////////////////////////////////////////////////
394 /// Close the Hbook file
395 
397 {
398  if(!IsOpen()) return;
399  if (!fList) return;
400 
401  gROOT->GetListOfBrowsables()->Remove(this);
402 
403  cd();
404 
405  fList->Delete();
406  fKeys->Delete();
407  if (fgLuns) fgLuns[fLun-10] = 0;
408  hdelet(0);
409 #ifndef WIN32
410  hrend(PASSCHAR(GetTitle()),strlen(GetTitle()));
411 #else
412  hrend(PASSCHAR(GetTitle()));
413 #endif
414 }
415 
416 ////////////////////////////////////////////////////////////////////////////////
417 ///remove id from file and memory
418 
420 {
421  hdelet(id);
422 }
423 
424 ////////////////////////////////////////////////////////////////////////////////
425 /// return object with name in fList in memory
426 
428 {
429  return fList->FindObject(name);
430 }
431 
432 ////////////////////////////////////////////////////////////////////////////////
433 /// return object with pointer obj in fList in memory
434 
436 {
437  return fList->FindObject(obj);
438 }
439 
440 ////////////////////////////////////////////////////////////////////////////////
441 /// import Hbook object with identifier idd in memory
442 
444 {
445  Int_t id = 0;
446  for (Int_t key=1;key<1000000;key++) {
447  int z0 = 0;
448  rzink(key,z0,"S",1);
449  if (quest[0]) break;
450  if (quest[13] & 8) continue;
451  id = quest[20];
452  if (id == idd) break;
453  }
454  if (id == 0) return 0;
455  if (id != idd) {
456  printf("Error cannot find ID = %d\n",idd);
457  return 0;
458  }
459 
460  int i999 = 999;
461  // must delete any previous object with the same ID !!
462  lcdir = hcbook[6];
463  ltab = hcbook[9];
464  for (Int_t i=1;i<=iq[lcdir+kNRH];i++) {
465  if (iq[ltab+i] == id) {
466  printf("WARNING, previous ID=%d is replaced\n",id);
467  hdelet(id);
468  break;
469  }
470  }
471  hrin(id,i999,0);
472  if (quest[0]) {
473  printf("Error cannot read ID = %d\n",id);
474  return 0;
475  }
476  hdcofl();
477  lcid = hcbook[10];
478  lcont = lq[lcid-1];
479  TObject *obj = 0;
480  if (hcbits[3]) {
481  if (iq[lcid-2] == 2) obj = ConvertRWN(id);
482  else obj = ConvertCWN(id);
483  //hdelet(id); //cannot be deleted here since used in GetEntry
484  if (obj) {
485  fList->Add(obj);
486  ((THbookTree *)obj)->SetTitle(GetName());
487  }
488  return obj;
489  }
490  if (hcbits[0] && hcbits[7]) {
491  obj = ConvertProfile(id);
492  hdelet(id);
493  if (obj) fList->Add(obj);
494  return obj;
495  }
496  if (hcbits[0]) {
497  obj = Convert1D(id);
498  hdelet(id);
499  if (obj) fList->Add(obj);
500  return obj;
501  }
502  if (hcbits[1] || hcbits[2]) {
503  obj = Convert2D(id);
504  hdelet(id);
505  if (obj) fList->Add(obj);
506  return obj;
507  }
508  return obj;
509 }
510 
511 
512 ////////////////////////////////////////////////////////////////////////////////
513 /// Read in memory all columns of entry number of ntuple id from the Hbook file
514 
516 {
517  Int_t ier = 0;
518  if (atype == 0) {
519  hgnf(id,entry+1,x[0],ier);
520  } else {
521  hgnt(id,entry+1,ier);
522  }
523  return 0;
524 }
525 
526 ////////////////////////////////////////////////////////////////////////////////
527 /// Read in memory only the branch bname
528 
530 {
531  if (entry == gLastEntry) return 0;
532  gLastEntry = entry;
533  Int_t ier = 0;
534  //uses the fast read method using the Hbook tables computed in InitLeaves
535  hgntf(id,entry+1,ier);
536  //old alternative slow method
537 //#ifndef WIN32
538 // hgnt1(id,PASSCHAR(blockname),PASSCHAR(branchname),0,-1,entry+1,ier,strlen(blockname),strlen(branchname));
539 //#else
540 // hgnt1(id,PASSCHAR(blockname),PASSCHAR(branchname),0,-1,entry+1,ier);
541 //#endif
542  return 0;
543 }
544 
545 
546 ////////////////////////////////////////////////////////////////////////////////
547 /// This function is called from the first entry in TTreePlayer::InitLoop
548 /// It analyzes the list of variables involved in the current query
549 /// and pre-process the internal Hbook tables to speed-up the search
550 /// at the next entries.
551 
553 {
554  if (!formula) return;
555  Int_t ncodes = formula->GetNcodes();
556  for (Int_t i=1;i<=ncodes;i++) {
557  TLeaf *leaf = formula->GetLeaf(i-1);
558  if (!leaf) continue;
559  if (var == 5) {
560  //leafcount may be null in case of a fix size array
561  if (leaf->GetLeafCount()) leaf = leaf->GetLeafCount();
562  }
563  Int_t last = 0;
564  if (var == 1 && i == ncodes) last = 1;
565 #ifndef WIN32
566  hntvar3(id,last,PASSCHAR(leaf->GetName()),strlen(leaf->GetName()));
567 #else
568  hntvar3(id,last,PASSCHAR(leaf->GetName()));
569 #endif
570  }
571 }
572 
573 ////////////////////////////////////////////////////////////////////////////////
574 /// Returns kTRUE in case file is open and kFALSE if file is not open.
575 
577 {
578  return fLun == 0 ? kFALSE : kTRUE;
579 }
580 
581 
582 ////////////////////////////////////////////////////////////////////////////////
583 ///Set branch address
584 
585 void THbookFile::SetBranchAddress(Int_t id, const char *bname, void *add)
586 {
587  Int_t *iadd = (Int_t*)add;
588  Int_t &aadd = *iadd;
589 #ifndef WIN32
590  hbnam(id,PASSCHAR(bname),aadd,PASSCHAR("$SET"),0,strlen(bname),4);
591 #else
592  hbnam(id,PASSCHAR(bname),aadd,PASSCHAR("$SET"),0);
593 #endif
594 }
595 
596 ////////////////////////////////////////////////////////////////////////////////
597 /// Convert this Hbook file to a Root file with name rootname.
598 /// if rootname="', rootname = hbook file name with .root instead of .hbook
599 /// By default, the Root file is connected and returned
600 /// option:
601 /// - "NO" do not connect the Root file
602 /// - "C" do not compress file (default is to compress)
603 /// - "L" do not convert names to lower case (default is to convert)
604 
605 TFile *THbookFile::Convert2root(const char *rootname, Int_t /*lrecl*/,
606  Option_t *option)
607 {
608  TString opt = option;
609  opt.ToLower();
610 
611  Int_t nch = strlen(rootname);
612  char *rfile=0;
613  if (nch) {
614  rfile = new char[nch+1];
615  strlcpy(rfile,rootname,nch+1);
616  } else {
617  nch = strlen(GetName());
618  rfile = new char[nch+1];
619  strlcpy(rfile,GetName(),nch+1);
620  char *dot = strrchr(rfile,'.');
621  if (dot) strcpy(dot+1,"root");
622  else strlcat(rfile,".root",nch+1);
623  }
624 
625  nch = 2*nch+50;
626  char *cmd = new char[nch+1];
627  snprintf(cmd,nch,"h2root %s %s",GetName(),rfile);
628  if (opt.Contains("c")) strlcat (cmd," 0",nch+1);
629  if (opt.Contains("l")) strlcat (cmd," 0",nch+1);
630 
631  gSystem->Exec(cmd);
632 
633  delete [] cmd;
634  if (opt.Contains("no")) {delete [] rfile; return 0;}
635  TFile *f = new TFile(rfile);
636  delete [] rfile;
637  if (f->IsZombie()) {delete f; f = 0;}
638  return f;
639 }
640 
641 
642 ////////////////////////////////////////////////////////////////////////////////
643 /// Convert the Column-Wise-Ntuple id to a Root Tree
644 
646 {
647  const int nchar=9;
648  int nvar;
649  int i,j;
650  int nsub,itype,isize,ielem;
651  char *chtag_out;
652  float rmin[1000], rmax[1000];
653 
654  if (id > 0) snprintf(idname,127,"h%d",id);
655  else snprintf(idname,127,"h_%d",-id);
656  hnoent(id,nentries);
657  //printf(" Converting CWN with ID= %d, nentries = %d\n",id,nentries);
658  nvar=0;
659 #ifndef WIN32
660  hgiven(id,chtitl,nvar,PASSCHAR(""),rmin[0],rmax[0],80,0);
661 #else
662  hgiven(id,chtitl,80,nvar,PASSCHAR(""),rmin[0],rmax[0]);
663 #endif
664  chtag_out = new char[nvar*nchar+1];
665  Int_t *charflag = new Int_t[nvar];
666  Int_t *lenchar = new Int_t[nvar];
667  Int_t *boolflag = new Int_t[nvar];
668  Int_t *lenbool = new Int_t[nvar];
669  UChar_t *boolarr = new UChar_t[10000];
670 
671  chtag_out[nvar*nchar]=0;
672  for (i=0;i<80;i++)chtitl[i]=0;
673 #ifndef WIN32
674  hgiven(id,chtitl,nvar,chtag_out,rmin[0],rmax[0],80,nchar);
675 #else
676  hgiven(id,chtitl,80,nvar,chtag_out,nchar,rmin[0],rmax[0]);
677 #endif
678 
679  Int_t bufpos = 0;
680  Int_t isachar = 0;
681  Int_t isabool = 0;
682  char fullname[64];
683  char name[32];
684  char block[32];
685  char oldblock[32];
686  strlcpy(oldblock,"OLDBLOCK",32);
687  Int_t oldischar = -1;
688  for (i=80;i>0;i--) {if (chtitl[i] == ' ') chtitl[i] = 0; }
689  THbookTree *tree = new THbookTree(idname,id);
690  tree->SetHbookFile(this);
691  tree->SetType(1);
692 
693  char *bigbuf = tree->MakeX(500000);
694 
695 #ifndef WIN32
696  hbnam(id,PASSCHAR(" "),bigbuf[0],PASSCHAR("$CLEAR"),0,1,6);
697 #else
698  hbnam(id,PASSCHAR(" "),bigbuf[0],PASSCHAR("$CLEAR"),0);
699 #endif
700 
701  UInt_t varNumber = 0;
702  Int_t golower = 1;
703  Int_t nbits = 0;
704  for(i=0; i<nvar;i++) {
705  memset(name,' ',sizeof(name));
706  name[sizeof(name)-1] = 0;
707  memset(block,' ',sizeof(block));
708  block[sizeof(block)-1] = 0;
709  memset(fullname,' ',sizeof(fullname));
710  fullname[sizeof(fullname)-1]=0;
711 #ifndef WIN32
712  hntvar2(id,i+1,PASSCHAR(name),PASSCHAR(fullname),PASSCHAR(block),nsub,itype,isize,nbits,ielem,32,64,32);
713 #else
714  hntvar2(id,i+1,PASSCHAR(name),PASSCHAR(fullname),PASSCHAR(block),nsub,itype,isize,nbits,ielem);
715 #endif
716  TString hbookName = name;
717 
718  for (j=30;j>0;j--) {
719  if(golower) name[j] = tolower(name[j]);
720  if (name[j] == ' ') name[j] = 0;
721  }
722  if (golower == 2) name[0] = tolower(name[0]);
723 
724  for (j=62;j>0;j--) {
725  if(golower && fullname[j-1] != '[') fullname[j] = tolower(fullname[j]);
726  // convert also character after [, if golower == 2
727  if (golower == 2) fullname[j] = tolower(fullname[j]);
728  if (fullname[j] == ' ') fullname[j] = 0;
729  }
730  // convert also first character, if golower == 2
731  if (golower == 2) fullname[0] = tolower(fullname[0]);
732  for (j=30;j>0;j--) {
733  if (block[j] == ' ') block[j] = 0;
734  else break;
735  }
736  if (itype == 1 && isize == 4) strlcat(fullname,"/F",64);
737  if (itype == 1 && isize == 8) strlcat(fullname,"/D",64);
738  if (itype == 2) strlcat(fullname,"/I",64);
739  if (itype == 3) strlcat(fullname,"/i",64);
740 // if (itype == 4) strlcat(fullname,"/i",64);
741  if (itype == 4) strlcat(fullname,"/b",64);
742  if (itype == 5) strlcat(fullname,"/C",64);
743 //printf("Creating branch:%s, block:%s, fullname:%s, nsub=%d, itype=%d, isize=%d, ielem=%d, bufpos=%d\n",name,block,fullname,nsub,itype,isize,ielem,bufpos);
744  Int_t ischar;
745  if (itype == 5) ischar = 1;
746  else ischar = 0;
747 
748  if (ischar != oldischar || strcmp(oldblock,block) != 0) {
749  varNumber = 0;
750  strlcpy(oldblock,block,32);
751  oldischar = ischar;
752  Long_t add= (Long_t)&bigbuf[bufpos];
753  Int_t lblock = strlen(block);
754 #ifndef WIN32
755  hbnam(id,PASSCHAR(block),add,PASSCHAR("$SET"),ischar,lblock,4);
756 #else
757  hbnam(id,PASSCHAR(block),add,PASSCHAR("$SET"),ischar);
758 #endif
759 
760  }
761 
762  Int_t bufsize = 8000;
763  THbookBranch *branch = new THbookBranch(tree,name,(void*)&bigbuf[bufpos],fullname,bufsize);
764  tree->GetListOfBranches()->Add(branch);
765  branch->SetBlockName(block);
766  branch->SetUniqueID(varNumber);
767  varNumber++;
768 
769  //NB: the information about isachar should be saved in the branch
770  // to be done
771  boolflag[i] = -10;
772  charflag[i] = 0;
773  if (itype == 4) {isabool++; boolflag[i] = bufpos; lenbool[i] = ielem;}
774  bufpos += isize*ielem;
775  if (ischar) {isachar++; charflag[i] = bufpos-1; lenchar[i] = isize*ielem;}
776  TObjArray *ll= branch->GetListOfLeaves();
777  TLeaf *leaf = (TLeaf*)ll->UncheckedAt(0);
778  if (!leaf) continue;
779  TLeafI *leafcount = (TLeafI*)leaf->GetLeafCount();
780  if (leafcount) {
781  if (leafcount->GetMaximum() <= 0) leafcount->SetMaximum(ielem);
782  }
783  }
784  tree->SetEntries(nentries);
785  delete [] charflag;
786  delete [] lenchar;
787  delete [] boolflag;
788  delete [] lenbool;
789  delete [] boolarr;
790  delete [] chtag_out;
791 
792  return tree;
793 }
794 
795 ////////////////////////////////////////////////////////////////////////////////
796 /// Convert the Row-Wise-Ntuple id to a Root Tree
797 
799 {
800  const int nchar=9;
801  int nvar;
802  int i,j;
803  char *chtag_out;
804  float rmin[1000], rmax[1000];
805 
806  if (id > 0) snprintf(idname,127,"h%d",id);
807  else snprintf(idname,127,"h_%d",-id);
808  hnoent(id,nentries);
809  //printf(" Converting RWN with ID= %d, nentries = %d\n",id,nentries);
810  nvar=0;
811 #ifndef WIN32
812  hgiven(id,chtitl,nvar,PASSCHAR(""),rmin[0],rmax[0],80,0);
813 #else
814  hgiven(id,chtitl,80,nvar,PASSCHAR(""),rmin[0],rmax[0]);
815 #endif
816 
817  chtag_out = new char[nvar*nchar+1];
818 
819  Int_t golower = 1;
820  chtag_out[nvar*nchar]=0;
821  for (i=0;i<80;i++)chtitl[i]=0;
822 #ifndef WIN32
823  hgiven(id,chtitl,nvar,chtag_out,rmin[0],rmax[0],80,nchar);
824 #else
825  hgiven(id,chtitl,80,nvar,chtag_out,nchar,rmin[0],rmax[0]);
826 #endif
827  hgnpar(id,"?",1);
828  char *name = chtag_out;
829  for (i=80;i>0;i--) {if (chtitl[i] == ' ') chtitl[i] = 0; }
830  THbookTree *tree = new THbookTree(idname,id);
831  tree->SetHbookFile(this);
832  tree->SetType(0);
833  Float_t *x = (Float_t*)tree->MakeX(nvar*4);
834 
835  Int_t first,last;
836  for(i=0; i<nvar;i++) {
837  name[nchar-1] = 0;
838  first = last = 0;
839  TString hbookName = name;
840  // suppress trailing blanks
841  for (j=nchar-2;j>0;j--) {
842  if(golower) name[j] = tolower(name[j]);
843  if (name[j] == ' ' && last == 0) name[j] = 0;
844  else last = j;
845  }
846  if (golower == 2) name[0] = tolower(name[0]);
847 
848  // suppress heading blanks
849  for (j=0;j<nchar;j++) {
850  if (name[j] != ' ') break;
851  first = j+1;
852  }
853  Int_t bufsize = 8000;
854  //tree->Branch(&name[first],&x[i],&name[first],bufsize);
855  THbookBranch *branch = new THbookBranch(tree,&name[first],&x[4*i],&name[first],bufsize);
856  branch->SetAddress(&x[i]);
857  branch->SetBlockName(hbookName.Data());
858  tree->GetListOfBranches()->Add(branch);
859  name += nchar;
860  }
861  tree->SetEntries(nentries);
862  delete [] chtag_out;
863 
864  return tree;
865 }
866 
867 ////////////////////////////////////////////////////////////////////////////////
868 /// Convert an Hbook profile histogram into a Root TProfile
869 ///
870 /// the following structure is used in Hbook
871 /// lcid points to the profile in array iq
872 /// lcont = lq(lcid-1)
873 /// lw = lq(lcont)
874 /// ln = lq(lw)
875 /// if option S jbyt(iq(lw),1,2) = 1
876 /// if option I jbyt(iq(lw),1,2) = 2
877 
879 {
880  if (id > 0) snprintf(idname,127,"h%d",id);
881  else snprintf(idname,127,"h_%d",-id);
882  hnoent(id,nentries);
883  Int_t lw = lq[lcont];
884  Int_t ln = lq[lw];
885 #ifndef WIN32
887 #else
889 #endif
890  Float_t offsetx = 0.5*(xmax-xmin)/ncx;
891  chtitl[4*nwt] = 0;
892  const char *option= " ";
893  if (iq[lw] == 1) option = "S";
894  if (iq[lw] == 2) option = "I";
895  TProfile *p = new TProfile(idname,chtitl,ncx,xmin,xmax,ymin,ymax,option);
896 
897  const Int_t kCON1 = 9;
898  Int_t i;
899  Float_t x = 0.0;
900  Float_t y = 0.5*(ymin+ymax);
901  for (i=1;i<=ncx;i++) {
902  Int_t n = Int_t(q[ln+i]);
903  hix(id,i,x);
904  for (Int_t j=0;j<n;j++) {
905  p->Fill(x+offsetx,y);
906  }
907  Float_t content = q[lcont+kCON1+i];
908  Float_t error = TMath::Sqrt(q[lw+i]);
909  p->SetBinContent(i,content);
910  p->SetBinError(i,error);
911  }
912  p->SetEntries(nentries);
913  return p;
914 }
915 
916 ////////////////////////////////////////////////////////////////////////////////
917 /// Convert an Hbook 1-d histogram into a Root TH1F
918 
920 {
921  if (id > 0) snprintf(idname,127,"h%d",id);
922  else snprintf(idname,127,"h_%d",-id);
923  hnoent(id,nentries);
924 #ifndef WIN32
926 #else
928 #endif
929  chtitl[4*nwt] = 0;
930  TH1F *h1;
931  Int_t i;
932  if (hcbits[5]) {
933  Int_t lbins = lq[lcid-2];
934  Double_t *xbins = new Double_t[ncx+1];
935  for (i=0;i<=ncx;i++) xbins[i] = q[lbins+i+1];
936  h1 = new TH1F(idname,chtitl,ncx,xbins);
937  delete [] xbins;
938  } else {
939  h1 = new TH1F(idname,chtitl,ncx,xmin,xmax);
940  }
941  if (hcbits[8]) h1->Sumw2();
942  TGraph *gr = 0;
943  if (hcbits[11]) {
944  gr = new TGraph(ncx);
946  }
947 
948  Float_t x;
949  for (i=0;i<=ncx+1;i++) {
950  x = h1->GetBinCenter(i);
951  h1->Fill(x,hi(id,i));
952  if (hcbits[8]) h1->SetBinError(i,hie(id,i));
953  if (gr && i>0 && i<=ncx) gr->SetPoint(i,x,hif(id,i));
954  }
955  Float_t yymin, yymax;
956  if (hcbits[19]) {
957  yymax = q[lcid+kMAX1];
958  h1->SetMaximum(yymax);
959  }
960  if (hcbits[20]) {
961  yymin = q[lcid+kMIN1];
962  h1->SetMinimum(yymin);
963  }
965  return h1;
966 }
967 
968 ////////////////////////////////////////////////////////////////////////////////
969 /// Convert an Hbook 2-d histogram into a Root TH2F
970 
972 {
973  if (id > 0) snprintf(idname,127,"h%d",id);
974  else snprintf(idname,127,"h_%d",-id);
975  hnoent(id,nentries);
976 #ifndef WIN32
978 #else
980 #endif
981  chtitl[4*nwt] = 0;
982  TH2F *h2 = new TH2F(idname,chtitl,ncx,xmin,xmax,ncy,ymin,ymax);
983  Float_t offsetx = 0.5*(xmax-xmin)/ncx;
984  Float_t offsety = 0.5*(ymax-ymin)/ncy;
985  Int_t lw = lq[lcont];
986  if (lw) h2->Sumw2();
987 
988  Float_t x = 0.0, y = 0.0;
989  for (Int_t j=0;j<=ncy+1;j++) {
990  for (Int_t i=0;i<=ncx+1;i++) {
991  hijxy(id,i,j,x,y);
992  h2->Fill(x+offsetx,y+offsety,hij(id,i,j));
993  if (lw) {
994  Double_t err2 = hije(id,i,j);
995  h2->SetBinError(i,j,err2);
996  }
997  }
998  }
999  h2->SetEntries(nentries);
1000  return h2;
1001 }
1002 
1003 ////////////////////////////////////////////////////////////////////////////////
1004 /// List contents of Hbook directory
1005 
1006 void THbookFile::ls(const char *path) const
1007 {
1008  Int_t nch = strlen(path);
1009  if (nch == 0) {
1010 #ifndef WIN32
1012 #else
1013  hldir(PASSCHAR(fCurDir.Data()),PASSCHAR("T"));
1014 #endif
1015  return;
1016  }
1017 
1018 #ifndef WIN32
1019  hldir(PASSCHAR(path),PASSCHAR("T"),strlen(path),1);
1020 #else
1021  hldir(PASSCHAR(path),PASSCHAR("T"));
1022 #endif
1023 }
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition: TLeaf.h:49
const Int_t kNRH
Definition: THbookFile.cxx:94
int ncy
Definition: THbookFile.cxx:91
virtual Int_t Fill(Double_t x)
Increment bin with abscissa X by 1.
Definition: TH1.cxx:3258
An array of TObjects.
Definition: TObjArray.h:37
float xmin
Definition: THbookFile.cxx:93
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:467
virtual Double_t GetBinCenter(Int_t bin) const
Return bin center for 1D histogram.
Definition: TH1.cxx:8562
#define hix
Definition: THbookFile.cxx:130
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:394
Int_t fLun
Definition: THbookFile.h:32
int idb
Definition: THbookFile.cxx:91
#define pawc
Definition: THbookFile.cxx:63
int nwt
Definition: THbookFile.cxx:91
#define PASSCHAR(string)
Definition: THbookFile.cxx:137
float Float_t
Definition: RtypesCore.h:53
char idname[128]
Definition: THbookFile.cxx:88
const char Option_t
Definition: RtypesCore.h:62
#define hnoent
Definition: THbookFile.cxx:108
virtual Bool_t IsOpen() const
Returns kTRUE in case file is open and kFALSE if file is not open.
Definition: THbookFile.cxx:576
float ymin
Definition: THbookFile.cxx:93
#define DEFCHAR
Definition: THbookFile.cxx:136
#define quest
Definition: THbookFile.cxx:64
int * lq
Definition: THbookFile.cxx:86
virtual TObject * ConvertProfile(Int_t id)
Convert an Hbook profile histogram into a Root TProfile.
Definition: THbookFile.cxx:878
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format...
Definition: TFile.h:48
#define hgnt1
Definition: THbookFile.cxx:115
#define rzcl
Definition: THbookFile.cxx:67
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:395
static Int_t gLastEntry
Definition: THbookFile.cxx:98
#define gROOT
Definition: TROOT.h:414
virtual TObject * ConvertRWN(Int_t id)
Convert the Row-Wise-Ntuple id to a Root Tree.
Definition: THbookFile.cxx:798
Basic string class.
Definition: TString.h:131
1-D histogram with a float per channel (see TH1 documentation)}
Definition: TH1.h:571
#define f(i)
Definition: RSha256.hxx:104
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
HBOOK Key.
Definition: THbookKey.h:26
virtual TObject * ConvertCWN(Int_t id)
Convert the Column-Wise-Ntuple id to a Root Tree.
Definition: THbookFile.cxx:645
virtual void Browse(TBrowser *b)
to be implemented
Definition: THbookFile.cxx:348
Profile Histogram.
Definition: TProfile.h:32
int lcid
Definition: THbookFile.cxx:92
TObject * Get(Int_t id)
import Hbook object with identifier idd in memory
Definition: THbookFile.cxx:443
#define hntvar3
Definition: THbookFile.cxx:122
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
Definition: TList.cxx:575
#define rzink
Definition: THbookFile.cxx:116
#define hgiven
Definition: THbookFile.cxx:110
virtual TFile * Convert2root(const char *rootname="", Int_t lrecl=0, Option_t *option="")
Convert this Hbook file to a Root file with name rootname.
Definition: THbookFile.cxx:605
Double_t x[n]
Definition: legend1.C:17
#define hij
Definition: THbookFile.cxx:129
#define hrend
Definition: THbookFile.cxx:106
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
int lcdir
Definition: THbookFile.cxx:92
const Int_t kMIN1
Definition: THbookFile.cxx:95
virtual void Close(Option_t *option="")
Close the Hbook file.
Definition: THbookFile.cxx:396
#define hbnam
Definition: THbookFile.cxx:125
Int_t fLrecl
Definition: THbookFile.h:33
Int_t GetEntry(Int_t entry, Int_t id, Int_t atype, Float_t *x)
Read in memory all columns of entry number of ntuple id from the Hbook file.
Definition: THbookFile.cxx:515
virtual ~THbookFile()
destructor
Definition: THbookFile.cxx:337
#define hcbits
Definition: THbookFile.cxx:65
#define PAWC_SIZE
Definition: THbookFile.cxx:58
const Int_t kMAX1
Definition: THbookFile.cxx:96
TH1F * h1
Definition: legend1.C:5
#define hi
Definition: THbookFile.cxx:126
virtual Int_t GetNcodes() const
Definition: TTreeFormula.h:193
virtual void SetBinError(Int_t bin, Double_t error)
Set the bin Error Note that this resets the bin eror option to be of Normal Type and for the non-empt...
Definition: TH1.cxx:8627
virtual void SetAddress(void *addobj)
Set address of this branch See important remark in the header of THbookTree.
#define hije
Definition: THbookFile.cxx:132
HBOOK Branch.
Definition: THbookBranch.h:26
Used to pass a selection expression to the Tree drawing routine.
Definition: TTreeFormula.h:58
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
Definition: TObject.cxx:705
A doubly linked list.
Definition: TList.h:44
TList * fList
Definition: THbookFile.h:34
int lcont
Definition: THbookFile.cxx:92
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
void DeleteID(Int_t id)
remove id from file and memory
Definition: THbookFile.cxx:419
float ymax
Definition: THbookFile.cxx:93
virtual TObject * FindObject(const char *name) const
return object with name in fList in memory
Definition: THbookFile.cxx:427
THbookFile()
the constructor
Definition: THbookFile.cxx:253
R__EXTERN TSystem * gSystem
Definition: TSystem.h:560
#define hie
Definition: THbookFile.cxx:127
2-D histogram with a float per channel (see TH1 documentation)}
Definition: TH2.h:251
virtual void SetBinContent(Int_t bin, Double_t content)
Set bin content see convention for numbering bins in TH1::GetBin In case the bin number is greater th...
Definition: TH1.cxx:8643
#define hntvar2
Definition: THbookFile.cxx:121
#define hgnpar
Definition: THbookFile.cxx:111
static Bool_t fgPawInit
Definition: THbookFile.h:38
unsigned int UInt_t
Definition: RtypesCore.h:42
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:880
Ssiz_t Length() const
Definition: TString.h:405
virtual TLeaf * GetLeafCount() const
If this leaf stores a variable-sized array or a multi-dimensional array whose last dimension has vari...
Definition: TLeaf.h:103
#define hmaxim
Definition: THbookFile.cxx:118
Int_t Fill(const Double_t *v)
Definition: TProfile.h:54
char chtitl[128]
Definition: THbookFile.cxx:90
#define hlimit
Definition: THbookFile.cxx:103
void SetBlockName(const char *name)
Definition: THbookBranch.h:40
virtual Int_t Exec(const char *shellcmd)
Execute a command.
Definition: TSystem.cxx:663
float xmax
Definition: THbookFile.cxx:93
#define hijxy
Definition: THbookFile.cxx:131
void InitLeaves(Int_t id, Int_t var, TTreeFormula *formula)
This function is called from the first entry in TTreePlayer::InitLoop It analyzes the list of variabl...
Definition: THbookFile.cxx:552
TGraphErrors * gr
Definition: legend1.C:25
const Bool_t kFALSE
Definition: RtypesCore.h:88
Int_t GetEntryBranch(Int_t entry, Int_t id)
Read in memory only the branch bname.
Definition: THbookFile.cxx:529
#define hminim
Definition: THbookFile.cxx:119
long Long_t
Definition: RtypesCore.h:50
virtual void SetBranchAddress(Int_t id, const char *bname, void *add)
Set branch address.
Definition: THbookFile.cxx:585
#define hif
Definition: THbookFile.cxx:128
TObject * UncheckedAt(Int_t i) const
Definition: TObjArray.h:90
#define hgntf
Definition: THbookFile.cxx:114
#define ClassImp(name)
Definition: Rtypes.h:365
virtual Int_t GetMaximum() const
Definition: TLeafI.h:44
virtual TLeaf * GetLeaf(Int_t n) const
Return leaf corresponding to serial number n.
#define hcdir
Definition: THbookFile.cxx:133
double Double_t
Definition: RtypesCore.h:55
virtual void ls(const char *path="") const
List contents of Hbook directory.
int nentries
Definition: THbookFile.cxx:89
Double_t y[n]
Definition: legend1.C:17
A wrapper class supporting Hbook ntuples (CWN and RWN).
Definition: THbookTree.h:30
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:619
TObjArray * GetListOfLeaves()
Definition: TBranch.h:240
Mother of all ROOT objects.
Definition: TObject.h:37
TList * fKeys
Definition: THbookFile.h:35
int ltab
Definition: THbookFile.cxx:92
virtual void SetMaximum(Int_t max)
Definition: TLeafI.h:57
virtual void SetPoint(Int_t i, Double_t x, Double_t y)
Set x and y values for point number i.
Definition: TGraph.cxx:2196
#define hgnt
Definition: THbookFile.cxx:113
virtual void Add(TObject *obj)
Definition: TList.h:87
virtual Bool_t cd(const char *dirname="")
change directory to dirname
Definition: THbookFile.cxx:360
#define hdelet
Definition: THbookFile.cxx:120
#define hcbook
Definition: THbookFile.cxx:66
void MakeZombie()
Definition: TObject.h:49
virtual void Sumw2(Bool_t flag=kTRUE)
Create structure to store sum of squares of weights.
Definition: TH1.cxx:8441
A Graph is a graphics object made of two arrays X and Y with npoints each.
Definition: TGraph.h:41
#define hrin
Definition: THbookFile.cxx:107
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
#define snprintf
Definition: civetweb.c:1540
#define hldir
Definition: THbookFile.cxx:104
This class is an interface to the Hbook objects in Hbook files.
Definition: THbookFile.h:29
constexpr size_t block
Definition: BatchHelpers.h:29
Definition: tree.py:1
static Int_t * fgLuns
Definition: THbookFile.h:39
virtual void SetEntries(Double_t n)
Definition: TH1.h:381
int * iq
Definition: THbookFile.cxx:86
#define type_of_call
Definition: THbookFile.cxx:135
virtual TObject * Convert1D(Int_t id)
Convert an Hbook 1-d histogram into a Root TH1F.
Definition: THbookFile.cxx:919
#define hropen
Definition: THbookFile.cxx:105
unsigned char UChar_t
Definition: RtypesCore.h:34
Definition: first.py:1
TString fCurDir
Definition: THbookFile.h:36
#define hgive
Definition: THbookFile.cxx:109
Double_t Sqrt(Double_t x)
Definition: TMath.h:681
virtual TObject * Convert2D(Int_t id)
Convert an Hbook 2-d histogram into a Root TH2F.
Definition: THbookFile.cxx:971
int ncx
Definition: THbookFile.cxx:91
Int_t Fill(Double_t)
Invalid Fill method.
Definition: TH2.cxx:292
float * q
Definition: THbookFile.cxx:87
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
TList * GetListOfFunctions() const
Definition: TH1.h:239
const Bool_t kTRUE
Definition: RtypesCore.h:87
const Int_t n
Definition: legend1.C:16
#define hdcofl
Definition: THbookFile.cxx:117
#define hgnf
Definition: THbookFile.cxx:112
char name[80]
Definition: TGX11.cxx:109
A TLeaf for an Integer data type.
Definition: TLeafI.h:27
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
const char * Data() const
Definition: TString.h:364