g4tools  5.4.0
Namespaces | Classes | Typedefs | Functions
tools::wroot Namespace Reference

Namespaces

 streamer__info
 

Classes

class  base_leaf
 
class  base_pntuple
 
class  base_pntuple_column_wise
 
class  base_pntuple_row_wise
 
class  basket
 
class  branch
 
class  branch_element
 
class  branch_object
 
class  buffer
 
class  bufobj
 
class  directory
 
class  file
 
class  free_seg
 
class  ibo
 
class  icol
 
class  idir
 
class  ifile
 
class  impi_ntuple
 
class  imt_ntuple
 
class  imutex
 
class  iobject
 
class  itree
 
class  key
 
class  leaf
 
class  leaf_element
 
class  leaf_object
 
class  leaf_ref
 
class  leaf_std_vector_ref
 
class  leaf_string
 
class  leaf_string_ref
 
class  member_writer
 
class  mpi_basket_add
 
class  mpi_ntuple_column_wise
 
class  mpi_ntuple_row_wise
 
class  mt_basket_add
 
class  mt_ntuple_column_wise
 
class  mt_ntuple_row_wise
 
class  ntuple
 
class  obj_array
 
class  obj_list
 
class  std_vector_be
 
class  std_vector_be_pointer
 
class  std_vector_be_ref
 
class  streamer_base
 
class  streamer_basic_pointer
 
class  streamer_basic_type
 
class  streamer_bool
 
class  streamer_double
 
class  streamer_element
 
class  streamer_float
 
class  streamer_info
 
class  streamer_int
 
class  streamer_object
 
class  streamer_object_any
 
class  streamer_object_pointer
 
class  streamer_short
 
class  streamer_stat_t
 
class  streamer_STL
 
class  streamer_string
 
class  streamer_uint
 
class  tree
 
class  wbuf
 

Typedefs

typedef unsigned int date
 
typedef int64 seek
 
typedef int seek32
 
typedef histo::histo_data< double, unsigned int, unsigned int, double > hd_data
 
typedef histo::histo_data< double, unsigned int, unsigned int, float > hf_data
 
typedef histo::profile_data< double, unsigned int, unsigned int, double, double > pd_data
 

Functions

const std::string & branch_element_store_class ()
 
cid base_cid ()
 
cid leaf_string_cid ()
 
cid leaf_element_cid ()
 
cid leaf_object_cid ()
 
cid base_leaf_cid ()
 
date get_date ()
 
free_seg * find_after (const std::list< free_seg * > &a_list, free_seg *a_what)
 
void remove (std::list< free_seg * > &a_list, free_seg *a_what)
 
void add_before (std::list< free_seg * > &a_list, free_seg *a_what, free_seg *a_new)
 
free_seg * add_free (std::list< free_seg * > &a_list, seek a_first, seek a_last)
 
void scs (unsigned int &a_cs, const std::string &a_s)
 
void acs (unsigned int &a_cs, int a_n, int *a_dims)
 
void fill_vec (obj_list< streamer_info > &a_infos, const std::string &a_type, streamer__info::Type a_si_type)
 
int size_VIRTUAL ()
 
int size_TObject ()
 
int size_TNamed ()
 
void fill_infos_core (obj_list< streamer_info > &a_infos, std::ostream &a_out)
 
void fill_infos_cont (obj_list< streamer_info > &a_infos, std::ostream &)
 
int size_TAttLine ()
 
int size_TAttFill ()
 
int size_TAttMarker ()
 
void fill_infos_graf (obj_list< streamer_info > &a_infos, std::ostream &a_out)
 
int size_TBranch ()
 
int size_TLeaf ()
 
int size_TTree ()
 
void fill_infos_tree (obj_list< streamer_info > &a_infos, std::ostream &a_out)
 
int size_TAttAxis ()
 
int size_TAxis ()
 
int size_TH1 ()
 
int size_TH2 ()
 
int size_TH2D ()
 
void fill_infos_histo (obj_list< streamer_info > &a_infos, std::ostream &a_out)
 
void fill_infos (obj_list< streamer_info > &a_infos, std::ostream &a_out)
 
const std::string & leaf_store_class (char)
 
const std::string & leaf_store_class (short)
 
const std::string & leaf_store_class (int)
 
const std::string & leaf_store_class (float)
 
const std::string & leaf_store_class (double)
 
const std::string & leaf_string_store_class ()
 
const std::string & leaf_element_store_class ()
 
const std::string & leaf_object_store_class ()
 
basket * mpi_create_basket (std::ostream &a_out, impi &a_mpi, bool a_byte_swap, seek a_seek_directory, uint32 a_basket_size)
 
uint32 mpi_protocol_basket ()
 
uint32 mpi_protocol_baskets ()
 
uint32 mpi_protocol_end_fill ()
 
bool mpi_pack_basket (impi &a_mpi, uint32 a_icol, const basket &a_basket)
 
bool mpi_send_basket (impi &a_mpi, int a_dest, int a_tag, uint32 a_id, uint32 a_icol, const basket &a_basket)
 
bool Object_stream (buffer &a_buffer)
 
bool Named_stream (buffer &a_buffer, const std::string &a_name, const std::string &a_title)
 
bool AttLine_stream (buffer &a_buffer)
 
bool AttFill_stream (buffer &a_buffer)
 
bool AttMarker_stream (buffer &a_buffer)
 
bool Att3D_stream (buffer &a_buffer)
 
uint32 START_BIG_FILE ()
 
uint32 big_file_version_tag ()
 
bool AttAxis_stream (buffer &a_buffer)
 
bool axis_stream (buffer &a_buffer, const histo::axis< double, unsigned int > &a_axis, const std::string &a_name, const std::string &a_title)
 
bool List_empty_stream (buffer &a_buffer)
 
template<class HIST >
std::string axis_title (const HIST &a_h, const std::string &a_key)
 
template<class HIST >
bool TH_write_1D (buffer &a_buffer, const HIST &a_h, const std::string &a_name, const std::vector< double > &a_bin_Sw2)
 
template<class HIST >
bool TH_write_2D (buffer &a_buffer, const HIST &a_h, const std::string &a_name, const std::vector< double > &a_bin_Sw2)
 
template<class HIST >
bool TH_write_3D (buffer &a_buffer, const HIST &a_h, const std::string &a_name, const std::vector< double > &a_bin_Sw2)
 
bool TH1F_stream (buffer &a_buffer, const histo::h1df &a_h, const std::string &a_name)
 
bool TH1F_stream (buffer &a_buffer, const histo::h1d &a_h, const std::string &a_name)
 
bool TH1D_stream (buffer &a_buffer, const histo::h1d &a_h, const std::string &a_name)
 
bool TH2F_stream (buffer &a_buffer, const histo::h2d &a_h, const std::string &a_name)
 
bool TH2F_stream (buffer &a_buffer, const histo::h2df &a_h, const std::string &a_name)
 
bool TH2D_stream (buffer &a_buffer, const histo::h2d &a_h, const std::string &a_name)
 
bool TH3F_stream (buffer &a_buffer, const histo::h3d &a_h, const std::string &a_name)
 
bool TH3F_stream (buffer &a_buffer, const histo::h3df &a_h, const std::string &a_name)
 
bool TH3D_stream (buffer &a_buffer, const histo::h3d &a_h, const std::string &a_name)
 
bool TProfile_stream (buffer &a_buffer, const histo::p1d &a_p, const std::string &a_name)
 
bool TProfile2D_stream (buffer &a_buffer, const histo::p2d &a_p, const std::string &a_name)
 
bool to (directory &a_dir, const std::map< std::string, std::string > &a_annotations, const std::string &a_histo_name)
 
bool to (directory &a_dir, const histo::h1d &a_histo, const std::string &a_name)
 
bool to (directory &a_dir, const histo::h1df &a_histo, const std::string &a_name)
 
bool to (directory &a_dir, const histo::h2d &a_histo, const std::string &a_name)
 
bool to (directory &a_dir, const histo::h2df &a_histo, const std::string &a_name)
 
bool to (directory &a_dir, const histo::h3d &a_histo, const std::string &a_name)
 
bool to (directory &a_dir, const histo::h3df &a_histo, const std::string &a_name)
 
bool to (directory &a_dir, const histo::p1d &a_histo, const std::string &a_name)
 
bool to (directory &a_dir, const histo::p2d &a_histo, const std::string &a_name)
 
bool write_histos (directory &a_dir, const std::vector< std::pair< std::string, void * > > &a_hists)
 
bool to_osc (directory &a_dir, const histo::h1d &a_histo, const std::string &a_name)
 
bool to_osc (directory &a_dir, const histo::h2d &a_histo, const std::string &a_name)
 
bool to_osc (directory &a_dir, const histo::h3d &a_histo, const std::string &a_name)
 
bool to_osc (directory &a_dir, const histo::p1d &a_histo, const std::string &a_name)
 
bool to_osc (directory &a_dir, const histo::p2d &a_histo, const std::string &a_name)
 

Typedef Documentation

◆ date

typedef unsigned int tools::wroot::date

Definition at line 17 of file date.

◆ hd_data

typedef histo::histo_data<double,unsigned int,unsigned int,double> tools::wroot::hd_data

Definition at line 25 of file streamers.

◆ hf_data

typedef histo::histo_data<double,unsigned int,unsigned int,float> tools::wroot::hf_data

Definition at line 26 of file streamers.

◆ pd_data

typedef histo::profile_data<double,unsigned int,unsigned int,double,double> tools::wroot::pd_data

Definition at line 27 of file streamers.

◆ seek

typedef int64 tools::wroot::seek

Definition at line 16 of file seek.

◆ seek32

typedef int tools::wroot::seek32

Definition at line 17 of file seek.

Function Documentation

◆ acs()

void tools::wroot::acs ( unsigned int &  a_cs,
int  a_n,
int *  a_dims 
)
inline

Definition at line 17 of file infos.

17  {
18  for(int i=0;i<a_n;i++) a_cs = a_cs*3+(unsigned int)a_dims[i];
19 }

◆ add_before()

void tools::wroot::add_before ( std::list< free_seg * > &  a_list,
free_seg *  a_what,
free_seg *  a_new 
)
inline

Definition at line 117 of file free_seg.

117  {
118  tools_lforit(free_seg*,a_list,it) {
119  if((*it)==a_what) {
120  a_list.insert(it,a_new);
121  return;
122  }
123  }
124 }

◆ add_free()

free_seg* tools::wroot::add_free ( std::list< free_seg * > &  a_list,
seek  a_first,
seek  a_last 
)
inline

Definition at line 126 of file free_seg.

126  {
127  // Add a new free segment to the list of free segments
128  // ===================================================
129  // If last just preceedes an existing free segment, then first becomes
130  // the new starting location of the free segment.
131  // if first just follows an existing free segment, then last becomes
132  // the new ending location of the free segment.
133  // if first just follows an existing free segment AND last just preceedes
134  // an existing free segment, these two segments are merged into
135  // one single segment.
136  //
137 
138  free_seg* idcur = a_list.front();
139 
140  while (idcur) {
141  seek curfirst = idcur->first();
142  seek curlast = idcur->last();
143  if (curlast == (a_first-1)) {
144  idcur->set_last(a_last);
145  free_seg* idnext = find_after(a_list,idcur);
146  if (idnext == 0) return idcur;
147  if (idnext->first() > (a_last+1)) return idcur;
148  idcur->set_last(idnext->last());
149  remove(a_list,idnext); //idnext not deleted.
150  delete idnext;
151  return idcur;
152  }
153  if (curfirst == (a_last+1)) {
154  idcur->set_first(a_first);
155  return idcur;
156  }
157  if (a_first < curfirst) {
158  free_seg* newfree = new free_seg(idcur->out(),a_first,a_last);
159  add_before(a_list,idcur,newfree);
160  return newfree;
161  }
162  idcur = find_after(a_list,idcur);
163  }
164 
165  return 0;
166 }

◆ Att3D_stream()

bool tools::wroot::Att3D_stream ( buffer &  a_buffer)
inline

Definition at line 161 of file named.

161  {
162  unsigned int c;
163  if(!a_buffer.write_version(1,c)) return false;
164  if(!a_buffer.set_byte_count(c)) return false;
165  return true;
166 }

◆ AttAxis_stream()

bool tools::wroot::AttAxis_stream ( buffer &  a_buffer)
inline

Definition at line 29 of file streamers.

29  {
30  int fNdivisions = 510; //Number of divisions(10000*n3 + 100*n2 + n1)
31  short fAxisColor = 1; //color of the line axis
32  short fLabelColor = 1; //color of labels
33  short fLabelFont = 62; //font for labels
34  float fLabelOffset = 0.005F; //offset of labels
35  float fLabelSize = 0.04F; //size of labels
36  float fTickLength = 0.03F; //length of tick marks
37  float fTitleOffset = 1; //offset of axis title
38  float fTitleSize = 0.04F; //size of axis title
39  short fTitleColor = 1; //color of axis title
40  short fTitleFont = 62; //font for axis title
41 
42  // Version 4 streaming (ROOT/v3-00-6).
43  unsigned int beg;
44  if(!a_buffer.write_version(4,beg)) return false;
45 
46  if(!a_buffer.write(fNdivisions)) return false;
47  if(!a_buffer.write(fAxisColor)) return false;
48  if(!a_buffer.write(fLabelColor)) return false;
49  if(!a_buffer.write(fLabelFont)) return false;
50  if(!a_buffer.write(fLabelOffset)) return false;
51  if(!a_buffer.write(fLabelSize)) return false;
52  if(!a_buffer.write(fTickLength)) return false;
53  if(!a_buffer.write(fTitleOffset)) return false;
54  if(!a_buffer.write(fTitleSize)) return false;
55  if(!a_buffer.write(fTitleColor)) return false;
56  if(!a_buffer.write(fTitleFont)) return false;
57 
58  if(!a_buffer.set_byte_count(beg)) return false;
59  return true;
60 }

◆ AttFill_stream()

bool tools::wroot::AttFill_stream ( buffer &  a_buffer)
inline

Definition at line 137 of file named.

137  {
138  short fFillColor = 0;
139  short fFillStyle = 101;
140  unsigned int c;
141  if(!a_buffer.write_version(1,c)) return false;
142  if(!a_buffer.write(fFillColor)) return false;
143  if(!a_buffer.write(fFillStyle)) return false;
144  if(!a_buffer.set_byte_count(c)) return false;
145  return true;
146 }

◆ AttLine_stream()

bool tools::wroot::AttLine_stream ( buffer &  a_buffer)
inline

Definition at line 124 of file named.

124  {
125  short fLineColor = 1;
126  short fLineStyle = 1;
127  short fLineWidth = 1;
128  unsigned int c;
129  if(!a_buffer.write_version(1,c)) return false;
130  if(!a_buffer.write(fLineColor)) return false;
131  if(!a_buffer.write(fLineStyle)) return false;
132  if(!a_buffer.write(fLineWidth)) return false;
133  if(!a_buffer.set_byte_count(c)) return false;
134  return true;
135 }

◆ AttMarker_stream()

bool tools::wroot::AttMarker_stream ( buffer &  a_buffer)
inline

Definition at line 148 of file named.

148  {
149  short fMarkerColor = 1;
150  short fMarkerStyle = 1;
151  float fMarkerWidth = 1;
152  unsigned int c;
153  if(!a_buffer.write_version(1,c)) return false;
154  if(!a_buffer.write(fMarkerColor)) return false;
155  if(!a_buffer.write(fMarkerStyle)) return false;
156  if(!a_buffer.write(fMarkerWidth)) return false;
157  if(!a_buffer.set_byte_count(c)) return false;
158  return true;
159 }

◆ axis_stream()

bool tools::wroot::axis_stream ( buffer &  a_buffer,
const histo::axis< double, unsigned int > &  a_axis,
const std::string &  a_name,
const std::string &  a_title 
)
inline

Definition at line 62 of file streamers.

65  {
66  // Version 6 streaming (ROOT/v3-00-6).
67 
68  unsigned int beg;
69  if(!a_buffer.write_version(6,beg)) return false;
70 
71  if(!Named_stream(a_buffer,a_name,a_title)) return false;
72 
73  if(!AttAxis_stream(a_buffer)) return false;
74 
75  if(!a_buffer.write(a_axis.bins())) return false;
76  if(!a_buffer.write(a_axis.lower_edge())) return false;
77  if(!a_buffer.write(a_axis.upper_edge())) return false;
78 
79  // fXbins
80  //if(a_axis.m_fixed) {
81  // std::vector<double> v;
82  // ArrayT<double> dummy(v);
83  // if(!dummy.stream(a_buffer)) return false; //TArrayD
84  //} else {
85  if(!a_buffer.write_array(a_axis.edges())) return false; //TArrayD
86  //}
87 
88  if(!a_buffer.write((int)0)) return false; //fFirst
89  if(!a_buffer.write((int)0)) return false; //fLast
90 
91  //Bool_t
92  if(!a_buffer.write((unsigned char)0)) return false; //TimeDisplay
93 
94  //TString
95  if(!a_buffer.write(std::string())) return false; //TimeFormat
96 
97  if(!a_buffer.set_byte_count(beg)) return false;
98 
99  return true;
100 }

◆ axis_title()

template<class HIST >
std::string tools::wroot::axis_title ( const HIST &  a_h,
const std::string &  a_key 
)
inline

Definition at line 115 of file streamers.

115  {
116  typedef std::map<std::string,std::string> annotations_t;
117  annotations_t::const_iterator it = a_h.annotations().find(a_key);
118  if(it==a_h.annotations().end()) return std::string();
119  return (*it).second;
120 }

◆ base_cid()

cid tools::wroot::base_cid ( )
inline

Definition at line 14 of file cids.

14 {return 100;} //must be > cids in ../cids.

◆ base_leaf_cid()

cid tools::wroot::base_leaf_cid ( )
inline

Definition at line 20 of file cids.

20 {return base_cid()+20;} //+12=32

◆ big_file_version_tag()

uint32 tools::wroot::big_file_version_tag ( )
inline

Definition at line 21 of file seek.

21 {return 1000;}

◆ branch_element_store_class()

const std::string& tools::wroot::branch_element_store_class ( )
inline

Definition at line 12 of file branch_element.

12  {
13  static const std::string s_v("TBranchElement");
14  return s_v;
15 }

◆ fill_infos()

void tools::wroot::fill_infos ( obj_list< streamer_info > &  a_infos,
std::ostream &  a_out 
)
inline

Definition at line 1564 of file infos.

1564  {
1565 
1566  fill_infos_core(a_infos,a_out);
1567  fill_infos_cont(a_infos,a_out);
1568  fill_infos_graf(a_infos,a_out);
1569  fill_infos_tree(a_infos,a_out);
1570  fill_infos_histo(a_infos,a_out);
1571 
1572 }

◆ fill_infos_cont()

void tools::wroot::fill_infos_cont ( obj_list< streamer_info > &  a_infos,
std::ostream &   
)
inline

*fFirst

*fLast

*fCache

fAscending

Definition at line 361 of file infos.

361  {
362 
363  // sizeof(TString) = 8 (4 (virtual ~) + 1 + 3 (align))
364  // sizeof(TObject) = 12
365 
366  short TObject_version = 1;
367 
368  const int size_POINTER = 4;
369  const int size_BOOL = 4;
370 
371  int size_TCollection = 0;
372  short TCollection_version = 3;
373  {unsigned int check = 0;
374  //this :
375  scs(check,"TCollection");
376  //base :
377  scs(check,"TObject");
378  //members :
379  scs(check,"fName");
380  scs(check,"TString");
381 
382  scs(check,"fSize");
383  scs(check,"Int_t");
384 
385  streamer_info* info = new streamer_info("TCollection",TCollection_version,check);
386  a_infos.push_back(info);
387  // Elements :
388  int ofs = 0;
389  info->add(new streamer_base("TObject","Basic ROOT object",ofs,TObject_version));ofs += size_TObject();
390  info->add(new streamer_string(ofs,"fName","name of the collection"));
391  info->add(new streamer_int(ofs,"fSize","number of elements in collection"));
392  size_TCollection = ofs;
393  }
394 
395  int size_TSeqCollection = 0;
396  short TSeqCollection_version = 0;
397  {unsigned int check = 0;
398  //this :
399  scs(check,"TSeqCollection");
400  //base :
401  scs(check,"TCollection");
402  //members :
403  scs(check,"fSorted");
404  scs(check,"Bool_t");
405 
406  streamer_info* info = new streamer_info("TSeqCollection",TSeqCollection_version,check);
407  a_infos.push_back(info);
408  // Elements :
409  int ofs = 0;
410  info->add(new streamer_base("TCollection","Collection abstract base class",ofs,TCollection_version));ofs += size_TCollection;
411  info->add(new streamer_bool(ofs,"fSorted"," true if collection has been sorted"));
412  size_TSeqCollection = ofs;
413  }
414 
415  //int size_TList = 0;
416  short TList_version = 4;
417  {unsigned int check = 0;
418  //this :
419  scs(check,"TList");
420  //base :
421  scs(check,"TSeqCollection");
422  //members :
423 
424  streamer_info* info = new streamer_info("TList",TList_version,check);
425  a_infos.push_back(info);
426  // Elements :
427  int ofs = 0;
428  info->add(new streamer_base("TSeqCollection","Sequenceable collection abstract base class",ofs,TSeqCollection_version));ofs += size_TSeqCollection;
429  ofs += size_POINTER;
430  ofs += size_POINTER;
431  ofs += size_POINTER;
432  ofs += size_BOOL;
433  //size_TList = ofs;
434  }
435 }

◆ fill_infos_core()

void tools::wroot::fill_infos_core ( obj_list< streamer_info > &  a_infos,
std::ostream &  a_out 
)
inline

Definition at line 33 of file infos.

33  {
34 
35  // sizeof(TString) = 8 (4 (virtual ~) + 1 + 3 (align))
36  // sizeof(TObject) = 12
37  // sizeof(TNamed) = 28
38  // sizeof(TObjArray) = 40
39  // sizeof(TArray) = 8
40  // sizeof(TArrayI) = 12
41  // sizeof(TArrayD) = 12
42  // sizeof(TArrayF) = 12
43 
44  const int size_POINTER = 4;
45  //const int size_OBJECT_POINTER = 4;
46  //const int size_COUNTER = 4;
47 
48  const int size_TArray = 8;
49 
50  short TArray_version = 1;
51 
52  short TObject_version = 1;
53  {unsigned int check = 0;
54  //this :
55  scs(check,"TObject");
56  //members :
57  scs(check,"fUniqueID");
58  scs(check,"UInt_t");
59 
60  scs(check,"fBits");
61  scs(check,"UInt_t");
62 
63  streamer_info* info = new streamer_info("TObject",1,check);
64  a_infos.push_back(info);
65  // Elements :
66  int ofs = size_VIRTUAL();
67  info->add(new streamer_uint(ofs,"fUniqueID","object unique identifier"));
68  info->add(new streamer_uint(ofs,"fBits","bit field status word"));
69  if(ofs!=size_TObject()) {
70  a_out << "tools::wroot::fill_infos :"
71  << " TObject " << ofs << " (" << size_TObject() << " expected.)"
72  << std::endl;
73  }}
74 
75  short TNamed_version = 1;
76  {unsigned int check = 0;
77  //this :
78  scs(check,"TNamed");
79  //base :
80  scs(check,"TObject");
81  //members :
82  scs(check,"fName");
83  scs(check,"TString");
84 
85  scs(check,"fTitle");
86  scs(check,"TString");
87 
88  streamer_info* info = new streamer_info("TNamed",1,check);
89  a_infos.push_back(info);
90  // Elements :
91  int ofs = 0;
92  info->add(new streamer_base("TObject","Basic ROOT object",ofs,TObject_version));ofs += size_TObject();
93  info->add(new streamer_string(ofs,"fName","object identifier"));
94  info->add(new streamer_string(ofs,"fTitle","object title"));
95  if(ofs!=size_TNamed()){
96  a_out << "tools::wroot::fill_infos :"
97  << " TNamed " << ofs << " (" << size_TNamed() << " expected.)"
98  << std::endl;
99  }}
100 
101  {unsigned int check = 0;
102  //this :
103  scs(check,"TStreamerInfo");
104  //bases :
105  scs(check,"TNamed");
106  //members :
107  scs(check,"fCheckSum");
108  scs(check,"UInt_t");
109 
110  scs(check,"fClassVersion");
111  scs(check,"Int_t");
112 
113  scs(check,"fElements");
114  scs(check,"TObjArray*");
115 
116  streamer_info* info = new streamer_info("TStreamerInfo",2,check);
117  a_infos.push_back(info);
118  // Elements :
119  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version));//28
120  info->add(new streamer_uint("fCheckSum","checksum of original class",28));//4
121  info->add(new streamer_int("fClassVersion","Class version identifier",32));//4
122  //40 = 2*int+4*int_p+2*ulong_p+bool+p (bool=4 !)
123  info->add(new streamer_object_pointer("fElements","Array of TStreamerElements",76,"TObjArray*"));//4
124 
125  //80
126  }
127 
128  short TStreamerElement_version = 2;
129  {unsigned int check = 0;
130  //this :
131  scs(check,"TStreamerElement");
132  //bases :
133  scs(check,"TNamed");
134  //members :
135  scs(check,"fType");
136  scs(check,"Int_t");
137 
138  scs(check,"fSize");
139  scs(check,"Int_t");
140 
141  scs(check,"fArrayLength");
142  scs(check,"Int_t");
143 
144  scs(check,"fArrayDim");
145  scs(check,"Int_t");
146 
147  scs(check,"fMaxIndex");
148  scs(check,"Int_t");
149  int dim = 5;
150  acs(check,1,&dim);
151 
152  scs(check,"fTypeName");
153  scs(check,"TString");
154  //Should be : 2369818458U
155 
156  streamer_info* info = new streamer_info("TStreamerElement",2,check);
157  a_infos.push_back(info);
158  // Elements :
159  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version));
160  info->add(new streamer_int("fType","element type",28));
161  info->add(new streamer_int("fSize","sizeof element",32));
162  info->add(new streamer_int("fArrayLength","cumulative size of all array dims",36));
163  info->add(new streamer_int("fArrayDim","number of array dimensions",40));
164 
165  {streamer_element* elem = new streamer_int("fMaxIndex","Maximum array index for array dimension \"dim\"",44);
166  info->add(elem);
167  elem->setArrayDimension(1);
168  elem->setMaxIndex(0,5);}
169 
170  info->add(new streamer_string("fTypeName","Data type name of data member",72));}
171 
172  {unsigned int check = 0;
173  //this :
174  scs(check,"TStreamerBase");
175  //bases :
176  scs(check,"TStreamerElement");
177  //members :
178  scs(check,"fBaseVersion");
179  scs(check,"Int_t");
180  //Should be : 2671078514U
181 
182  streamer_info* info = new streamer_info("TStreamerBase",3,check);
183  a_infos.push_back(info);
184  // Elements :
185  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));
186  info->add(new streamer_int("fBaseVersion","version number of the base class",88));}
187 
188  {unsigned int check = 0;
189  //this :
190  scs(check,"TStreamerString");
191  //bases :
192  scs(check,"TStreamerElement");
193  //Should be : 2525579865U
194 
195  streamer_info* info = new streamer_info("TStreamerString",2,check);
196  a_infos.push_back(info);
197  // Elements :
198  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
199 
200  {unsigned int check = 0;
201  //this :
202  scs(check,"TStreamerBasicType");
203  //bases :
204  scs(check,"TStreamerElement");
205  //Should be : 3001875966U;
206 
207  streamer_info* info = new streamer_info("TStreamerBasicType",2,check);
208  a_infos.push_back(info);
209  // Elements :
210  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
211 
212  {unsigned int check = 0;
213  //this :
214  scs(check,"TStreamerBasicPointer");
215  //bases :
216  scs(check,"TStreamerElement");
217  //members :
218  scs(check,"fCountVersion");
219  scs(check,"Int_t");
220 
221  scs(check,"fCountName");
222  scs(check,"TString");
223 
224  scs(check,"fCountClass");
225  scs(check,"TString");
226  //Should be : 1587298059U
227 
228  streamer_info* info = new streamer_info("TStreamerBasicPointer",2,check);
229  a_infos.push_back(info);
230  // Elements :
231  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));
232  info->add(new streamer_int("fCountVersion","version number of the class with the counter",88));
233  info->add(new streamer_string("fCountName","name of data member holding the array count",92));
234  info->add(new streamer_string("fCountClass","name of the class with the counter",100));}
235 
236  {unsigned int check = 0;
237  //this :
238  scs(check,"TStreamerObject");
239  //bases :
240  scs(check,"TStreamerElement");
241  //Should be : 2177456715U
242 
243  streamer_info* info = new streamer_info("TStreamerObject",2,check);
244  a_infos.push_back(info);
245  // Elements :
246  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
247 
248  {unsigned int check = 0;
249  //this :
250  scs(check,"TStreamerObjectPointer");
251  //bases :
252  scs(check,"TStreamerElement");
253  //Should be : 720556968U
254 
255  streamer_info* info = new streamer_info("TStreamerObjectPointer",2,check);
256  a_infos.push_back(info);
257  // Elements :
258  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
259 
260  {unsigned int check = 0;
261  //this :
262  scs(check,"TStreamerObjectAny");
263  //bases :
264  scs(check,"TStreamerElement");
265  //Should be : 3108880127U
266 
267  streamer_info* info = new streamer_info("TStreamerObjectAny",2,check);
268  a_infos.push_back(info);
269  // Elements :
270  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
271 
272  {unsigned int check = 0;
273  //this :
274  scs(check,"TArray");
275  //members :
276  scs(check,"fN");
277  scs(check,"Int_t");
278 
279  streamer_info* info = new streamer_info("TArray",1,check);
280  a_infos.push_back(info);
281 
282  // Elements :
283  int ofs = 0;
284  ofs += size_VIRTUAL();
285  info->add(new streamer_int(ofs,"fN","Number of array elements"));
286  //size_TArray = ofs; //8
287  }
288 
289  {unsigned int check = 0;
290  //this :
291  scs(check,"TArrayI");
292  //base :
293  scs(check,"TArray");
294  //members :
295  scs(check,"fArray");
296  scs(check,"Int_t*");
297 
298  streamer_info* info = new streamer_info("TArrayI",1,check);
299  a_infos.push_back(info);
300 
301  // Elements :
302  int offset = 0;
303  info->add(new streamer_base("TArray","Abstract array base class",offset,TArray_version));offset += size_TArray;
304  info->add(new streamer_basic_pointer("fArray","[fN] Array of fN integers",offset,streamer__info::INT,"fN","TArray",1,"Int_t*"));offset += size_POINTER;
305 
306  //12
307  }
308 
309  {unsigned int check = 0;
310  //this :
311  scs(check,"TArrayD");
312  //base :
313  scs(check,"TArray");
314  //members :
315  scs(check,"fArray");
316  scs(check,"Double_t*");
317 
318  streamer_info* info = new streamer_info("TArrayD",1,check);
319  a_infos.push_back(info);
320 
321  // Elements :
322  int offset = 0;
323  info->add(new streamer_base("TArray","Abstract array base class",offset,TArray_version));offset += size_TArray; //8
324  info->add(new streamer_basic_pointer("fArray","[fN] Array of fN integers",offset,streamer__info::DOUBLE,"fN","TArray",1,"Double_t*"));offset += size_POINTER;
325 
326  //12
327  }
328 
329  {unsigned int check = 0;
330  //this :
331  scs(check,"TArrayF");
332  //base :
333  scs(check,"TArray");
334  //members :
335  scs(check,"fArray");
336  scs(check,"Float_t*");
337 
338  streamer_info* info = new streamer_info("TArrayF",1,check);
339  a_infos.push_back(info);
340 
341  // Elements :
342  int offset = 0;
343  info->add(new streamer_base("TArray","Abstract array base class",offset,TArray_version));offset += size_TArray;
344  info->add(new streamer_basic_pointer("fArray","[fN] Array of fN integers",offset,streamer__info::FLOAT,"fN","TArray",1,"Float_t*"));offset += size_POINTER;
345 
346  //12
347  }
348 
349  fill_vec(a_infos,"char",streamer__info::CHAR);
350  fill_vec(a_infos,"short",streamer__info::SHORT);
351  fill_vec(a_infos,"int",streamer__info::INT);
352  fill_vec(a_infos,"unsigned char",streamer__info::UNSIGNED_CHAR);
353  fill_vec(a_infos,"unsigned short",streamer__info::UNSIGNED_SHORT);
354  fill_vec(a_infos,"unsigned int",streamer__info::UNSIGNED_INT);
355  fill_vec(a_infos,"float",streamer__info::FLOAT);
356  fill_vec(a_infos,"double",streamer__info::DOUBLE);
357  fill_vec(a_infos,"bool",streamer__info::BOOL);
358 
359 }

◆ fill_infos_graf()

void tools::wroot::fill_infos_graf ( obj_list< streamer_info > &  a_infos,
std::ostream &  a_out 
)
inline

Definition at line 441 of file infos.

441  {
442 
443  //sizeof(Font_t) = 2
444  //sizeof(Style_t) = 2
445  //sizeof(Marker_t) = 2
446  //sizeof(Width_t) = 2
447  //sizeof(Size_t) = 4
448 
449  const int size_SHORT = 2;
450  const int size_FLOAT = 4;
451 
452  {unsigned int check = 0;
453  //this :
454  scs(check,"TAttLine");
455  //members :
456  scs(check,"fLineColor");
457  scs(check,"Color_t");
458 
459  scs(check,"fLineStyle");
460  scs(check,"Style_t");
461 
462  scs(check,"fLineWidth");
463  scs(check,"Width_t");
464 
465  //Should be : 1369587346U
466 
467  // Beurk ; but the ROOT TTree compells indirectly the below.
468  streamer_info* info = new streamer_info("TAttLine",1,check);
469  a_infos.push_back(info);
470  // Elements :
471  int ofs = size_VIRTUAL();
472  info->add(new streamer_basic_type("fLineColor","line color",ofs,streamer__info::SHORT,"Color_t"));ofs += size_SHORT;
473  info->add(new streamer_basic_type("fLineStyle","line style",ofs,streamer__info::SHORT,"Style_t"));ofs += size_SHORT;
474  info->add(new streamer_basic_type("fLineWidth","line width",ofs,streamer__info::SHORT,"Width_t"));ofs += size_SHORT;
475  //2 (alignement ???)
476  if(ofs!=size_TAttLine()) {
477  a_out << "tools::wroot::fill_infos :"
478  << " TAttLine " << ofs << " (" << size_TAttLine() << " expected.)"
479  << std::endl;
480  }}
481 
482  {unsigned int check = 0;
483  //this :
484  scs(check,"TAttFill");
485  //members :
486  scs(check,"fFillColor");
487  scs(check,"Color_t");
488 
489  scs(check,"fFillStyle");
490  scs(check,"Style_t");
491 
492  //Should be : 1204118360U
493  streamer_info* info = new streamer_info("TAttFill",1,check);
494  a_infos.push_back(info);
495  // Elements :
496  int ofs = size_VIRTUAL();
497  info->add(new streamer_basic_type("fFillColor","fill area color",ofs,streamer__info::SHORT,"Color_t"));ofs += size_SHORT;
498  info->add(new streamer_basic_type("fFillStyle","fill area style",ofs,streamer__info::SHORT,"Style_t"));ofs += size_SHORT;
499  if(ofs!=size_TAttFill()) {
500  a_out << "tools::wroot::fill_infos :"
501  << " TAttFill " << ofs << " (" << size_TAttFill() << " expected.)"
502  << std::endl;
503  }}
504 
505  {unsigned int check = 0;
506  //this :
507  scs(check,"TAttMarker");
508  //members :
509  scs(check,"fMarkerColor");
510  scs(check,"Color_t");
511 
512  scs(check,"fMarkerStyle");
513  scs(check,"Style_t");
514 
515  scs(check,"fMarkerSize");
516  scs(check,"Size_t");
517 
518  //Should be 4207747460U
519 
520  streamer_info* info = new streamer_info("TAttMarker",1,check);
521  a_infos.push_back(info);
522  // Elements :
523  int ofs = size_VIRTUAL();
524  info->add(new streamer_basic_type("fMarkerColor","Marker color index",ofs,streamer__info::SHORT,"Color_t"));ofs += size_SHORT;
525  info->add(new streamer_basic_type("fMarkerStyle","Marker style",ofs,streamer__info::SHORT,"Style_t"));ofs += size_SHORT;
526  info->add(new streamer_basic_type("fMarkerSize","Marker size",ofs,streamer__info::FLOAT,"Size_t"));ofs += size_FLOAT;
527  if(ofs!=size_TAttMarker()) {
528  a_out << "tools::wroot::fill_infos :"
529  << " TAttMarker " << ofs << " (" << size_TAttMarker() << " expected.)"
530  << std::endl;
531  }}
532 
533 }

◆ fill_infos_histo()

void tools::wroot::fill_infos_histo ( obj_list< streamer_info > &  a_infos,
std::ostream &  a_out 
)
inline

*fXlabels

*fParent

*fDirectory

fDimension

*fIntegral

*fPainter

Definition at line 1064 of file infos.

1064  {
1065 
1066  typedef streamer_basic_type sbt;
1067 
1068  const int size_POINTER = 4;
1069 
1070  const int size_DOUBLE = 8;
1071  const int size_SHORT = 2;
1072  const int size_INT = 4;
1073 
1074  //const int size_TObjArray = 40;
1075  const int size_TArrayD = 12;
1076  const int size_TArrayF = 12;
1077 
1078  short TNamed_version = 1;
1079  short TArrayF_version = 1;
1080  short TArrayD_version = 1;
1081 
1082  short TAttLine_version = 1;
1083  short TAttFill_version = 1;
1084  short TAttMarker_version = 1;
1085 
1086  short TAttAxis_version = 4;
1087 
1088 
1089  {unsigned int check = 0;
1090  //this :
1091  scs(check,"TAttAxis");
1092  //members :
1093  scs(check,"fNdivisions");
1094  scs(check,"Int_t");
1095 
1096  scs(check,"fAxisColor");
1097  scs(check,"Color_t");
1098 
1099  scs(check,"fLabelColor");
1100  scs(check,"Color_t");
1101 
1102  scs(check,"fLabelFont");
1103  scs(check,"Style_t");
1104 
1105  scs(check,"fLabelOffset");
1106  scs(check,"Float_t");
1107 
1108  scs(check,"fLabelSize");
1109  scs(check,"Float_t");
1110 
1111  scs(check,"fTickLength");
1112  scs(check,"Float_t");
1113 
1114  scs(check,"fTitleOffset");
1115  scs(check,"Float_t");
1116 
1117  scs(check,"fTitleSize");
1118  scs(check,"Float_t");
1119 
1120  scs(check,"fTitleColor");
1121  scs(check,"Color_t");
1122 
1123  scs(check,"fTitleFont");
1124  scs(check,"Style_t");
1125 
1126  streamer_info* info = new streamer_info("TAttAxis",4,check);
1127  a_infos.push_back(info);
1128  // Elements :
1129  int ofs = size_VIRTUAL();
1130  info->add(new streamer_int(ofs,"fNdivisions","Number of divisions(10000*n3 + 100*n2 + n1)"));
1131  info->add(new sbt("fAxisColor","color of the line axis",ofs,streamer__info::SHORT,"Color_t"));ofs += size_SHORT;
1132  info->add(new sbt("fLabelColor","color of labels",ofs,streamer__info::SHORT,"Color_t"));ofs += size_SHORT;
1133  info->add(new sbt("fLabelFont","font for labels",ofs,streamer__info::SHORT,"Style_t"));ofs += size_SHORT;
1134  info->add(new streamer_float(ofs,"fLabelOffset","offset of labels"));
1135  info->add(new streamer_float(ofs,"fLabelSize","size of labels"));
1136  info->add(new streamer_float(ofs,"fTickLength","length of tick marks"));
1137  info->add(new streamer_float(ofs,"fTitleOffset","offset of axis title"));
1138  info->add(new streamer_float(ofs,"fTitleSize","size of axis title"));
1139  info->add(new sbt("fTitleColor","color of axis title",ofs,streamer__info::SHORT,"Color_t"));ofs += size_SHORT;
1140  info->add(new sbt("fTitleFont","font for axis title",ofs,streamer__info::SHORT,"Style_t"));ofs += size_SHORT;
1141  //uuuu ofs += 2; //alignement ???
1142  if(ofs!=size_TAttAxis()) {
1143  a_out << "tools::wroot::fill_infos :"
1144  << " TAttAxis " << ofs << " (" << size_TAttAxis() << " expected.)"
1145  << std::endl;
1146  }}
1147 
1148  {unsigned int check = 0;
1149  //this :
1150  scs(check,"TAxis");
1151  //bases :
1152  scs(check,"TNamed");
1153  scs(check,"TAttAxis");
1154  //members :
1155  scs(check,"fNbins");
1156  scs(check,"Int_t");
1157 
1158  scs(check,"fXmin");
1159  scs(check,"Axis_t");
1160 
1161  scs(check,"fXmax");
1162  scs(check,"Axis_t");
1163 
1164  scs(check,"fXbins");
1165  scs(check,"TArrayD");
1166 
1167  scs(check,"fFirst");
1168  scs(check,"Int_t");
1169 
1170  scs(check,"fLast");
1171  scs(check,"Int_t");
1172 
1173  scs(check,"fTimeDisplay");
1174  scs(check,"Bool_t");
1175 
1176  scs(check,"fTimeFormat");
1177  scs(check,"TString");
1178 
1179  streamer_info* info = new streamer_info("TAxis",6,check);
1180  a_infos.push_back(info);
1181 
1182  // Elements :
1183  int ofs = 0;
1184  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",ofs,TNamed_version));ofs += size_TNamed();
1185  info->add(new streamer_base("TAttAxis","Axis attributes",ofs,TAttAxis_version));ofs += size_TAttAxis();
1186  info->add(new streamer_int(ofs,"fNbins","Number of bins"));
1187  info->add(new sbt("fXmin","low edge of first bin",ofs,streamer__info::DOUBLE,"Axis_t"));ofs += size_DOUBLE;
1188  info->add(new sbt("fXmax","upper edge of last bin",ofs,streamer__info::DOUBLE,"Axis_t"));ofs += size_DOUBLE;
1189  info->add(new streamer_object_any("fXbins","Bin edges array in X",ofs,"TArrayD"));ofs += size_TArrayD;
1190  ofs += size_POINTER;
1191  info->add(new streamer_int(ofs,"fFirst","first bin to display"));
1192  info->add(new streamer_int(ofs,"fLast","last bin to display"));
1193  info->add(new streamer_bool(ofs,"fTimeDisplay","on/off displaying time values instead of numerics"));
1194  info->add(new streamer_string(ofs,"fTimeFormat","Date&time format, ex: 09/12/99 12:34:00"));
1195  ofs += size_POINTER;
1196  //v3-05-07 : 124 (stored) + 4 = 128
1197  if(ofs!=size_TAxis()) {
1198  a_out << "tools::wroot::fill_infos :"
1199  << " TAxis " << ofs << " (" << size_TAxis() << " expected.)"
1200  << std::endl;
1201  }}
1202 
1203  short TH1_version = 3;
1204  {unsigned int check = 0;
1205  //this :
1206  scs(check,"TH1");
1207  //bases :
1208  scs(check,"TNamed");
1209  scs(check,"TAttLine");
1210  scs(check,"TAttFill");
1211  scs(check,"TAttMarker");
1212  //members :
1213  scs(check,"fNcells");
1214  scs(check,"Int_t");
1215 
1216  scs(check,"fXaxis");
1217  scs(check,"TAxis");
1218 
1219  scs(check,"fBarOffset");
1220  scs(check,"Short_t");
1221 
1222  scs(check,"fBarWidth");
1223  scs(check,"Short_t");
1224 
1225  scs(check,"fEntries");
1226  scs(check,"Stat_t");
1227 
1228  scs(check,"fTsumw");
1229  scs(check,"Stat_t");
1230 
1231  scs(check,"fTsumw2");
1232  scs(check,"Stat_t");
1233 
1234  scs(check,"fTsumwx");
1235  scs(check,"Stat_t");
1236 
1237  scs(check,"fTsumwx2");
1238  scs(check,"Stat_t");
1239 
1240  scs(check,"fMaximum");
1241  scs(check,"Double_t");
1242 
1243  scs(check,"fMinimum");
1244  scs(check,"Double_t");
1245 
1246  scs(check,"fNormFactor");
1247  scs(check,"Double_t");
1248 
1249  scs(check,"fContour");
1250  scs(check,"TArrayD");
1251 
1252  scs(check,"fSumw2");
1253  scs(check,"TArrayD");
1254 
1255  scs(check,"fOption");
1256  scs(check,"TString");
1257 
1258  scs(check,"fFunctions");
1259  scs(check,"TList*");
1260 
1261  streamer_info* info = new streamer_info("TH1",TH1_version,check);
1262  a_infos.push_back(info);
1263 
1264  int ofs = 0;
1265  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",ofs,TNamed_version));ofs += size_TNamed();
1266  info->add(new streamer_base("TAttLine","Line attributes",ofs,TAttLine_version));ofs += size_TAttLine();
1267  info->add(new streamer_base("TAttFill","Fill area attributes",ofs,TAttFill_version));ofs += size_TAttFill();
1268  info->add(new streamer_base("TAttMarker","Marker attributes",ofs,TAttMarker_version));ofs += size_TAttMarker();
1269  info->add(new streamer_int(ofs,"fNcells","number of bins(1D), cells (2D) +U/Overflows"));
1270  info->add(new streamer_object("fXaxis","X axis descriptor",ofs,"TAxis"));ofs += size_TAxis();
1271  info->add(new streamer_object("fYaxis","Y axis descriptor",ofs,"TAxis"));ofs += size_TAxis();
1272  info->add(new streamer_object("fZaxis","Z axis descriptor",ofs,"TAxis"));ofs += size_TAxis();
1273  info->add(new streamer_short(ofs,"fBarOffset","(1000*offset) for bar charts or legos"));
1274  info->add(new streamer_short(ofs,"fBarWidth","(1000*width) for bar charts or legos"));
1275  info->add(new streamer_stat_t(ofs,"fEntries","Number of entries"));
1276  info->add(new streamer_stat_t(ofs,"fTsumw","Total Sum of weights"));
1277  info->add(new streamer_stat_t(ofs,"fTsumw2","Total Sum of squares of weights"));
1278  info->add(new streamer_stat_t(ofs,"fTsumwx","Total Sum of weight*X"));
1279  info->add(new streamer_stat_t(ofs,"fTsumwx2","Total Sum of weight*X*X"));
1280  info->add(new streamer_double(ofs,"fMaximum","Maximum value for plotting"));
1281  info->add(new streamer_double(ofs,"fMinimum","Minimum value for plotting"));
1282  info->add(new streamer_double(ofs,"fNormFactor","Normalization factor"));
1283  info->add(new streamer_object_any("fContour","Array to display contour levels",ofs,"TArrayD"));ofs += size_TArrayD;
1284  info->add(new streamer_object_any("fSumw2","Array of sum of squares of weights",ofs,"TArrayD"));ofs += size_TArrayD;
1285  info->add(new streamer_string(ofs,"fOption","histogram options"));
1286  info->add(new streamer_object_pointer("fFunctions","->Pointer to list of functions (fits and user)",ofs,"TList*"));ofs += size_POINTER;
1287  ofs += size_POINTER;
1288  ofs += size_INT;
1289  ofs += size_POINTER;
1290  ofs += size_POINTER;
1291  //v3-05-07 : 576 = 568 + 2 * 4 = ok
1292  if(ofs!=size_TH1()) {
1293  a_out << "tools::wroot::fill_infos :"
1294  << " TH1 " << ofs << " (" << size_TH1() << " expected.)"
1295  << std::endl;
1296  }}
1297 
1298  {unsigned int check = 0;
1299  //this :
1300  scs(check,"TH1F");
1301  //base :
1302  scs(check,"TH1");
1303  scs(check,"TArrayF");
1304 
1305  streamer_info* info = new streamer_info("TH1F",1,check);
1306  a_infos.push_back(info);
1307  int ofs = 0;
1308  info->add(new streamer_base("TH1","1-Dim histogram base class",ofs,TH1_version));ofs += size_TH1();
1309  info->add(new streamer_base("TArrayF","Array of floats",ofs,TArrayF_version));ofs += size_TArrayF;
1310  }
1311 
1312  int size_TH1D = 0;
1313  short TH1D_version = 1;
1314  {unsigned int check = 0;
1315  //this :
1316  scs(check,"TH1D");
1317  //base :
1318  scs(check,"TH1");
1319  scs(check,"TArrayD");
1320 
1321  streamer_info* info = new streamer_info("TH1D",TH1D_version,check);
1322  a_infos.push_back(info);
1323  int ofs = 0;
1324  info->add(new streamer_base("TH1","1-Dim histogram base class",ofs,TH1_version));ofs += size_TH1();
1325  info->add(new streamer_base("TArrayD","Array of doubles",ofs,TArrayD_version));ofs += size_TArrayD;
1326  size_TH1D = ofs; //580
1327 
1328  //v3-05-07 : 588 = 576 + 12 = ok
1329  }
1330 
1331  {unsigned int check = 0;
1332  //this :
1333  scs(check,"TProfile");
1334  //base :
1335  scs(check,"TH1D");
1336  //members :
1337  scs(check,"fBinEntries");
1338  scs(check,"TArrayD");
1339 
1340  scs(check,"fErrorMode");
1341  scs(check,"EErrorType");//FIXME : ok ?
1342 
1343  scs(check,"fYmin");
1344  scs(check,"Double_t");
1345 
1346  scs(check,"fYmax");
1347  scs(check,"Double_t");
1348 
1349  scs(check,"fTsumwy");
1350  scs(check,"Double_t");
1351 
1352  scs(check,"fTsumwy2");
1353  scs(check,"Double_t");
1354 
1355  streamer_info* info = new streamer_info("TProfile",4,check);
1356  a_infos.push_back(info);
1357 
1358  int ofs = 0;
1359  info->add(new streamer_base("TH1D","1-Dim histograms (one double per channel)",ofs,TH1D_version));ofs += size_TH1D;
1360  info->add(new streamer_object_any("fBinEntries","number of entries per bin",ofs,"TArrayD"));ofs += size_TArrayD;
1361  info->add(new streamer_basic_type("fErrorMode","Option to compute errors",ofs,streamer__info::INT,"EErrorType"));ofs += size_INT;
1362  info->add(new streamer_double(ofs,"fYmin","Lower limit in Y (if set)"));
1363  info->add(new streamer_double(ofs,"fYmax","Upper limit in Y (if set)"));
1364  info->add(new streamer_double(ofs,"fTsumwy","Total Sum of weight*Y"));
1365  info->add(new streamer_double(ofs,"fTsumwy2","Total Sum of weight*Y*Y"));
1366  //628
1367 
1368  //v3-05-07 : 624 = 612 + 4 + 8 (diff TH1D) = ok
1369  }
1370 
1371  short TH2_version = 3;
1372  {unsigned int check = 0;
1373  //this :
1374  scs(check,"TH2");
1375  //bases :
1376  scs(check,"TH1");
1377  //members :
1378  scs(check,"fScalefactor");
1379  scs(check,"Stat_t");
1380 
1381  scs(check,"fTsumwy");
1382  scs(check,"Stat_t");
1383 
1384  scs(check,"fTsumwy2");
1385  scs(check,"Stat_t");
1386 
1387  scs(check,"fTsumwxy");
1388  scs(check,"Stat_t");
1389 
1390  streamer_info* info = new streamer_info("TH2",TH2_version,check);
1391  a_infos.push_back(info);
1392 
1393  int ofs = 0;
1394  info->add(new streamer_base("TH1","1-Dim histogram base class",ofs,TH1_version));ofs += size_TH1();
1395  info->add(new streamer_stat_t(ofs,"fScalefactor","Scale factor"));
1396  info->add(new streamer_stat_t(ofs,"fTsumwy","Total Sum of weight*Y"));
1397  info->add(new streamer_stat_t(ofs,"fTsumwy2","Total Sum of weight*Y*Y"));
1398  info->add(new streamer_stat_t(ofs,"fTsumwxy","Total Sum of weight*X*Y"));
1399  //v3-05-07 : <to be checked>
1400  if(ofs!=size_TH2()) {
1401  a_out << "tools::wroot::fill_infos :"
1402  << " TH2 " << ofs << " (" << size_TH2() << " expected.)"
1403  << std::endl;
1404  }}
1405 
1406  {unsigned int check = 0;
1407  //this :
1408  scs(check,"TH2F");
1409  //base :
1410  scs(check,"TH2");
1411  scs(check,"TArrayF");
1412 
1413  streamer_info* info = new streamer_info("TH2F",3,check);
1414  a_infos.push_back(info);
1415 
1416  int ofs = 0;
1417  info->add(new streamer_base("TH2","2-Dim histogram base class",ofs,TH2_version));ofs += size_TH2();
1418  info->add(new streamer_base("TArrayF","Array of floats",ofs,TArrayF_version));ofs += size_TArrayF;
1419  //612
1420 
1421  }
1422 
1423  short TH2D_version = 3;
1424  {unsigned int check = 0;
1425  //this :
1426  scs(check,"TH2D");
1427  //base :
1428  scs(check,"TH2");
1429  scs(check,"TArrayD");
1430 
1431  streamer_info* info = new streamer_info("TH2D",TH2D_version,check);
1432  a_infos.push_back(info);
1433 
1434  int ofs = 0;
1435  info->add(new streamer_base("TH2","2-Dim histogram base class",ofs,TH2_version));ofs += size_TH2();
1436  info->add(new streamer_base("TArrayD","Array of doubles",ofs,TArrayD_version));ofs += size_TArrayD;
1437  if(ofs!=size_TH2D()) {
1438  a_out << "tools::wroot::fill_infos :"
1439  << " TH2D " << ofs << " (" << size_TH2D() << " expected.)"
1440  << std::endl;
1441  }}
1442 
1443  {unsigned int check = 0;
1444  //this :
1445  scs(check,"TProfile2D");
1446  //base :
1447  scs(check,"TH2D");
1448  //members :
1449  scs(check,"fBinEntries");
1450  scs(check,"TArrayD");
1451 
1452  scs(check,"fErrorMode");
1453  scs(check,"EErrorType");//FIXME : ok ?
1454 
1455  scs(check,"fZmin");
1456  scs(check,"Double_t");
1457 
1458  scs(check,"fZmax");
1459  scs(check,"Double_t");
1460 
1461  scs(check,"fTsumwz");
1462  scs(check,"Double_t");
1463 
1464  scs(check,"fTsumwz2");
1465  scs(check,"Double_t");
1466 
1467  streamer_info* info = new streamer_info("TProfile2D",5,check);
1468  a_infos.push_back(info);
1469 
1470  int ofs = 0;
1471  info->add(new streamer_base("TH2D","2-Dim histograms (one double per channel)",ofs,TH2D_version));ofs += size_TH2D();
1472  info->add(new streamer_object_any("fBinEntries","number of entries per bin",ofs,"TArrayD"));ofs += size_TArrayD;
1473  info->add(new sbt("fErrorMode","Option to compute errors",ofs,streamer__info::INT,"EErrorType"));ofs += size_INT;
1474  info->add(new streamer_double(ofs,"fZmin","Lower limit in Z (if set)"));
1475  info->add(new streamer_double(ofs,"fZmax","Upper limit in Z (if set)"));
1476  info->add(new streamer_double(ofs,"fTsumwz","Total Sum of weight*Z"));
1477  info->add(new streamer_double(ofs,"fTsumwz2","Total Sum of weight*Z*Z"));
1478  //660
1479 
1480  }
1481 
1482  int size_TH3 = 0;
1483  short TH3_version = 4;
1484  short TAtt3D_version = 1;
1485  {unsigned int check = 0;
1486  //this :
1487  scs(check,"TH3");
1488  //bases :
1489  scs(check,"TH1");
1490  scs(check,"TAtt3D");
1491  //members :
1492  scs(check,"fTsumwy");
1493  scs(check,"Double_t");
1494  scs(check,"fTsumwy2");
1495  scs(check,"Double_t");
1496  scs(check,"fTsumwxy");
1497  scs(check,"Double_t");
1498 
1499  scs(check,"fTsumwz");
1500  scs(check,"Double_t");
1501  scs(check,"fTsumwz2");
1502  scs(check,"Double_t");
1503  scs(check,"fTsumwxz");
1504  scs(check,"Double_t");
1505  scs(check,"fTsumwyz");
1506  scs(check,"Double_t");
1507 
1508  streamer_info* info = new streamer_info("TH3",TH3_version,check);
1509  a_infos.push_back(info);
1510 
1511  int ofs = 0;
1512  info->add(new streamer_base("TH1","1-Dim histogram base class",ofs,TH1_version));ofs += size_TH1();
1513  info->add(new streamer_base("TAtt3D","3D attributes",ofs,TAtt3D_version));ofs += 0;
1514  info->add(new streamer_double(ofs,"fTsumwy","Total Sum of weight*Y"));
1515  info->add(new streamer_double(ofs,"fTsumwy2","Total Sum of weight*Y*Y"));
1516  info->add(new streamer_double(ofs,"fTsumwxy","Total Sum of weight*X*Y"));
1517 
1518  info->add(new streamer_double(ofs,"fTsumwz","Total Sum of weight*Z"));
1519  info->add(new streamer_double(ofs,"fTsumwz2","Total Sum of weight*Z*Z"));
1520  info->add(new streamer_double(ofs,"fTsumwxz","Total Sum of weight*X*Z"));
1521  info->add(new streamer_double(ofs,"fTsumwyz","Total Sum of weight*Y*Z"));
1522  size_TH3 = ofs; //624
1523 
1524  //v4-00-02 : <to be checked>
1525  }
1526 
1527  {unsigned int check = 0;
1528  //this :
1529  scs(check,"TH3F");
1530  //base :
1531  scs(check,"TH3");
1532  scs(check,"TArrayF");
1533 
1534  streamer_info* info = new streamer_info("TH3F",3,check);
1535  a_infos.push_back(info);
1536 
1537  int ofs = 0;
1538  info->add(new streamer_base("TH3","3-Dim histogram base class",ofs,TH3_version));ofs += size_TH3;
1539  info->add(new streamer_base("TArrayF","Array of floats",ofs,TArrayF_version));ofs += size_TArrayF;
1540  //636
1541 
1542  }
1543 
1544  {unsigned int check = 0;
1545  //this :
1546  scs(check,"TH3D");
1547  //base :
1548  scs(check,"TH3");
1549  scs(check,"TArrayD");
1550 
1551  streamer_info* info = new streamer_info("TH3D",3,check);
1552  a_infos.push_back(info);
1553 
1554  int ofs = 0;
1555  info->add(new streamer_base("TH3","3-Dim histogram base class",ofs,TH3_version));ofs += size_TH3;
1556  info->add(new streamer_base("TArrayD","Array of doubles",ofs,TArrayD_version));ofs += size_TArrayD;
1557  //636
1558 
1559  }
1560 
1561 
1562 }

◆ fill_infos_tree()

void tools::wroot::fill_infos_tree ( obj_list< streamer_info > &  a_infos,
std::ostream &  a_out 
)
inline

fChainOffset

fReadEntry

fTotalBuffers

fPacketSize

fNfill

*fDirectory

*fEventList

*fPlayer

fNLeaves

fReadBasket

fReadEntry

fNBasketRAM

*fBasketRAM

*fTree

*fAddress

*fDirectory

fNdata

*fBranch

*fAbsAddress

Definition at line 539 of file infos.

539  {
540 
541  const int size_CHAR = 1;
542  const int size_INT = 4;
543  const int size_POINTER = 4;
544  const int size_COUNTER = 4;
545 
546  const int size_TObjArray = 40;
547  const int size_TArrayD = 12;
548  const int size_TArrayI = 12;
549 
550  short TNamed_version = 1;
551 
552  short TAttLine_version = 1;
553  short TAttFill_version = 1;
554  short TAttMarker_version = 1;
555  short TBranch_version = 8;
556  short TLeaf_version = 2;
557 
558  {unsigned int check = 0;
559  //this :
560  scs(check,"TTree");
561  //bases :
562  scs(check,"TNamed");
563  scs(check,"TAttLine");
564  scs(check,"TAttFill");
565  scs(check,"TAttMarker");
566  //members :
567  scs(check,"fEntries");
568  scs(check,"Stat_t");
569 
570  scs(check,"fTotBytes");
571  scs(check,"Stat_t");
572 
573  scs(check,"fZipBytes");
574  scs(check,"Stat_t");
575 
576  scs(check,"fSavedBytes");
577  scs(check,"Stat_t");
578 
579  scs(check,"fTimerInterval");
580  scs(check,"Int_t");
581 
582  scs(check,"fScanField");
583  scs(check,"Int_t");
584 
585  scs(check,"fUpdate");
586  scs(check,"Int_t");
587 
588  scs(check,"fMaxEntryLoop");
589  scs(check,"Int_t");
590 
591  scs(check,"fMaxVirtualSize");
592  scs(check,"Int_t");
593 
594  scs(check,"fAutoSave");
595  scs(check,"Int_t");
596 
597  scs(check,"fEstimate");
598  scs(check,"Int_t");
599 
600  scs(check,"fBranches");
601  scs(check,"TObjArray");
602 
603  scs(check,"fLeaves");
604  scs(check,"TObjArray");
605 
606  //scs(check,"fAliases");
607  //scs(check,"TList*");
608 
609  scs(check,"fIndexValues");
610  scs(check,"TArrayD");
611 
612  scs(check,"fIndex");
613  scs(check,"TArrayI");
614 
615  //scs(check,"fFriends");
616  //scs(check,"TList*");
617  //Should be : 3245044844U //3.00.06
618  //Should be : FIXME //3.10.02
619 
620  streamer_info* info = new streamer_info("TTree",5,check);
621  a_infos.push_back(info);
622 
623  // Elements :
624  int ofs = 0;
625  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",ofs,TNamed_version));ofs += size_TNamed();
626  info->add(new streamer_base("TAttLine","Line attributes",ofs,TAttLine_version));ofs += size_TAttLine();
627  info->add(new streamer_base("TAttFill","Fill area attributes",ofs,TAttFill_version));ofs += size_TAttFill();
628  info->add(new streamer_base("TAttMarker","Marker attributes",ofs,TAttMarker_version));ofs += size_TAttMarker();
629 
630  info->add(new streamer_stat_t(ofs,"fEntries","Number of entries"));
631  info->add(new streamer_stat_t(ofs,"fTotBytes","Total number of bytes in all branches before compression"));
632  info->add(new streamer_stat_t(ofs,"fZipBytes","Total number of bytes in all branches after compression"));
633  info->add(new streamer_stat_t(ofs,"fSavedBytes","Number of autosaved bytes"));
634 
635  info->add(new streamer_int(ofs,"fTimerInterval","Timer interval in milliseconds"));
636  info->add(new streamer_int(ofs,"fScanField","Number of runs before prompting in Scan"));
637  info->add(new streamer_int(ofs,"fUpdate","Update frequency for EntryLoop"));
638  info->add(new streamer_int(ofs,"fMaxEntryLoop","Maximum number of entries to process"));
639  info->add(new streamer_int(ofs,"fMaxVirtualSize","Maximum total size of buffers kept in memory"));
640  info->add(new streamer_int(ofs,"fAutoSave","Autosave tree when fAutoSave bytes produced"));
641  info->add(new streamer_int(ofs,"fEstimate","Number of entries to estimate histogram limits"));
642  ofs += size_INT;
643  ofs += size_INT;
644  ofs += size_INT;
645  ofs += size_INT;
646  ofs += size_INT;
647  ofs += size_POINTER;
648  info->add(new streamer_object("fBranches","List of Branches",ofs,"TObjArray"));ofs += size_TObjArray;
649  info->add(new streamer_object("fLeaves","Direct pointers to individual branch leaves",ofs,"TObjArray"));ofs += size_TObjArray;
650  ofs += size_POINTER;
651  info->add(new streamer_object_any("fIndexValues","Sorted index values",ofs,"TArrayD"));ofs += size_TArrayD;
652  info->add(new streamer_object_any("fIndex","Index of sorted values",ofs,"TArrayI"));ofs += size_TArrayI;
653  ofs += size_POINTER;
654 
655  if(ofs!=size_TTree()) {
656  a_out << "tools::wroot::fill_infos :"
657  << " TTree " << ofs << " (" << size_TTree() << " expected.)"
658  << std::endl;
659  }
660 
661  //info->add(new streamer_object_pointer("fAliases","List of aliases for expressions based on the tree branches.",offset,"TList*"));offset += size_OBJECT_POINTER;
662  //info->add(new streamer_object_pointer("fFriends","pointer to list of friend elements",offset,"TList*"));offset += size_OBJECT_POINTER;
663  }
664 
665  //---------------------------------------------------------------------
666  {unsigned int check = 0;
667  //this :
668  scs(check,"TBranch");
669  //bases :
670  scs(check,"TNamed");
671  scs(check,"TAttFill");
672  //members :
673  scs(check,"fCompress");
674  scs(check,"Int_t");
675 
676  scs(check,"fBasketSize");
677  scs(check,"Int_t");
678 
679  scs(check,"fEntryOffsetLen");
680  scs(check,"Int_t");
681 
682  scs(check,"fWriteBasket");
683  scs(check,"Int_t");
684 
685  scs(check,"fEntryNumber");
686  scs(check,"Int_t");
687 
688  scs(check,"fOffset");
689  scs(check,"Int_t");
690 
691  scs(check,"fMaxBaskets");
692  scs(check,"Int_t");
693 
694  scs(check,"fSplitLevel");
695  scs(check,"Int_t");
696 
697  scs(check,"fEntries");
698  scs(check,"Stat_t");
699 
700  scs(check,"fTotBytes");
701  scs(check,"Stat_t");
702 
703  scs(check,"fZipBytes");
704  scs(check,"Stat_t");
705 
706  scs(check,"fBranches");
707  scs(check,"TObjArray");
708 
709  scs(check,"fLeaves");
710  scs(check,"TObjArray");
711 
712  scs(check,"fBaskets");
713  scs(check,"TObjArray");
714 
715  scs(check,"fBasketBytes");
716  scs(check,"Int_t*");
717 
718  scs(check,"fBasketEntry");
719  scs(check,"Int_t*");
720 
721  scs(check,"fBasketSeek");
722  scs(check,"Seek_t*");
723 
724  scs(check,"fFileName");
725  scs(check,"TString");
726  //Should be : 2056727376U (6 3.00.06)
727  //Should be : FIXME (7 3.03.01)
728 
729  streamer_info* info = new streamer_info("TBranch",8,check);
730  a_infos.push_back(info);
731  // Elements :
732  int ofs = 0;
733  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",ofs,TNamed_version));ofs += size_TNamed();
734  info->add(new streamer_base("TAttFill","Fill area attributes",ofs,TAttFill_version));ofs += size_TAttFill();
735  info->add(new streamer_int(ofs,"fCompress","(=1 branch is compressed, 0 otherwise)"));
736  info->add(new streamer_int(ofs,"fBasketSize","Initial Size of Basket Buffer"));
737  info->add(new streamer_int(ofs,"fEntryOffsetLen","Initial Length of fEntryOffset table in the basket buffers"));
738  info->add(new streamer_int(ofs,"fWriteBasket","Last basket number written"));
739  info->add(new streamer_int(ofs,"fEntryNumber","Current entry number (last one filled in this branch)"));
740  info->add(new streamer_int(ofs,"fOffset","Offset of this branch"));
741  info->add(new streamer_basic_type("fMaxBaskets","Maximum number of Baskets so far",ofs,streamer__info::COUNTER,"Int_t"));ofs += size_COUNTER;
742  info->add(new streamer_int(ofs,"fSplitLevel","Branch split level")); //3.03.01
743  ofs += size_INT;
744  ofs += size_INT;
745  ofs += size_INT;
746  info->add(new streamer_stat_t(ofs,"fEntries","Number of entries"));
747  info->add(new streamer_stat_t(ofs,"fTotBytes","Total number of bytes in all leaves before compression"));
748  info->add(new streamer_stat_t(ofs,"fZipBytes","Total number of bytes in all leaves after compression"));
749  info->add(new streamer_object("fBranches","-> List of Branches of this branch",ofs,"TObjArray"));ofs += size_TObjArray;
750  info->add(new streamer_object("fLeaves","-> List of leaves of this branch",ofs,"TObjArray"));ofs += size_TObjArray;
751  info->add(new streamer_object("fBaskets","-> List of baskets of this branch",ofs,"TObjArray"));ofs += size_TObjArray;
752  ofs += size_INT;
753  ofs += size_POINTER;
754  info->add(new streamer_basic_pointer("fBasketBytes","[fMaxBaskets] Length of baskets on file",ofs,streamer__info::INT,"fMaxBaskets","TBranch",6,"Int_t*"));ofs += size_POINTER;
755  info->add(new streamer_basic_pointer("fBasketEntry","[fMaxBaskets] Table of first entry in eack basket",ofs,streamer__info::INT,"fMaxBaskets","TBranch",6,"Int_t*"));ofs += size_POINTER;
756  info->add(new streamer_basic_pointer("fBasketSeek","[fMaxBaskets] Addresses of baskets on file",ofs,streamer__info::INT,"fMaxBaskets","TBranch",6,"Seek_t*"));ofs += size_POINTER;
757  ofs += size_POINTER;
758  ofs += size_POINTER;
759  ofs += size_POINTER;
760  info->add(new streamer_string(ofs,"fFileName","Name of file where buffers are stored (\"\" if in same file as Tree header)"));
761  if(ofs!=size_TBranch()) {
762  a_out << "tools::wroot::fill_infos :"
763  << " TBranch " << ofs << " (" << size_TBranch() << " expected.)"
764  << std::endl;
765  }}
766 
767  {unsigned int check = 0;
768  //this :
769  scs(check,"TBranchObject");
770  //bases :
771  scs(check,"TBranch");
772  //members :
773  scs(check,"fClassName");
774  scs(check,"TString");
775 
776  //Should be : 2857878535U
777 
778  streamer_info* info = new streamer_info("TBranchObject",1,check);
779  a_infos.push_back(info);
780  // Elements :
781  int ofs = 0;
782  info->add(new streamer_base("TBranch","Branch descriptor",ofs,TBranch_version));ofs += size_TBranch();
783  info->add(new streamer_string(ofs,"fClassName","Class name of referenced object"));
784  }
785 
786  //---------------------------------------------------------------------
787  {unsigned int check = 0;
788  //this :
789  scs(check,"TBranchElement");
790  //bases :
791  scs(check,"TBranch");
792  //members :
793  scs(check,"fClassName");
794  scs(check,"TString");
795 
796  scs(check,"fClassVersion");
797  scs(check,"Int_t");
798 
799  scs(check,"fID");
800  scs(check,"Int_t");
801 
802  scs(check,"fType");
803  scs(check,"Int_t");
804 
805  scs(check,"fStreamerType");
806  scs(check,"Int_t");
807 
808  streamer_info* info = new streamer_info("TBranchElement",1,check);
809  a_infos.push_back(info);
810  // Elements :
811  int offset = 0;
812  info->add(new streamer_base("TBranch","Branch descriptor",offset,TBranch_version));offset += size_TBranch();
813  info->add(new streamer_string(offset,"fClassName","Class name of referenced object"));
814  info->add(new streamer_int(offset,"fClassVersion","Version number of class"));
815  info->add(new streamer_int(offset,"fID","element serial number in fInfo"));
816  info->add(new streamer_int(offset,"fType","branch type"));
817  info->add(new streamer_int(offset,"fStreamerType","branch streamer type"));
818 
819  }
820 
821  {unsigned int check = 0;
822  //this :
823  scs(check,"TLeaf");
824  //bases :
825  scs(check,"TNamed");
826  //members :
827  scs(check,"fLen");
828  scs(check,"Int_t");
829 
830  scs(check,"fLenType");
831  scs(check,"Int_t");
832 
833  scs(check,"fOffset");
834  scs(check,"Int_t");
835 
836  scs(check,"fIsRange");
837  scs(check,"Bool_t");
838 
839  scs(check,"fIsUnsigned");
840  scs(check,"Bool_t");
841 
842  scs(check,"fLeafCount");
843  scs(check,"TLeaf*");
844 
845  //Should be : 727988519U
846 
847  streamer_info* info = new streamer_info("TLeaf",2,check);
848  a_infos.push_back(info);
849 
850  // Elements :
851  int ofs = 0;
852  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",ofs,TNamed_version));ofs += size_TNamed();
853  ofs += size_INT;
854  info->add(new streamer_int(ofs,"fLen","Number of fixed length elements"));
855  info->add(new streamer_int(ofs,"fLenType","Number of bytes for this data type"));
856  info->add(new streamer_int(ofs,"fOffset","Offset in ClonesArray object (if one)"));
857  info->add(new streamer_bool(ofs,"fIsRange","(=kTRUE if leaf has a range, kFALSE otherwise)"));
858  info->add(new streamer_bool(ofs,"fIsUnsigned","(=kTRUE if unsigned, kFALSE otherwise)"));
859  info->add(new streamer_object_pointer("fLeafCount","Pointer to Leaf count if variable length",ofs,"TLeaf*"));ofs += size_POINTER;
860  ofs += size_POINTER;
861  if(ofs!=size_TLeaf()) {
862  a_out << "tools::wroot::fill_infos :"
863  << " TLeaf " << ofs << " (" << size_TLeaf() << " expected.)"
864  << std::endl;
865  }}
866 
867  {unsigned int check = 0;
868  //this :
869  scs(check,"TLeafS");
870  //bases :
871  scs(check,"TLeaf");
872  //members :
873  scs(check,"fMinimum");
874  scs(check,"Short_t");
875 
876  scs(check,"fMaximum");
877  scs(check,"Short_t");
878 
879  //Should be : FIXME
880 
881  streamer_info* info = new streamer_info("TLeafS",1,check);
882  a_infos.push_back(info);
883  // Elements :
884  int ofs = 0;
885  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",ofs,TLeaf_version));ofs += size_TLeaf();
886  info->add(new streamer_short(ofs,"fMinimum","Minimum value if leaf range is specified"));
887  info->add(new streamer_short(ofs,"fMaximum","Maximum value if leaf range is specified"));
888 
889  }
890 
891  {unsigned int check = 0;
892  //this :
893  scs(check,"TLeafI");
894  //bases :
895  scs(check,"TLeaf");
896  //members :
897  scs(check,"fMinimum");
898  scs(check,"Int_t");
899 
900  scs(check,"fMaximum");
901  scs(check,"Int_t");
902 
903  //Should be : 3495201397U
904 
905  streamer_info* info = new streamer_info("TLeafI",1,check);
906  a_infos.push_back(info);
907 
908  // Elements :
909  int ofs = 0;
910  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",ofs,TLeaf_version));ofs += size_TLeaf();
911  info->add(new streamer_int(ofs,"fMinimum","Minimum value if leaf range is specified"));
912  info->add(new streamer_int(ofs,"fMaximum","Maximum value if leaf range is specified"));
913  //size_TLeafI = ofs;
914  }
915 
916  {unsigned int check = 0;
917  //name :
918  scs(check,"TLeafF");
919  //bases :
920  scs(check,"TLeaf");
921  //members :
922  scs(check,"fMinimum");
923  scs(check,"Float_t");
924 
925  scs(check,"fMaximum");
926  scs(check,"Float_t");
927 
928  //Should be 1366318032U
929 
930  streamer_info* info = new streamer_info("TLeafF",1,check);
931  a_infos.push_back(info);
932 
933  // Elements :
934  int ofs = 0;
935  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",ofs,TLeaf_version));ofs += size_TLeaf();
936  info->add(new streamer_float(ofs,"fMinimum","Minimum value if leaf range is specified"));
937  info->add(new streamer_float(ofs,"fMaximum","Maximum value if leaf range is specified"));
938  //size_TLeafF = ofs;
939  }
940 
941  {unsigned int check = 0;
942  //this :
943  scs(check,"TLeafD");
944  //bases :
945  scs(check,"TLeaf");
946  //members :
947  scs(check,"fMinimum");
948  scs(check,"Double_t");
949 
950  scs(check,"fMaximum");
951  scs(check,"Double_t");
952 
953  //Should be
954 
955  streamer_info* info = new streamer_info("TLeafD",1,check);
956  a_infos.push_back(info);
957 
958  // Elements :
959  int ofs = 0;
960  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",ofs,TLeaf_version));ofs += size_TLeaf();
961  info->add(new streamer_double(ofs,"fMinimum","Minimum value if leaf range is specified"));
962  info->add(new streamer_double(ofs,"fMaximum","Maximum value if leaf range is specified"));
963 
964  }
965 
966  {unsigned int check = 0;
967  //this :
968  scs(check,"TLeafB");
969  //bases :
970  scs(check,"TLeaf");
971  //members :
972  scs(check,"fMinimum");
973  scs(check,"Char_t");
974 
975  scs(check,"fMaximum");
976  scs(check,"Char_t");
977 
978  //Should be : FIXME
979 
980  streamer_info* info = new streamer_info("TLeafB",1,check);
981  a_infos.push_back(info);
982  // Elements :
983  int ofs = 0;
984  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",ofs,TLeaf_version));ofs += size_TLeaf();
985  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",ofs,streamer__info::CHAR,"Char_t"));ofs += size_CHAR;
986  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",ofs,streamer__info::CHAR,"Char_t"));ofs += size_CHAR;
987 
988  }
989 
990  {unsigned int check = 0;
991  //this :
992  scs(check,"TLeafC");
993  //bases :
994  scs(check,"TLeaf");
995  //members :
996  scs(check,"fMinimum");
997  scs(check,"Int_t");
998 
999  scs(check,"fMaximum");
1000  scs(check,"Int_t");
1001 
1002  //Should be : FIXME
1003 
1004  streamer_info* info = new streamer_info("TLeafC",1,check);
1005  a_infos.push_back(info);
1006 
1007  // Elements :
1008  int ofs = 0;
1009  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",ofs,TLeaf_version));ofs += size_TLeaf();
1010  info->add(new streamer_int(ofs,"fMinimum","Minimum value if leaf range is specified"));
1011  info->add(new streamer_int(ofs,"fMaximum","Maximum value if leaf range is specified"));}
1012 
1013  {unsigned int check = 0;
1014  //this :
1015  scs(check,"TLeafObject");
1016  //bases :
1017  scs(check,"TLeaf");
1018  //members :
1019  scs(check,"fVirtual");
1020  scs(check,"Bool_t");
1021 
1022  //Should be 2312661809U
1023 
1024  streamer_info* info = new streamer_info("TLeafObject",4,check);
1025  a_infos.push_back(info);
1026 
1027  // Elements :
1028  int ofs = 0;
1029  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",ofs,TLeaf_version));ofs += size_TLeaf();
1030  info->add(new streamer_bool(ofs,"fVirtual","Support for Virtuality"));}
1031 
1032  {unsigned int check = 0;
1033  //this :
1034  scs(check,"TLeafElement");
1035  //bases :
1036  scs(check,"TLeaf");
1037  //members :
1038  scs(check,"fID");
1039  scs(check,"Int_t");
1040 
1041  scs(check,"fType");
1042  scs(check,"Int_t");
1043 
1044  streamer_info* info = new streamer_info("TLeafElement",1,check);
1045  a_infos.push_back(info);
1046 
1047  // Elements :
1048  int ofs = 0;
1049  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",ofs,TLeaf_version));ofs += size_TLeaf();
1050  ofs += size_POINTER;
1051  info->add(new streamer_int(ofs,"fID","element serial number in fInfo"));
1052  info->add(new streamer_int(ofs,"fType","leaf type"));
1053  //size_TLeafElement = ofs;
1054  }
1055 
1056 }

◆ fill_vec()

void tools::wroot::fill_vec ( obj_list< streamer_info > &  a_infos,
const std::string &  a_type,
streamer__info::Type  a_si_type 
)
inline

Definition at line 21 of file infos.

21  {
22  unsigned int check = 196608;
23  streamer_info* info = new streamer_info(std::string("vector<")+a_type+">",4,check);
24  a_infos.push_back(info);
25  info->add(new streamer_STL("This","Used to call the proper TStreamerInfo case",0,a_si_type,std::string("vector<")+a_type+">"));
26 }

◆ find_after()

free_seg* tools::wroot::find_after ( const std::list< free_seg * > &  a_list,
free_seg *  a_what 
)
inline

Definition at line 96 of file free_seg.

96  {
97  tools_lforcit(free_seg*,a_list,it) {
98  if((*it)==a_what) {
99  it++;
100  if(it==a_list.end()) return 0;
101  return *it;
102  }
103  }
104  return 0;
105 }

◆ get_date()

date tools::wroot::get_date ( )
inline

Definition at line 19 of file date.

19  {
20  // Set Date/Time to current time as reported by the system.
21  // Date and Time are encoded into one single unsigned 32 bit word.
22  // Date is stored with the origin being the 1st january 1995.
23  // Time has 1 second precision.
24  time_t tloc = ::time(0);
25 #ifdef _MSC_VER
26  struct tm *tp = (tm*)::localtime(&tloc); //not thread safe (but exist on Windows).
27 #else
28  struct tm tpa;
29  struct tm *tp = (tm*)::localtime_r(&tloc, &tpa); //does not exist on Windows.
30 #endif
31  unsigned int year = tp->tm_year;
32  unsigned int month = tp->tm_mon + 1;
33  unsigned int day = tp->tm_mday;
34  unsigned int hour = tp->tm_hour;
35  unsigned int min = tp->tm_min;
36  unsigned int sec = tp->tm_sec;
37  return ((year-95)<<26 | month<<22 | day<<17 | hour<<12 | min<<6 | sec);
38 }

◆ leaf_element_cid()

cid tools::wroot::leaf_element_cid ( )
inline

Definition at line 17 of file cids.

17 {return base_cid()+12;}

◆ leaf_element_store_class()

const std::string& tools::wroot::leaf_element_store_class ( )
inline

Definition at line 39 of file leaf.

39  {
40  static const std::string s_v("TLeafElement");
41  return s_v;
42 }

◆ leaf_object_cid()

cid tools::wroot::leaf_object_cid ( )
inline

Definition at line 18 of file cids.

18 {return base_cid()+13;}

◆ leaf_object_store_class()

const std::string& tools::wroot::leaf_object_store_class ( )
inline

Definition at line 43 of file leaf.

43  {
44  static const std::string s_v("TLeafObject");
45  return s_v;
46 }

◆ leaf_store_class() [1/5]

const std::string& tools::wroot::leaf_store_class ( char  )
inline

Definition at line 15 of file leaf.

15  {
16  static const std::string s_v("TLeafB");
17  return s_v;
18 }

◆ leaf_store_class() [2/5]

const std::string& tools::wroot::leaf_store_class ( double  )
inline

Definition at line 31 of file leaf.

31  {
32  static const std::string s_v("TLeafD");
33  return s_v;
34 }

◆ leaf_store_class() [3/5]

const std::string& tools::wroot::leaf_store_class ( float  )
inline

Definition at line 27 of file leaf.

27  {
28  static const std::string s_v("TLeafF");
29  return s_v;
30 }

◆ leaf_store_class() [4/5]

const std::string& tools::wroot::leaf_store_class ( int  )
inline

Definition at line 23 of file leaf.

23  {
24  static const std::string s_v("TLeafI");
25  return s_v;
26 }

◆ leaf_store_class() [5/5]

const std::string& tools::wroot::leaf_store_class ( short  )
inline

Definition at line 19 of file leaf.

19  {
20  static const std::string s_v("TLeafS");
21  return s_v;
22 }

◆ leaf_string_cid()

cid tools::wroot::leaf_string_cid ( )
inline

Definition at line 16 of file cids.

16 {return base_cid()+11;}

◆ leaf_string_store_class()

const std::string& tools::wroot::leaf_string_store_class ( )
inline

Definition at line 35 of file leaf.

35  {
36  static const std::string s_v("TLeafC");
37  return s_v;
38 }

◆ List_empty_stream()

bool tools::wroot::List_empty_stream ( buffer &  a_buffer)
inline

Definition at line 102 of file streamers.

102  {
103  unsigned int beg;
104  if(!a_buffer.write_version(4,beg)) return false;
105  if(!Object_stream(a_buffer)) return false;
106  std::string name;
107  if(!a_buffer.write(name)) return false;
108  int nobjects = 0;
109  if(!a_buffer.write(nobjects)) return false;
110  if(!a_buffer.set_byte_count(beg)) return false;
111  return true;
112 }

◆ mpi_create_basket()

basket* tools::wroot::mpi_create_basket ( std::ostream &  a_out,
impi &  a_mpi,
bool  a_byte_swap,
seek  a_seek_directory,
uint32  a_basket_size 
)
inline

Definition at line 13 of file mpi_create_basket.

13  {
14  std::string oname;
15  if(!a_mpi.sunpack(oname)) return 0;
16  std::string otitle;
17  if(!a_mpi.sunpack(otitle)) return 0;
18 
19  uint32 last,nev_buf_size,nev;
20  if(!a_mpi.unpack(last)) return 0;
21  if(!a_mpi.unpack(nev_buf_size)) return 0;
22  if(!a_mpi.unpack(nev)) return 0;
23 
24  int* entry_offset = 0;
25  {bool not_null;
26  if(!a_mpi.bunpack(not_null)) return 0;
27  if(not_null) {
28  uint32 n;
29  if(!a_mpi.unpack(n,entry_offset)) return 0;
30  }}
31 
32  int* displacement = 0;
33  {bool not_null;
34  if(!a_mpi.bunpack(not_null)) {delete [] entry_offset;return 0;}
35  if(not_null) {
36  uint32 n;
37  if(!a_mpi.unpack(n,displacement)) {delete [] entry_offset;return 0;}
38  }}
39 
40  uint32 _size;
41  char* _buffer;
42  if(!a_mpi.unpack(_size,_buffer)) {
43  a_out << "unpack(buffer) failed."<< std::endl;
44  delete [] entry_offset;
45  delete [] displacement;
46  return 0;
47  }
48 
49  // wbasket fields set at file writing :
50  //m_buf_size,m_buffer,m_nbytes,m_object_size,m_date,m_cycle,m_seek_key
51 
52  //::printf("debug : col = %d, %s, %s, %lu\n",
53  // icol,rbasket.object_class().c_str(),rbasket.object_name().c_str(),rbasket.seek_key());
54 
55  basket* _basket = new basket(a_out,a_byte_swap,a_seek_directory,
56  oname,otitle,"TBasket",a_basket_size,
57  false/*verbose*/);
58  _basket->datbuf().write_fast_array(_buffer,_size);
59  _basket->set_nev(last,nev_buf_size,nev,entry_offset,displacement);
60 
61  delete [] entry_offset;
62  delete [] displacement;
63 
64  delete [] _buffer;
65 
66  return _basket;
67 }

◆ mpi_pack_basket()

bool tools::wroot::mpi_pack_basket ( impi &  a_mpi,
uint32  a_icol,
const basket &  a_basket 
)
inline

Definition at line 14 of file mpi_send_basket.

14  {
15  if(!a_mpi.pack(a_icol)) return false;
16 
17  if(!a_mpi.spack(a_basket.object_name())) return false;
18  if(!a_mpi.spack(a_basket.object_title())) return false;
19 
20  if(!a_mpi.pack(a_basket.last())) return false;
21  if(!a_mpi.pack(a_basket.nev_buf_size())) return false;
22  if(!a_mpi.pack(a_basket.nev())) return false;
23 
24  if(a_basket.entry_offset()) {
25  if(!a_mpi.bpack(true)) return false;
26  if(!a_mpi.pack(a_basket.nev_buf_size(),a_basket.entry_offset())) return false;
27  } else {
28  if(!a_mpi.bpack(false)) return false;
29  }
30 
31  if(a_basket.displacement()) {
32  if(!a_mpi.bpack(true)) return false;
33  if(!a_mpi.pack(a_basket.nev_buf_size(),a_basket.displacement())) return false;
34  } else {
35  if(!a_mpi.bpack(false)) return false;
36  }
37 
38  if(!a_mpi.pack(a_basket.datbuf().length(),a_basket.datbuf().buf())) return false;
39  return true;
40 }

◆ mpi_protocol_basket()

uint32 tools::wroot::mpi_protocol_basket ( )
inline

Definition at line 12 of file mpi_protocol.

12 {return 1;}

◆ mpi_protocol_baskets()

uint32 tools::wroot::mpi_protocol_baskets ( )
inline

Definition at line 13 of file mpi_protocol.

13 {return 2;}

◆ mpi_protocol_end_fill()

uint32 tools::wroot::mpi_protocol_end_fill ( )
inline

Definition at line 14 of file mpi_protocol.

14 {return 3;}

◆ mpi_send_basket()

bool tools::wroot::mpi_send_basket ( impi &  a_mpi,
int  a_dest,
int  a_tag,
uint32  a_id,
uint32  a_icol,
const basket &  a_basket 
)
inline

Definition at line 42 of file mpi_send_basket.

42  {
43  a_mpi.pack_reset();
44  if(!a_mpi.pack(mpi_protocol_basket())) return false;
45  if(!a_mpi.pack(a_id)) return false;
46  if(!mpi_pack_basket(a_mpi,a_icol,a_basket)) return false;
47  return a_mpi.send_buffer(a_dest,a_tag);
48 }

◆ Named_stream()

bool tools::wroot::Named_stream ( buffer &  a_buffer,
const std::string &  a_name,
const std::string &  a_title 
)
inline

Definition at line 23 of file named.

23  {
24  unsigned int beg;
25  if(!a_buffer.write_version(1,beg)) return false;
26  if(!Object_stream(a_buffer)) return false;
27  if(!a_buffer.write(a_name)) return false;
28  if(!a_buffer.write(a_title)) return false;
29  if(!a_buffer.set_byte_count(beg)) return false;
30  return true;
31 }

◆ Object_stream()

bool tools::wroot::Object_stream ( buffer &  a_buffer)
inline

Definition at line 14 of file named.

14  {
15  short v = 1;
16  if(!a_buffer.write_version(v)) return false;
17  if(!a_buffer.write((unsigned int)0)) return false;
18  static const unsigned int kNotDeleted = 0x02000000;
19  if(!a_buffer.write(kNotDeleted)) return false;
20  return true;
21 }

◆ remove()

void tools::wroot::remove ( std::list< free_seg * > &  a_list,
free_seg *  a_what 
)
inline

Definition at line 107 of file free_seg.

107  {
108  //NOTE : it does not delete a_what.
109  tools_lforit(free_seg*,a_list,it) {
110  if((*it)==a_what) {
111  a_list.erase(it);
112  return;
113  }
114  }
115 }

◆ scs()

void tools::wroot::scs ( unsigned int &  a_cs,
const std::string &  a_s 
)
inline

Definition at line 12 of file infos.

12  {
13  size_t l = a_s.size();
14  for(size_t i=0;i<l;i++) a_cs = a_cs*3+a_s[i];
15 }

◆ size_TAttAxis()

int tools::wroot::size_TAttAxis ( )
inline

Definition at line 1058 of file infos.

1058 {return 38;} //40?

◆ size_TAttFill()

int tools::wroot::size_TAttFill ( )
inline

Definition at line 438 of file infos.

438 {return 8;}

◆ size_TAttLine()

int tools::wroot::size_TAttLine ( )
inline

Definition at line 437 of file infos.

437 {return 10;} //12?

◆ size_TAttMarker()

int tools::wroot::size_TAttMarker ( )
inline

Definition at line 439 of file infos.

439 {return 12;}

◆ size_TAxis()

int tools::wroot::size_TAxis ( )
inline

Definition at line 1059 of file infos.

1059 {return 126;} //128?

◆ size_TBranch()

int tools::wroot::size_TBranch ( )
inline

Definition at line 535 of file infos.

535 {return 264;} //256?

◆ size_TH1()

int tools::wroot::size_TH1 ( )
inline

Definition at line 1060 of file infos.

1060 {return 560;} //568?

◆ size_TH2()

int tools::wroot::size_TH2 ( )
inline

Definition at line 1061 of file infos.

1061 {return 592;} //600?

◆ size_TH2D()

int tools::wroot::size_TH2D ( )
inline

Definition at line 1062 of file infos.

1062 {return 604;} //612?

◆ size_TLeaf()

int tools::wroot::size_TLeaf ( )
inline

Definition at line 536 of file infos.

536 {return 60;} //52?

◆ size_TNamed()

int tools::wroot::size_TNamed ( )
inline

Definition at line 31 of file infos.

31 {return 28;}

◆ size_TObject()

int tools::wroot::size_TObject ( )
inline

Definition at line 30 of file infos.

30 {return 12;}

◆ size_TTree()

int tools::wroot::size_TTree ( )
inline

Definition at line 537 of file infos.

537 {return 254;} //240?

◆ size_VIRTUAL()

int tools::wroot::size_VIRTUAL ( )
inline

Definition at line 28 of file infos.

28 {return 4;}

◆ START_BIG_FILE()

uint32 tools::wroot::START_BIG_FILE ( )
inline

Definition at line 19 of file seek.

19 {return 2000000000;}

◆ TH1D_stream()

bool tools::wroot::TH1D_stream ( buffer &  a_buffer,
const histo::h1d &  a_h,
const std::string &  a_name 
)
inline

Definition at line 285 of file streamers.

285  {
286  if(!a_buffer.write_version(1)) return false;
287  if(!TH_write_1D(a_buffer,a_h,a_name,a_h.bins_sum_w2())) return false;
288  if(!a_buffer.write_array(a_h.bins_sum_w())) return false; //fArray TArrayD
289  return true;
290 }

◆ TH1F_stream() [1/2]

bool tools::wroot::TH1F_stream ( buffer &  a_buffer,
const histo::h1d &  a_h,
const std::string &  a_name 
)
inline

Definition at line 276 of file streamers.

276  {
277  if(!a_buffer.write_version(1)) return false;
278  if(!TH_write_1D(a_buffer,a_h,a_name,a_h.bins_sum_w2())) return false;
279  std::vector<float> bins_sum_wf;
280  convert<double,float>(a_h.bins_sum_w(),bins_sum_wf);
281  if(!a_buffer.write_array(bins_sum_wf)) return false;
282  return true;
283 }

◆ TH1F_stream() [2/2]

bool tools::wroot::TH1F_stream ( buffer &  a_buffer,
const histo::h1df &  a_h,
const std::string &  a_name 
)
inline

Definition at line 267 of file streamers.

267  {
268  if(!a_buffer.write_version(1)) return false;
269  std::vector<double> bins_sum_w2d;
270  convert<float,double>(a_h.bins_sum_w2(),bins_sum_w2d);
271  if(!TH_write_1D(a_buffer,a_h,a_name,bins_sum_w2d)) return false;
272  if(!a_buffer.write_array(a_h.bins_sum_w())) return false;
273  return true;
274 }

◆ TH2D_stream()

bool tools::wroot::TH2D_stream ( buffer &  a_buffer,
const histo::h2d &  a_h,
const std::string &  a_name 
)
inline

Definition at line 310 of file streamers.

310  {
311  if(!a_buffer.write_version(3)) return false;
312  if(!TH_write_2D(a_buffer,a_h,a_name,a_h.bins_sum_w2())) return false;
313  if(!a_buffer.write_array(a_h.bins_sum_w())) return false; //fArray TArrayD
314  return true;
315 }

◆ TH2F_stream() [1/2]

bool tools::wroot::TH2F_stream ( buffer &  a_buffer,
const histo::h2d &  a_h,
const std::string &  a_name 
)
inline

Definition at line 292 of file streamers.

292  {
293  if(!a_buffer.write_version(3)) return false;
294  if(!TH_write_2D(a_buffer,a_h,a_name,a_h.bins_sum_w2())) return false;
295  std::vector<float> bins_sum_wf;
296  convert<double,float>(a_h.bins_sum_w(),bins_sum_wf);
297  if(!a_buffer.write_array(bins_sum_wf)) return false; //fArray TArrayF
298  return true;
299 }

◆ TH2F_stream() [2/2]

bool tools::wroot::TH2F_stream ( buffer &  a_buffer,
const histo::h2df &  a_h,
const std::string &  a_name 
)
inline

Definition at line 301 of file streamers.

301  {
302  if(!a_buffer.write_version(3)) return false;
303  std::vector<double> bins_sum_w2d;
304  convert<float,double>(a_h.bins_sum_w2(),bins_sum_w2d);
305  if(!TH_write_2D(a_buffer,a_h,a_name,bins_sum_w2d)) return false;
306  if(!a_buffer.write_array(a_h.bins_sum_w())) return false;
307  return true;
308 }

◆ TH3D_stream()

bool tools::wroot::TH3D_stream ( buffer &  a_buffer,
const histo::h3d &  a_h,
const std::string &  a_name 
)
inline

Definition at line 335 of file streamers.

335  {
336  if(!a_buffer.write_version(3)) return false;
337  if(!TH_write_3D(a_buffer,a_h,a_name,a_h.bins_sum_w2())) return false;
338  if(!a_buffer.write_array(a_h.bins_sum_w())) return false; //fArray TArrayD
339  return true;
340 }

◆ TH3F_stream() [1/2]

bool tools::wroot::TH3F_stream ( buffer &  a_buffer,
const histo::h3d &  a_h,
const std::string &  a_name 
)
inline

Definition at line 317 of file streamers.

317  {
318  if(!a_buffer.write_version(3)) return false;
319  if(!TH_write_3D(a_buffer,a_h,a_name,a_h.bins_sum_w2())) return false;
320  std::vector<float> bins_sum_wf;
321  convert<double,float>(a_h.bins_sum_w(),bins_sum_wf);
322  if(!a_buffer.write_array(bins_sum_wf)) return false; //fArray TArrayF
323  return true;
324 }

◆ TH3F_stream() [2/2]

bool tools::wroot::TH3F_stream ( buffer &  a_buffer,
const histo::h3df &  a_h,
const std::string &  a_name 
)
inline

Definition at line 326 of file streamers.

326  {
327  if(!a_buffer.write_version(3)) return false;
328  std::vector<double> bins_sum_w2d;
329  convert<float,double>(a_h.bins_sum_w2(),bins_sum_w2d);
330  if(!TH_write_3D(a_buffer,a_h,a_name,bins_sum_w2d)) return false;
331  if(!a_buffer.write_array(a_h.bins_sum_w())) return false; //fArray TArrayF
332  return true;
333 }

◆ TH_write_1D()

template<class HIST >
bool tools::wroot::TH_write_1D ( buffer &  a_buffer,
const HIST &  a_h,
const std::string &  a_name,
const std::vector< double > &  a_bin_Sw2 
)
inline

Definition at line 123 of file streamers.

126  {
127 
128  if(!a_buffer.write_version(3)) return false;
129 
130  if(!Named_stream(a_buffer,a_name,a_h.title())) return false;
131 
132  if(!AttLine_stream(a_buffer)) return false;
133  if(!AttFill_stream(a_buffer)) return false;
134  if(!AttMarker_stream(a_buffer)) return false;
135 
136  if(!a_buffer.write((int)a_h.get_bins())) return false;
137 
138  //fXAxis,fYAxis,fZAxis
139  if(a_h.dimension()==3) {
140 
141  {histo::axis<double,unsigned int> haxis(a_h.get_axis(0));
142  if(!axis_stream(a_buffer,haxis,"xaxis",axis_title(a_h,histo::key_axis_x_title()))) return false;}
143 
144  {histo::axis<double,unsigned int> haxis(a_h.get_axis(1));
145  if(!axis_stream(a_buffer,haxis,"yaxis",axis_title(a_h,histo::key_axis_y_title()))) return false;}
146 
147  {histo::axis<double,unsigned int> haxis(a_h.get_axis(2));
148  if(!axis_stream(a_buffer,haxis,"zaxis",axis_title(a_h,histo::key_axis_z_title()))) return false;}
149 
150  } else if(a_h.dimension()==2) {
151 
152  {histo::axis<double,unsigned int> haxis(a_h.get_axis(0));
153  if(!axis_stream(a_buffer,haxis,"xaxis",axis_title(a_h,histo::key_axis_x_title()))) return false;}
154 
155  {histo::axis<double,unsigned int> haxis(a_h.get_axis(1));
156  if(!axis_stream(a_buffer,haxis,"yaxis",axis_title(a_h,histo::key_axis_y_title()))) return false;}
157 
158  {histo::axis<double,unsigned int> dummy;
159  dummy.configure(1,0,1);
160  if(!axis_stream(a_buffer,dummy,"zaxis",axis_title(a_h,histo::key_axis_z_title()))) return false;}
161 
162  } else if(a_h.dimension()==1) {
163 
164  {histo::axis<double,unsigned int> haxis(a_h.get_axis(0));
165  if(!axis_stream(a_buffer,haxis,"xaxis",axis_title(a_h,histo::key_axis_x_title()))) return false;}
166 
167  {histo::axis<double,unsigned int> dummy;
168  dummy.configure(1,0,1);
169  if(!axis_stream(a_buffer,dummy,"yaxis",axis_title(a_h,histo::key_axis_y_title()))) return false;}
170 
171  {histo::axis<double,unsigned int> dummy;
172  dummy.configure(1,0,1);
173  if(!axis_stream(a_buffer,dummy,"zaxis",axis_title(a_h,histo::key_axis_z_title()))) return false;}
174 
175  } else {
176  return false;
177  }
178 
179  if(!a_buffer.write((short)(1000 * 0.25))) return false; //fBarOffset
180  if(!a_buffer.write((short)(1000 * 0.5))) return false; //fBarWidth
181 
182  if(!a_buffer.write((double)a_h.all_entries())) return false;
183  if(!a_buffer.write((double)a_h.get_in_range_Sw())) return false; //enforce double in case h1df
184  if(!a_buffer.write((double)a_h.get_in_range_Sw2())) return false; //idem
185 
186  {double value;
187  a_h.get_ith_axis_Sxw(0,value);
188  if(!a_buffer.write(value)) return false;}
189 
190  {double value;
191  a_h.get_ith_axis_Sx2w(0,value);
192  if(!a_buffer.write(value)) return false;}
193 
194  if(!a_buffer.write((double)-1111)) return false; //fMaximum
195  if(!a_buffer.write((double)-1111)) return false; //fMinimum
196  if(!a_buffer.write((double)0)) return false; //NormFactor
197 
198  if(!a_buffer.write_array(std::vector<double>())) return false; //fContour TArrayD
199 
200  if(!a_buffer.write_array(a_bin_Sw2)) return false; //fSumw2 TArrayD
201 
202  // store annotation on fOption
203  // but try to fool CERN-ROOT in order that it does not
204  // understand fOption as.. CERN-ROOT options !
205  //{std::string opt = " "+fAnnotation;
206  // opt[0] = 0; //awfull trick
207  // if(!a_buffer.write(opt)) return false;} //TString fOption
208  {std::string opt;
209  if(!a_buffer.write(opt)) return false;} //TString fOption
210 
211  if(!List_empty_stream(a_buffer)) return false; //*TList fFunctions
212 
213  return true;
214 }

◆ TH_write_2D()

template<class HIST >
bool tools::wroot::TH_write_2D ( buffer &  a_buffer,
const HIST &  a_h,
const std::string &  a_name,
const std::vector< double > &  a_bin_Sw2 
)
inline

Definition at line 217 of file streamers.

220  {
221  if(!a_buffer.write_version(3)) return false;
222  if(!TH_write_1D(a_buffer,a_h,a_name,a_bin_Sw2)) return false;
223  if(!a_buffer.write((double)1)) return false; //ScaleFactor
224 
225  {double value;
226  a_h.get_ith_axis_Sxw(1,value);
227  if(!a_buffer.write(value)) return false;}
228 
229  {double value;
230  a_h.get_ith_axis_Sx2w(1,value);
231  if(!a_buffer.write(value)) return false;}
232 
233  if(!a_buffer.write((double)a_h.Sxyw())) return false; //Tsumwxy
234 
235  return true;
236 }

◆ TH_write_3D()

template<class HIST >
bool tools::wroot::TH_write_3D ( buffer &  a_buffer,
const HIST &  a_h,
const std::string &  a_name,
const std::vector< double > &  a_bin_Sw2 
)
inline

Definition at line 239 of file streamers.

242  {
243  if(!a_buffer.write_version(4)) return false;
244  if(!TH_write_1D(a_buffer,a_h,a_name,a_bin_Sw2)) return false;
245  if(!Att3D_stream(a_buffer)) return false;
246 
247  {double value;
248  a_h.get_ith_axis_Sxw(1,value);
249  if(!a_buffer.write(value)) return false;} //Tsumwy : Total Sum of weight*Y
250  {double value;
251  a_h.get_ith_axis_Sx2w(1,value);
252  if(!a_buffer.write(value)) return false;} //Tsumwy2 : Total Sum of weight*Y*Y
253  if(!a_buffer.write((double)a_h.Sxyw())) return false; //Tsumwxy : Total Sum of weight*X*Y
254 
255  {double value;
256  a_h.get_ith_axis_Sxw(2,value);
257  if(!a_buffer.write(value)) return false;} //Tsumwz : Total Sum of weight*Z
258  {double value;
259  a_h.get_ith_axis_Sx2w(2,value);
260  if(!a_buffer.write(value)) return false;} //Tsumwz2 : Total Sum of weight*Z*Z
261  if(!a_buffer.write((double)a_h.Szxw())) return false; //Tsumwxz : Total Sum of weight*X*Z
262  if(!a_buffer.write((double)a_h.Syzw())) return false; //Tsumwyz : Total Sum of weight*Y*Z
263 
264  return true;
265 }

◆ to() [1/9]

bool tools::wroot::to ( directory &  a_dir,
const histo::h1d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 35 of file to.

35  {
36  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,a_name,a_histo.title(),"TH1D");
37  if(!TH1D_stream(*bo,a_histo,a_name)) {
38  a_dir.file().out() << "tools::wroot::to : TH1D_stream failed." << std::endl;
39  delete bo;
40  return false;
41  }
42  a_dir.append_object(bo); //a_dir takes ownership of bo.
43  return true;
44 }

◆ to() [2/9]

bool tools::wroot::to ( directory &  a_dir,
const histo::h1df &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 46 of file to.

46  {
47  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,a_name,a_histo.title(),"TH1F");
48  if(!TH1F_stream(*bo,a_histo,a_name)) {
49  a_dir.file().out() << "tools::wroot::to : TH1F_stream failed." << std::endl;
50  delete bo;
51  return false;
52  }
53  a_dir.append_object(bo); //a_dir takes ownership of bo.
54  return true;
55 }

◆ to() [3/9]

bool tools::wroot::to ( directory &  a_dir,
const histo::h2d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 57 of file to.

57  {
58  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,a_name,a_histo.title(),"TH2D");
59  if(!TH2D_stream(*bo,a_histo,a_name)) {
60  a_dir.file().out() << "tools::wroot::to : TH2D_stream failed." << std::endl;
61  delete bo;
62  return false;
63  }
64  a_dir.append_object(bo); //a_dir takes ownership of bo.
65  return true;
66 }

◆ to() [4/9]

bool tools::wroot::to ( directory &  a_dir,
const histo::h2df &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 68 of file to.

68  {
69  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,a_name,a_histo.title(),"TH2F");
70  if(!TH2F_stream(*bo,a_histo,a_name)) {
71  a_dir.file().out() << "tools::wroot::to :"
72  << " TH2F_stream failed."
73  << std::endl;
74  delete bo;
75  return false;
76  }
77  a_dir.append_object(bo); //a_dir takes ownership of bo.
78  return true;
79 }

◆ to() [5/9]

bool tools::wroot::to ( directory &  a_dir,
const histo::h3d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 81 of file to.

81  {
82  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
83  a_name,a_histo.title(),"TH3D");
84  if(!TH3D_stream(*bo,a_histo,a_name)) {
85  a_dir.file().out() << "tools::wroot::to :"
86  << " TH3D_stream failed."
87  << std::endl;
88  delete bo;
89  return false;
90  }
91  a_dir.append_object(bo); //a_dir takes ownership of bo.
92  return true;
93 }

◆ to() [6/9]

bool tools::wroot::to ( directory &  a_dir,
const histo::h3df &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 95 of file to.

95  {
96  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,a_name,a_histo.title(),"TH3F");
97  if(!TH3F_stream(*bo,a_histo,a_name)) {
98  a_dir.file().out() << "tools::wroot::to :"
99  << " TH3F_stream failed."
100  << std::endl;
101  delete bo;
102  return false;
103  }
104  a_dir.append_object(bo); //a_dir takes ownership of bo.
105  return true;
106 }

◆ to() [7/9]

bool tools::wroot::to ( directory &  a_dir,
const histo::p1d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 108 of file to.

108  {
109  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
110  a_name,a_histo.title(),"TProfile");
111  if(!TProfile_stream(*bo,a_histo,a_name)) {
112  a_dir.file().out() << "tools::wroot::to :"
113  << " TProfile_stream failed."
114  << std::endl;
115  delete bo;
116  return false;
117  }
118  a_dir.append_object(bo); //a_dir takes ownership of bo.
119  return true;
120 }

◆ to() [8/9]

bool tools::wroot::to ( directory &  a_dir,
const histo::p2d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 122 of file to.

122  {
123  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
124  a_name,a_histo.title(),"TProfile2D");
125  if(!TProfile2D_stream(*bo,a_histo,a_name)) {
126  a_dir.file().out() << "tools::wroot::to :"
127  << " TProfile2D_stream failed."
128  << std::endl;
129  delete bo;
130  return false;
131  }
132  a_dir.append_object(bo); //a_dir takes ownership of bo.
133  return true;
134 }

◆ to() [9/9]

bool tools::wroot::to ( directory &  a_dir,
const std::map< std::string, std::string > &  a_annotations,
const std::string &  a_histo_name 
)
inline

Definition at line 15 of file to.

15  {
16  //if(a_annotations.empty()) return true;
17  std::string sas;
18  tools_mforcit(std::string,std::string,a_annotations,it) {
19  if(it!=a_annotations.begin()) sas += "\n";
20  sas += (*it).first;
21  sas += "\n";
22  sas += (*it).second;
23  }
24  std::string key_name = "annotations_"+a_histo_name;
25  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,key_name,"annotations","TNamed");
26  if(!Named_stream(*bo,a_histo_name,sas)) {
27  a_dir.file().out() << "tools::wroot::to : Named_stream failed." << std::endl;
28  delete bo;
29  return false;
30  }
31  a_dir.append_object(bo); //a_dir takes ownership of bo.
32  return true;
33 }

◆ to_osc() [1/5]

bool tools::wroot::to_osc ( directory &  a_dir,
const histo::h1d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 180 of file to.

180  {
181  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
182  a_name,a_histo.title(),osc::s_h1d());
183 
184  //Stream as in a BatchLab/Rio/Data.h :
185  if(!bo->write_version(1)) return false;
186  if(!Named_stream(*bo,a_name,a_histo.title())) return false;
187 
188  member_writer mw(*bo);
189  if(!osc::visit(mw,a_histo)) {
190  a_dir.file().out() << "tools::wroot::to_osc :"
191  << " Histogram1D_stream failed."
192  << std::endl;
193  delete bo;
194  return false;
195  }
196  a_dir.append_object(bo); //a_dir takes ownership of bo.
197  return true;
198 }

◆ to_osc() [2/5]

bool tools::wroot::to_osc ( directory &  a_dir,
const histo::h2d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 200 of file to.

200  {
201  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
202  a_name,a_histo.title(),osc::s_h2d());
203 
204  //Stream as in a BatchLab/Rio/Data.h :
205  if(!bo->write_version(1)) return false;
206  if(!Named_stream(*bo,a_name,a_histo.title())) return false;
207 
208  member_writer mw(*bo);
209  if(!osc::visit(mw,a_histo)) {
210  a_dir.file().out() << "tools::wroot::to_osc :"
211  << " Histogram2D_stream failed."
212  << std::endl;
213  delete bo;
214  return false;
215  }
216  a_dir.append_object(bo); //a_dir takes ownership of bo.
217  return true;
218 }

◆ to_osc() [3/5]

bool tools::wroot::to_osc ( directory &  a_dir,
const histo::h3d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 220 of file to.

220  {
221  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
222  a_name,a_histo.title(),osc::s_h3d());
223 
224  //Stream as in a BatchLab/Rio/Data.h :
225  if(!bo->write_version(1)) return false;
226  if(!Named_stream(*bo,a_name,a_histo.title())) return false;
227 
228  member_writer mw(*bo);
229  if(!osc::visit(mw,a_histo)) {
230  a_dir.file().out() << "tools::wroot::to_osc :"
231  << " Histogram3D_stream failed."
232  << std::endl;
233  delete bo;
234  return false;
235  }
236  a_dir.append_object(bo); //a_dir takes ownership of bo.
237  return true;
238 }

◆ to_osc() [4/5]

bool tools::wroot::to_osc ( directory &  a_dir,
const histo::p1d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 240 of file to.

240  {
241  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
242  a_name,a_histo.title(),osc::s_p1d());
243 
244  //Stream as in a BatchLab/Rio/Data.h :
245  if(!bo->write_version(1)) return false;
246  if(!Named_stream(*bo,a_name,a_histo.title())) return false;
247 
248  member_writer mw(*bo);
249  if(!osc::visit(mw,a_histo)) {
250  a_dir.file().out() << "tools::wroot::to_osc :"
251  << " Profile1D_stream failed."
252  << std::endl;
253  delete bo;
254  return false;
255  }
256  a_dir.append_object(bo); //a_dir takes ownership of bo.
257  return true;
258 }

◆ to_osc() [5/5]

bool tools::wroot::to_osc ( directory &  a_dir,
const histo::p2d &  a_histo,
const std::string &  a_name 
)
inline

Definition at line 260 of file to.

260  {
261  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
262  a_name,a_histo.title(),osc::s_p2d());
263 
264  //Stream as in a BatchLab/Rio/Data.h :
265  if(!bo->write_version(1)) return false;
266  if(!Named_stream(*bo,a_name,a_histo.title())) return false;
267 
268  member_writer mw(*bo);
269  if(!osc::visit(mw,a_histo)) {
270  a_dir.file().out() << "tools::wroot::to_osc :"
271  << " Profile2D_stream failed."
272  << std::endl;
273  delete bo;
274  return false;
275  }
276  a_dir.append_object(bo); //a_dir takes ownership of bo.
277  return true;
278 }

◆ TProfile2D_stream()

bool tools::wroot::TProfile2D_stream ( buffer &  a_buffer,
const histo::p2d &  a_p,
const std::string &  a_name 
)
inline

Definition at line 374 of file streamers.

374  {
375  if(!a_buffer.write_version(5)) return false;
376 
377  //WARNING : the mapping histo::p2d / TProfile2D is not obvious.
378  //p2d::m_bin_Svw <---> TProfile2D::fArray
379  //p2d::m_bin_Sv2w <---> TProfile2D::fSumw2
380  //p2d::m_bin_Sw <---> TProfile2D::fBinEntries
381 
382  // TH2D_stream(a_buffer,h,a_name) :
383  //if(!a_buffer.write_version(3)) return false;
384  //if(!TH_write_2D(a_buffer,a_h,a_name,a_h.bins_sum_w2())) return false; //fSumw2 TArrayD
385  //if(!a_buffer.write_array(a_h.bins_sum_w())) return false; //fArray TArrayD
386  // for profile :
387  if(!a_buffer.write_version(3)) return false;
388  if(!TH_write_2D(a_buffer,a_p,a_name,a_p.bins_sum_v2w())) return false; //fSumw2 TArrayD
389  if(!a_buffer.write_array(a_p.bins_sum_vw())) return false; //fArray TArrayD
390 
391  //TProfile2D specific :
392  if(!a_buffer.write_array(a_p.bins_sum_w())) return false; //fBinEntries TArrayD
393 
394  int errorMode = 0;
395  if(!a_buffer.write(errorMode)) return false; //fErrorMode
396  if(!a_buffer.write(a_p.min_v())) return false; //fZmin
397  if(!a_buffer.write(a_p.max_v())) return false; //fZmax
398 
399  // version 5 :
400  if(!a_buffer.write(a_p.get_Svw())) return false; //Double_t fTsumwz; //Total Sum of weight*Z
401  if(!a_buffer.write(a_p.get_Sv2w())) return false; //Double_t fTsumwz2; //Total Sum of weight*Z*Z
402 
403  return true;
404 }

◆ TProfile_stream()

bool tools::wroot::TProfile_stream ( buffer &  a_buffer,
const histo::p1d &  a_p,
const std::string &  a_name 
)
inline

Definition at line 342 of file streamers.

342  {
343  if(!a_buffer.write_version(4)) return false;
344 
345  //WARNING : the mapping histo::p1d / TProfile is not obvious.
346  //p1d::m_bin_Svw <---> TProfile::fArray
347  //p1d::m_bin_Sv2w <---> TProfile::fSumw2
348  //p1d::m_bin_Sw <---> TProfile::fBinEntries
349 
350  // TH1D_stream(a_buffer,h,a_name) :
351  //if(!a_buffer.write_version(1)) return false;
352  //if(!TH_write_1D(a_buffer,a_h,a_name,a_h.bins_sum_w2())) return false; //fSumw2 TArrayD
353  //if(!a_buffer.write_array(a_h.bins_sum_w())) return false; //fArray TArrayD
354  // but for profile :
355  if(!a_buffer.write_version(1)) return false;
356  if(!TH_write_1D(a_buffer,a_p,a_name,a_p.bins_sum_v2w())) return false; //fSumw2 TArrayD
357  if(!a_buffer.write_array(a_p.bins_sum_vw())) return false; //fArray TArrayD
358 
359  //TProfile specific :
360  if(!a_buffer.write_array(a_p.bins_sum_w())) return false; //fBinEntries TArrayD
361 
362  int errorMode = 0;
363  if(!a_buffer.write(errorMode)) return false;
364  if(!a_buffer.write(a_p.min_v())) return false;
365  if(!a_buffer.write(a_p.max_v())) return false;
366 
367  // version 4 :
368  if(!a_buffer.write(a_p.get_Svw())) return false; //Double_t fTsumwy; //Total Sum of weight*Y
369  if(!a_buffer.write(a_p.get_Sv2w())) return false; //Double_t fTsumwy2; //Total Sum of weight*Y*Y
370 
371  return true;
372 }

◆ write_histos()

bool tools::wroot::write_histos ( directory &  a_dir,
const std::vector< std::pair< std::string, void * > > &  a_hists 
)
inline

Definition at line 136 of file to.

136  {
137  typedef std::pair<std::string,void*> class_pointer;
138 
139  tools_vforcit(class_pointer,a_hists,it) {
140  const std::string& scls = (*it).first;
141  void* p = (*it).second;
142  if(scls==histo::h1d::s_class()) {
143  histo::h1d& h = *((histo::h1d*)p);
144  if(!to(a_dir,h,h.title())) return false;
145 
146  } else if(scls==histo::h2d::s_class()) {
147  histo::h2d& h = *((histo::h2d*)p);
148  if(!to(a_dir,h,h.title())) return false;
149 
150  } else if(scls==histo::h3d::s_class()) {
151  histo::h3d& h = *((histo::h3d*)p);
152  if(!to(a_dir,h,h.title())) return false;
153 
154  } else if(scls==histo::p1d::s_class()) {
155  histo::p1d& h = *((histo::p1d*)p);
156  if(!to(a_dir,h,h.title())) return false;
157 
158  } else if(scls==histo::p2d::s_class()) {
159  histo::p2d& h = *((histo::p2d*)p);
160  if(!to(a_dir,h,h.title())) return false;
161 
162  } else {
163  a_dir.file().out() << "tools::wroot::write_histos :"
164  << " WARNING : class " << scls << " not handled."
165  << std::endl;
166  }
167 
168  }
169  return true;
170 }
tools::rroot::AttMarker_stream
bool AttMarker_stream(buffer &a_buffer)
Definition: named:48
tools::wroot::streamer__info::size_BOOL
const int size_BOOL
Definition: element:47
tools::wroot::size_TLeaf
int size_TLeaf()
Definition: infos:536
tools::wroot::size_TAxis
int size_TAxis()
Definition: infos:1059
tools::osc::s_p2d
const std::string & s_p2d()
Definition: osc_streamers:61
tools::osc::visit
bool visit(iobj_const_visitor &a_v, const histo::h1d &a_histo)
Definition: osc_streamers:522
tools::wroot::streamer__info::size_SHORT
const int size_SHORT
Definition: element:46
tools::wroot::List_empty_stream
bool List_empty_stream(buffer &a_buffer)
Definition: streamers:102
tools::rroot::Object_stream
bool Object_stream(buffer &a_buffer, uint32 &a_id, uint32 &a_bits)
Definition: object:12
tools::rroot::TH2D_stream
histo::h2d * TH2D_stream(buffer &a_buffer)
Definition: streamers:523
tools::osc::s_h2d
const std::string & s_h2d()
Definition: osc_streamers:46
tools::osc::s_h3d
const std::string & s_h3d()
Definition: osc_streamers:51
tools::wroot::TH_write_3D
bool TH_write_3D(buffer &a_buffer, const HIST &a_h, const std::string &a_name, const std::vector< double > &a_bin_Sw2)
Definition: streamers:239
tools::wroot::TH3F_stream
bool TH3F_stream(buffer &a_buffer, const histo::h3d &a_h, const std::string &a_name)
Definition: streamers:317
tools::wroot::axis_stream
bool axis_stream(buffer &a_buffer, const histo::axis< double, unsigned int > &a_axis, const std::string &a_name, const std::string &a_title)
Definition: streamers:62
tools::wroot::fill_infos_graf
void fill_infos_graf(obj_list< streamer_info > &a_infos, std::ostream &a_out)
Definition: infos:441
tools::wroot::streamer__info::COUNTER
@ COUNTER
Definition: element:23
tools::wroot::streamer__info::size_INT
const int size_INT
Definition: element:44
tools::wroot::size_TObject
int size_TObject()
Definition: infos:30
tools::wroot::fill_vec
void fill_vec(obj_list< streamer_info > &a_infos, const std::string &a_type, streamer__info::Type a_si_type)
Definition: infos:21
tools::rroot::AttLine_stream
bool AttLine_stream(buffer &a_buffer, short &a_color, short &a_style, short &a_width)
Definition: named:27
tools::wroot::size_TAttMarker
int size_TAttMarker()
Definition: infos:439
tools::rroot::TH3D_stream
histo::h3d * TH3D_stream(buffer &a_buffer)
Definition: streamers:582
tools::wroot::remove
void remove(std::list< free_seg * > &a_list, free_seg *a_what)
Definition: free_seg:107
tools::rroot::Named_stream
bool Named_stream(buffer &a_buffer, std::string &a_name, std::string &a_title)
Definition: named:15
tools::wroot::fill_infos_core
void fill_infos_core(obj_list< streamer_info > &a_infos, std::ostream &a_out)
Definition: infos:33
tools::wroot::streamer__info::DOUBLE
@ DOUBLE
Definition: element:28
tools::rroot::TH2F_stream
histo::h2d * TH2F_stream(buffer &a_buffer)
Definition: streamers:461
tools::rroot::TH1F_stream
histo::h1d * TH1F_stream(buffer &a_buffer)
Definition: streamers:353
tools::wroot::streamer__info::SHORT
@ SHORT
Definition: element:25
tools::histo::key_axis_z_title
const std::string & key_axis_z_title()
Definition: base_histo:661
tools_lforcit
#define tools_lforcit(a__T, a__l, a__it)
Definition: forit:40
tools::wroot::base_cid
cid base_cid()
Definition: cids:14
tools::wroot::streamer__info::FLOAT
@ FLOAT
Definition: element:27
tools::rroot::AttFill_stream
bool AttFill_stream(buffer &a_buffer, short &a_color, short &a_style)
Definition: named:38
tools::wroot::size_TAttLine
int size_TAttLine()
Definition: infos:437
tools::wroot::size_TAttFill
int size_TAttFill()
Definition: infos:438
tools::rroot::TProfile_stream
histo::p1d * TProfile_stream(buffer &a_buffer)
Definition: streamers:643
tools::rroot::seek
int64 seek
Definition: seek:16
tools::osc::s_h1d
const std::string & s_h1d()
Definition: osc_streamers:41
tools::wroot::scs
void scs(unsigned int &a_cs, const std::string &a_s)
Definition: infos:12
tools::wroot::size_VIRTUAL
int size_VIRTUAL()
Definition: infos:28
tools::histo::key_axis_y_title
const std::string & key_axis_y_title()
Definition: base_histo:657
tools::wroot::fill_infos_cont
void fill_infos_cont(obj_list< streamer_info > &a_infos, std::ostream &)
Definition: infos:361
tools::wroot::streamer__info::BOOL
@ BOOL
Definition: element:32
tools::wroot::streamer__info::CHAR
@ CHAR
Definition: element:24
tools::wroot::fill_infos_histo
void fill_infos_histo(obj_list< streamer_info > &a_infos, std::ostream &a_out)
Definition: infos:1064
tools::wroot::size_TH2D
int size_TH2D()
Definition: infos:1062
tools::wroot::streamer__info::UNSIGNED_CHAR
@ UNSIGNED_CHAR
Definition: element:29
tools_mforcit
#define tools_mforcit(a__K, a__V, a__m, a__it)
Definition: forit:49
tools::rroot::annotations_t
std::map< std::string, std::string > annotations_t
Definition: THistogram:20
tools::wroot::size_TBranch
int size_TBranch()
Definition: infos:535
tools::wroot::Object_stream
bool Object_stream(buffer &a_buffer)
Definition: named:14
tools::wroot::size_TH2
int size_TH2()
Definition: infos:1061
tools::wroot::AttAxis_stream
bool AttAxis_stream(buffer &a_buffer)
Definition: streamers:29
tools::wroot::axis_title
std::string axis_title(const HIST &a_h, const std::string &a_key)
Definition: streamers:115
tools::wroot::acs
void acs(unsigned int &a_cs, int a_n, int *a_dims)
Definition: infos:17
tools::wroot::add_before
void add_before(std::list< free_seg * > &a_list, free_seg *a_what, free_seg *a_new)
Definition: free_seg:117
tools::wroot::size_TTree
int size_TTree()
Definition: infos:537
tools::rroot::TProfile2D_stream
histo::p2d * TProfile2D_stream(buffer &a_buffer)
Definition: streamers:712
tools::wroot::streamer__info::UNSIGNED_SHORT
@ UNSIGNED_SHORT
Definition: element:30
tools::wroot::fill_infos_tree
void fill_infos_tree(obj_list< streamer_info > &a_infos, std::ostream &a_out)
Definition: infos:539
tools::wroot::TH_write_1D
bool TH_write_1D(buffer &a_buffer, const HIST &a_h, const std::string &a_name, const std::vector< double > &a_bin_Sw2)
Definition: streamers:123
tools_lforit
#define tools_lforit(a__T, a__l, a__it)
Definition: forit:43
tools::wroot::mpi_protocol_basket
uint32 mpi_protocol_basket()
Definition: mpi_protocol:12
tools::wroot::size_TNamed
int size_TNamed()
Definition: infos:31
tools::wroot::to
bool to(directory &a_dir, const histo::p2d &a_histo, const std::string &a_name)
Definition: to:122
tools::rroot::Att3D_stream
bool Att3D_stream(buffer &a_buffer)
Definition: named:72
tools::rroot::TH1D_stream
histo::h1d * TH1D_stream(buffer &a_buffer)
Definition: streamers:409
tools::wroot::streamer__info::size_DOUBLE
const int size_DOUBLE
Definition: element:43
tools::wroot::find_after
free_seg * find_after(const std::list< free_seg * > &a_list, free_seg *a_what)
Definition: free_seg:96
tools::wroot::streamer__info::size_FLOAT
const int size_FLOAT
Definition: element:42
tools::wroot::size_TAttAxis
int size_TAttAxis()
Definition: infos:1058
tools::osc::s_p1d
const std::string & s_p1d()
Definition: osc_streamers:56
tools::wroot::size_TH1
int size_TH1()
Definition: infos:1060
tools::histo::key_axis_x_title
const std::string & key_axis_x_title()
Definition: base_histo:653
tools_vforcit
#define tools_vforcit(a__T, a__v, a__it)
Definition: forit:7
tools::wroot::mpi_pack_basket
bool mpi_pack_basket(impi &a_mpi, uint32 a_icol, const basket &a_basket)
Definition: mpi_send_basket:14
tools::uint32
unsigned int uint32
Definition: typedefs:71
tools::wroot::TH_write_2D
bool TH_write_2D(buffer &a_buffer, const HIST &a_h, const std::string &a_name, const std::vector< double > &a_bin_Sw2)
Definition: streamers:217
tools::wroot::streamer__info::UNSIGNED_INT
@ UNSIGNED_INT
Definition: element:31
tools::wroot::streamer__info::INT
@ INT
Definition: element:26
Generated by doxygen 1.8.20