inlib::wroot Namespace Reference

Namespaces
namespace	streamer_info
Classes
class	base_leaf
class	basket
class	branch
class	buffer
class	bufobj
class	directory
class	streamer_element
class	streamer_base
class	streamer_basic_type
class	streamer_basic_pointer
class	streamer_string
class	streamer_object
class	streamer_object_pointer
class	streamer_object_any
class	streamer_STL
class	file
class	ibo
class	idir
class	ifile
class	StreamerInfo
class	iobject
class	itree
class	key
class	leaf
class	ObjArray
class	List
class	ntuple
class	tree
class	wbuf
Typedefs
typedef unsigned int	date
typedef int64	seek
typedef int	seek32
typedef histo::histo_data < double, unsigned int, double >	hd_data
typedef histo::profile_data < double, unsigned int, double, double >	pd_data
Functions
date	get_date ()
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 (List< StreamerInfo > &a_infos, const std::string &a_type, streamer_info::Type a_si_type)
bool	fill_infos (List< StreamerInfo > &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)
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)
template<class T >
bool	Array_stream (buffer &a_buffer, const std::vector< T > &a_v)
bool	AttAxis_stream (buffer &a_buffer)
bool	axis_stream (buffer &a_buffer, const histo::axis< double > &a_axis, const std::string &a_name)
bool	List_empty_stream (buffer &a_buffer)
bool	TH_write_1D (buffer &a_buffer, const hd_data &a_data, const std::string &a_name)
bool	TH_write_2D (buffer &a_buffer, const hd_data &a_data, 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	TH2D_stream (buffer &a_buffer, const histo::h2d &a_h, const std::string &a_name)
bool	TProfile_stream (buffer &a_buffer, const histo::p1d &a_p, const std::string &a_name)
bool	to (directory &a_dir, const histo::h1d &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::p1d &a_histo, const std::string &a_name)

---

Typedef Documentation

typedef unsigned int inlib::wroot::date

Definition at line 16 of file date.

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

Definition at line 22 of file streamers.

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

Definition at line 23 of file streamers.

typedef int64 inlib::wroot::seek

Definition at line 16 of file seek.

typedef int inlib::wroot::seek32

Definition at line 17 of file seek.

---

Function Documentation

void inlib::wroot::acs	(	unsigned int &	a_cs,
		int	a_n,
		int *	a_dims
	)		[inline]

Definition at line 17 of file infos.

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

template<class T >

bool inlib::wroot::Array_stream	(	buffer &	a_buffer,
		const std::vector< T > &	a_v
	)		[inline]

Definition at line 161 of file named.

                                                                   {
  if(!a_buffer.write((int)a_v.size())) return false;
  if(!a_buffer.write_fast_array(vec_data(a_v),a_v.size())) return false;
  return true;
}

bool inlib::wroot::AttAxis_stream

(

buffer &

a_buffer

)

[inline]

Definition at line 25 of file streamers.

                                             {
  int fNdivisions = 510;   //Number of divisions(10000*n3 + 100*n2 + n1)
  short fAxisColor = 1;    //color of the line axis
  short fLabelColor = 1;   //color of labels
  short fLabelFont = 62;    //font for labels
  float fLabelOffset = 0.005F;  //offset of labels
  float fLabelSize = 0.04F;    //size of labels
  float fTickLength = 0.03F;   //length of tick marks
  float fTitleOffset = 1;  //offset of axis title
  float fTitleSize = 0.04F;    //size of axis title
  short fTitleColor = 1;   //color of axis title
  short fTitleFont = 62;    //font for axis title

  // Version 4 streaming (ROOT/v3-00-6).
  unsigned int beg;
  if(!a_buffer.write_version(4,beg)) return false;

  if(!a_buffer.write(fNdivisions)) return false;
  if(!a_buffer.write(fAxisColor)) return false;
  if(!a_buffer.write(fLabelColor)) return false;
  if(!a_buffer.write(fLabelFont)) return false;
  if(!a_buffer.write(fLabelOffset)) return false;
  if(!a_buffer.write(fLabelSize)) return false;
  if(!a_buffer.write(fTickLength)) return false;
  if(!a_buffer.write(fTitleOffset)) return false;
  if(!a_buffer.write(fTitleSize)) return false;
  if(!a_buffer.write(fTitleColor)) return false;
  if(!a_buffer.write(fTitleFont)) return false;

  if(!a_buffer.set_byte_count(beg)) return false;
  return true;
}

bool inlib::wroot::AttFill_stream

(

buffer &

a_buffer

)

[inline]

Definition at line 136 of file named.

                                            {
  short fFillColor = 0;
  short fFillStyle = 101;
  unsigned int c;
  if(!a_buffer.write_version(1,c)) return false;
  if(!a_buffer.write(fFillColor)) return false;
  if(!a_buffer.write(fFillStyle)) return false;
  if(!a_buffer.set_byte_count(c)) return false;
  return true;
}

bool inlib::wroot::AttLine_stream

(

buffer &

a_buffer

)

[inline]

Definition at line 123 of file named.

                                            {
  short fLineColor = 1;
  short fLineStyle = 1;
  short fLineWidth = 1;
  unsigned int c;
  if(!a_buffer.write_version(1,c)) return false;
  if(!a_buffer.write(fLineColor)) return false;
  if(!a_buffer.write(fLineStyle)) return false;
  if(!a_buffer.write(fLineWidth)) return false;
  if(!a_buffer.set_byte_count(c)) return false;
  return true;
}

bool inlib::wroot::AttMarker_stream

(

buffer &

a_buffer

)

[inline]

Definition at line 147 of file named.

                                               {
  short fMarkerColor = 1;
  short fMarkerStyle = 1;
  float fMarkerWidth = 1;
  unsigned int c;
  if(!a_buffer.write_version(1,c)) return false;
  if(!a_buffer.write(fMarkerColor)) return false;
  if(!a_buffer.write(fMarkerStyle)) return false;
  if(!a_buffer.write(fMarkerWidth)) return false;
  if(!a_buffer.set_byte_count(c)) return false;
  return true;
}

bool inlib::wroot::axis_stream	(	buffer &	a_buffer,
		const histo::axis< double > &	a_axis,
		const std::string &	a_name
	)		[inline]

Definition at line 58 of file streamers.

                                                 {
    // Version 6 streaming (ROOT/v3-00-6).

    unsigned int beg;
    if(!a_buffer.write_version(6,beg)) return false;

   {std::string title;
    if(!Named_stream(a_buffer,a_name,title)) return false;}

    if(!AttAxis_stream(a_buffer)) return false;

    if(!a_buffer.write(a_axis.bins())) return false;
    if(!a_buffer.write(a_axis.lower_edge())) return false;
    if(!a_buffer.write(a_axis.upper_edge())) return false;

    // fXbins 
    //if(a_axis.m_fixed) {
    //  std::vector<double> v;
    //  ArrayT<double> dummy(v);
    //  if(!dummy.stream(a_buffer)) return false; //TArrayD
    //} else {
      if(!Array_stream(a_buffer,a_axis.edges())) return false; //TArrayD
    //}

    if(!a_buffer.write((int)0)) return false; //fFirst
    if(!a_buffer.write((int)0)) return false; //fLast

    //Bool_t
    if(!a_buffer.write((unsigned char)0)) return false;  //TimeDisplay

    //TString
    if(!a_buffer.write(std::string())) return false; //TimeFormat

    if(!a_buffer.set_byte_count(beg)) return false;

    return true;
}

bool inlib::wroot::fill_infos	(	List< StreamerInfo > &	a_infos,
		std::ostream &	a_out
	)		[inline]

core //////////////////////////////////////////////////

graf //////////////////////////////////////////////////

tree //////////////////////////////////////////////////

//144

//228

histo /////////////////////////////////////////////////

fDirectory offset 552 : //4 fDimension offset 556 : //4 fIntegral offset 560 : //4 fPainter offset 564 : //4

Definition at line 32 of file infos.

                                                                      {

  const int size_DOUBLE = 8;
  const int size_INT = 4;
  const int size_POINTER = 4;
  //const int size_OBJECT_POINTER = 4;
  const int size_COUNTER = 4;
  const int size_VIRTUAL = 4;

  const int size_TNamed = 28;
  const int size_TAttLine = 12;
  const int size_TAttFill = 8;
  const int size_TAttMarker = 12;
  const int size_TObjArray = 40;
  const int size_TArray = 8;
  const int size_TArrayD = 12;

  const int size_TString = 8;
  const int size_TBranch = 256;
  const int size_TLeaf = 64;

  // sizeof(TString) = 8   (4 (virtual ~) + 1 + 3 (align))
  // sizeof(TObject) = 12
  // sizeof(TNamed)  = 28
  // sizeof(TObjArray) = 40
  // sizeof(TArray) = 8
  // sizeof(TArrayI) = 12
  // sizeof(TArrayD) = 12
  // sizeof(TArrayF) = 12


  short TObject_version = 1;
  short TNamed_version = 1;
  short TStreamerElement_version = 2;
  short TArray_version = 1;
  short TArrayF_version = 1;
  short TArrayD_version = 1;

 {unsigned int check = 0;  
  //this :
  scs(check,"TNamed");
  //base :
  scs(check,"TObject");
  //members :
  scs(check,"fName");
  scs(check,"TString");

  scs(check,"fTitle");
  scs(check,"TString");

  StreamerInfo* info = new StreamerInfo("TNamed",1,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TObject","Basic ROOT object",0,TObject_version)); //12
  info->add(new streamer_string("fName","object identifier",12));//8
  info->add(new streamer_string("fTitle","object title",20));//8

  //28
 }

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerInfo");
  //bases :
  scs(check,"TNamed");
  //members :
  scs(check,"fCheckSum");
  scs(check,"UInt_t");

  scs(check,"fClassVersion");
  scs(check,"Int_t");

  scs(check,"fElements");
  scs(check,"TObjArray*");

  StreamerInfo* info = new StreamerInfo("TStreamerInfo",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version));//28
  info->add(new streamer_basic_type("fCheckSum","checksum of original class",28,streamer_info::UNSIGNED_INT,"UInt_t"));//4
  info->add(new streamer_basic_type("fClassVersion","Class version identifier",32,streamer_info::INT,"Int_t"));//4
  //40 = 2*int+4*int_p+2*ulong_p+bool+p (bool=4 !)
  info->add(new streamer_object_pointer("fElements","Array of TStreamerElements",76,"TObjArray*"));//4

  //80
 }

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerElement");
  //bases :
  scs(check,"TNamed");
  //members :
  scs(check,"fType");
  scs(check,"Int_t");

  scs(check,"fSize");
  scs(check,"Int_t");

  scs(check,"fArrayLength");
  scs(check,"Int_t");

  scs(check,"fArrayDim");
  scs(check,"Int_t");

  scs(check,"fMaxIndex");
  scs(check,"Int_t");
  int dim = 5;
  acs(check,1,&dim);

  scs(check,"fTypeName");
  scs(check,"TString");
  //Should be : 2369818458U

  StreamerInfo* info = new StreamerInfo("TStreamerElement",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version));
  info->add(new streamer_basic_type("fType","element type",28,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fSize","sizeof element",32,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fArrayLength","cumulative size of all array dims",36,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fArrayDim","number of array dimensions",40,streamer_info::INT,"Int_t"));

 {streamer_element* elem = new streamer_basic_type("fMaxIndex","Maximum array index for array dimension \"dim\"",44,streamer_info::INT,"Int_t");
  info->add(elem);
  elem->setArrayDimension(1);
  elem->setMaxIndex(0,5);}

  info->add(new streamer_string("fTypeName","Data type name of data member",72));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerBase");
  //bases :
  scs(check,"TStreamerElement");
  //members :
  scs(check,"fBaseVersion");
  scs(check,"Int_t");
  //Should be : 2671078514U

  StreamerInfo* info = new StreamerInfo("TStreamerBase",3,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));
  info->add(new streamer_basic_type("fBaseVersion","version number of the base class",88,streamer_info::INT,"Int_t"));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerString");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 2525579865U

  StreamerInfo* info = new StreamerInfo("TStreamerString",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerBasicType");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 3001875966U;

  StreamerInfo* info = new StreamerInfo("TStreamerBasicType",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerBasicPointer");
  //bases :
  scs(check,"TStreamerElement");
  //members :
  scs(check,"fCountVersion");
  scs(check,"Int_t");

  scs(check,"fCountName");
  scs(check,"TString");

  scs(check,"fCountClass");
  scs(check,"TString");
  //Should be : 1587298059U

  StreamerInfo* info = new StreamerInfo("TStreamerBasicPointer",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));
  info->add(new streamer_basic_type("fCountVersion","version number of the class with the counter",88,streamer_info::INT,"Int_t"));
  info->add(new streamer_string("fCountName","name of data member holding the array count",92));
  info->add(new streamer_string("fCountClass","name of the class with the counter",100));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerObject");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 2177456715U

  StreamerInfo* info = new StreamerInfo("TStreamerObject",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerObjectPointer");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 720556968U

  StreamerInfo* info = new StreamerInfo("TStreamerObjectPointer",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TStreamerObjectAny");
  //bases :
  scs(check,"TStreamerElement");
  //Should be : 3108880127U

  StreamerInfo* info = new StreamerInfo("TStreamerObjectAny",2,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TArray");
  //members :
  scs(check,"fN");
  scs(check,"Int_t");

  StreamerInfo* info = new StreamerInfo("TArray",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;
  offset += size_VIRTUAL;

  info->add(new streamer_basic_type(
      "fN",
      "Number of array elements",
      offset,
      streamer_info::INT,"Int_t")); //4
  offset += size_INT;

  //8
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TArrayI");
  //base :
  scs(check,"TArray");
  //members :
  scs(check,"fArray");
  scs(check,"Int_t*");

  StreamerInfo* info = new StreamerInfo("TArrayI",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TArray",
      "Abstract array base class",
      offset,
      TArray_version));
  offset += size_TArray;

  info->add(new streamer_basic_pointer(
      "fArray",
      "[fN] Array of fN integers",
      offset,
      streamer_info::INT,"fN","TArray",1,"Int_t*"));
  offset += size_POINTER;

  //12
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TArrayD");
  //base :
  scs(check,"TArray");
  //members :
  scs(check,"fArray");
  scs(check,"Double_t*");

  StreamerInfo* info = new StreamerInfo("TArrayD",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TArray",
      "Abstract array base class",
      offset,
      TArray_version));
  offset += size_TArray; //8

  info->add(new streamer_basic_pointer(
      "fArray",
      "[fN] Array of fN integers",
      offset,
      streamer_info::DOUBLE,"fN","TArray",1,"Double_t*"));
  offset += size_POINTER;

  //12
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TArrayF");
  //base :
  scs(check,"TArray");
  //members :
  scs(check,"fArray");
  scs(check,"Float_t*");

  StreamerInfo* info = new StreamerInfo("TArrayF",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TArray",
      "Abstract array base class",
      offset,
      TArray_version));
  offset += size_TArray;

  info->add(new streamer_basic_pointer(
      "fArray",
      "[fN] Array of fN integers",
      offset,
      streamer_info::FLOAT,"fN","TArray",1,"Float_t*"));
  offset += size_POINTER;

  //12
  }

  fill_vec(a_infos,"char",streamer_info::CHAR);
  fill_vec(a_infos,"short",streamer_info::SHORT);
  fill_vec(a_infos,"int",streamer_info::INT);
  fill_vec(a_infos,"unsigned char",streamer_info::UNSIGNED_CHAR);
  fill_vec(a_infos,"unsigned short",streamer_info::UNSIGNED_SHORT);
  fill_vec(a_infos,"unsigned int",streamer_info::UNSIGNED_INT);
  fill_vec(a_infos,"float",streamer_info::FLOAT);
  fill_vec(a_infos,"double",streamer_info::DOUBLE);
  fill_vec(a_infos,"bool",streamer_info::BOOL);


  //sizeof(Font_t) = 2
  //sizeof(Style_t) = 2
  //sizeof(Marker_t) = 2
  //sizeof(Width_t) = 2
  //sizeof(Size_t) = 4

 {unsigned int check = 0;  
  //this :
  scs(check,"TAttLine");
  //members :
  scs(check,"fLineColor");
  scs(check,"Color_t");

  scs(check,"fLineStyle");
  scs(check,"Style_t");

  scs(check,"fLineWidth");
  scs(check,"Width_t");

  //Should be : 1369587346U

  // Beurk ; but the ROOT TTree compells indirectly the below.
  StreamerInfo* info = new StreamerInfo("TAttLine",1,check);
  a_infos.push_back(info);
  // Elements :
  //4 (virtual ~)
  info->add(new streamer_basic_type("fLineColor","line color",4,streamer_info::SHORT,"Color_t"));//2
  info->add(new streamer_basic_type("fLineStyle","line style",6,streamer_info::SHORT,"Style_t"));//2
  info->add(new streamer_basic_type("fLineWidth","line width",8,streamer_info::SHORT,"Width_t"));//2
  //2 (alignement ???)

  //12
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TAttFill");
  //members :
  scs(check,"fFillColor");
  scs(check,"Color_t");

  scs(check,"fFillStyle");
  scs(check,"Style_t");

    //Should be : 1204118360U
  StreamerInfo* info = new StreamerInfo("TAttFill",1,check);
  a_infos.push_back(info);
  // Elements :
  //4 (virtual ~)
  info->add(new streamer_basic_type("fFillColor","fill area color",4,streamer_info::SHORT,"Color_t"));//2
  info->add(new streamer_basic_type("fFillStyle","fill area style",6,streamer_info::SHORT,"Style_t"));//2

  //8
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TAttMarker");
  //members :
  scs(check,"fMarkerColor");
  scs(check,"Color_t");

  scs(check,"fMarkerStyle");
  scs(check,"Style_t");

  scs(check,"fMarkerSize");
  scs(check,"Size_t");

  //Should be 4207747460U

  StreamerInfo* info = new StreamerInfo("TAttMarker",1,check);
  a_infos.push_back(info);
  // Elements :
  //4 (virtual ~)
  info->add(new streamer_basic_type("fMarkerColor","Marker color index",0,streamer_info::SHORT,"Color_t"));//2
  info->add(new streamer_basic_type("fMarkerStyle","Marker style",4,streamer_info::SHORT,"Style_t"));//2
  info->add(new streamer_basic_type("fMarkerSize","Marker size",6,streamer_info::FLOAT,"Size_t"));//4

  //12
  }

  short TAttLine_version = 1;
  short TAttFill_version = 1;
  short TAttMarker_version = 1;
  short TBranch_version = 8;
  short TLeaf_version = 2;

 {unsigned int check = 0;  
  //this :
  scs(check,"TTree");
  //bases :
  scs(check,"TNamed");
  scs(check,"TAttLine");
  scs(check,"TAttFill");
  scs(check,"TAttMarker");
  //members :
  scs(check,"fEntries");
  scs(check,"Stat_t");

  scs(check,"fTotBytes");
  scs(check,"Stat_t");

  scs(check,"fZipBytes");
  scs(check,"Stat_t");

  scs(check,"fSavedBytes");
  scs(check,"Stat_t");

  scs(check,"fTimerInterval");
  scs(check,"Int_t");

  scs(check,"fScanField");
  scs(check,"Int_t");

  scs(check,"fUpdate");
  scs(check,"Int_t");

  scs(check,"fMaxEntryLoop");
  scs(check,"Int_t");

  scs(check,"fMaxVirtualSize");
  scs(check,"Int_t");

  scs(check,"fAutoSave");
  scs(check,"Int_t");

  scs(check,"fEstimate");
  scs(check,"Int_t");

  scs(check,"fBranches");
  scs(check,"TObjArray");

  scs(check,"fLeaves");
  scs(check,"TObjArray");

  //scs(check,"fAliases");
  //scs(check,"TList*");

  scs(check,"fIndexValues");
  scs(check,"TArrayD");

  scs(check,"fIndex");
  scs(check,"TArrayI");

  //scs(check,"fFriends");
  //scs(check,"TList*");
  //Should be : 3245044844U //3.00.06
  //Should be : FIXME //3.10.02

  StreamerInfo* info = new StreamerInfo("TTree",5,check);
  a_infos.push_back(info);
  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TNamed",
      "The basis for a named object (name, title)",
      offset,
      TNamed_version));
  offset += size_TNamed;

  info->add(new streamer_base(
      "TAttLine",
      "Line attributes",
      offset,
      TAttLine_version));
  offset += size_TAttLine;

  info->add(new streamer_base(
      "TAttFill",
      "Fill area attributes",
      offset,
      TAttFill_version));
  offset += size_TAttFill;

  info->add(new streamer_base(
      "TAttMarker",
      "Marker attributes",
      offset,
      TAttMarker_version));
  offset += size_TAttMarker;

  info->add(new streamer_basic_type(
      "fEntries",
      "Number of entries",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fTotBytes",
      "Total number of bytes in all branches before compression",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fZipBytes",
      "Total number of bytes in all branches after compression",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fSavedBytes",
      "Number of autosaved bytes",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fTimerInterval",
      "Timer interval in milliseconds",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fScanField",
      "Number of runs before prompting in Scan",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fUpdate",
      "Update frequency for EntryLoop",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fMaxEntryLoop",
      "Maximum number of entries to process",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fMaxVirtualSize",
      "Maximum total size of buffers kept in memory",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fAutoSave",
      "Autosave tree when fAutoSave bytes produced",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fEstimate",
      "Number of entries to estimate histogram limits",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  offset += 5*size_INT+size_POINTER, 

  info->add(new streamer_object(
      "fBranches",
      "List of Branches",
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  info->add(new streamer_object(
      "fLeaves",
      "Direct pointers to individual branch leaves",
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  //info->add(new streamer_object_pointer(
  //  "fAliases",
  //  "List of aliases for expressions based on the tree branches.",
  //  offset,
  //  "TList*"));
  //offset += size_OBJECT_POINTER;

  offset += size_POINTER; 

  info->add(new streamer_object_any(
      "fIndexValues",
      "Sorted index values",
      offset,
      "TArrayD"));
  offset += size_TArrayD;

  info->add(new streamer_object_any(
      "fIndex",
      "Index of sorted values",
      offset,
      "TArrayI"));

  //info->add(new streamer_object_pointer(
  //  "fFriends",
  //  "pointer to list of friend elements",
  //  offset,
  //  "TList*"));
  //offset += size_OBJECT_POINTER;

  if(offset!=240) {
    a_out << "inlib::wroot::fill_infos :"
          << " Tree " << offset << " (240 expected.)"
          << std::endl;
  }}

  //---------------------------------------------------------------------
 {unsigned int check = 0;  
  //this :
  scs(check,"TBranch");
  //bases :
  scs(check,"TNamed");
  scs(check,"TAttFill");
  //members :
  scs(check,"fCompress");
  scs(check,"Int_t");

  scs(check,"fBasketSize");
  scs(check,"Int_t");

  scs(check,"fEntryOffsetLen");
  scs(check,"Int_t");

  scs(check,"fWriteBasket");
  scs(check,"Int_t");

  scs(check,"fEntryNumber");
  scs(check,"Int_t");

  scs(check,"fOffset");
  scs(check,"Int_t");

  scs(check,"fMaxBaskets");
  scs(check,"Int_t");

  scs(check,"fSplitLevel");
  scs(check,"Int_t");

  scs(check,"fEntries");
  scs(check,"Stat_t");

  scs(check,"fTotBytes");
  scs(check,"Stat_t");

  scs(check,"fZipBytes");
  scs(check,"Stat_t");

  scs(check,"fBranches");
  scs(check,"TObjArray");

  scs(check,"fLeaves");
  scs(check,"TObjArray");

  scs(check,"fBaskets");
  scs(check,"TObjArray");

  scs(check,"fBasketBytes");
  scs(check,"Int_t*");

  scs(check,"fBasketEntry");
  scs(check,"Int_t*");

  scs(check,"fBasketSeek");
  scs(check,"Seek_t*");

  scs(check,"fFileName");
  scs(check,"TString");
  //Should be : 2056727376U (6 3.00.06)
  //Should be : FIXME (7 3.03.01)

  StreamerInfo* info = new StreamerInfo("TBranch",8,check);
  a_infos.push_back(info);
  // Elements :
  int offset = 0;

  info->add(new streamer_base(
      "TNamed",
      "The basis for a named object (name, title)",
      offset,
      TNamed_version));
  offset += size_TNamed;

  info->add(new streamer_base(
      "TAttFill",
      "Fill area attributes",
      offset,
      TAttFill_version));
  offset += size_TAttFill;

  info->add(new streamer_basic_type(
      "fCompress",
      "(=1 branch is compressed, 0 otherwise)",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fBasketSize",
      "Initial Size of  Basket Buffer",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fEntryOffsetLen",
      "Initial Length of fEntryOffset table in the basket buffers",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fWriteBasket",
      "Last basket number written",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fEntryNumber",
      "Current entry number (last one filled in this branch)",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fOffset",
      "Offset of this branch",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type(
      "fMaxBaskets",
      "Maximum number of Baskets so far",
      offset,
      streamer_info::COUNTER,"Int_t"));
  offset += size_COUNTER;

  info->add(new streamer_basic_type( //3.03.01
      "fSplitLevel",
      "Branch split level",
      offset,
      streamer_info::INT,"Int_t"));
  offset += size_INT;

  offset += 3*size_INT; 

  info->add(new streamer_basic_type(
      "fEntries",
      "Number of entries",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fTotBytes",
      "Total number of bytes in all leaves before compression",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_basic_type(
      "fZipBytes",
      "Total number of bytes in all leaves after compression",
      offset,
      streamer_info::DOUBLE,"Stat_t"));
  offset += size_DOUBLE;

  info->add(new streamer_object(
      "fBranches",
      "-> List of Branches of this branch",
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  info->add(new streamer_object(
      "fLeaves", 
      "-> List of leaves of this branch",
      size_TNamed+6*size_INT+size_COUNTER+
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  info->add(new streamer_object(
      "fBaskets",
      "-> List of baskets of this branch",
      offset,
      "TObjArray"));
  offset += size_TObjArray;

  offset += size_INT+size_POINTER; 

  info->add(new streamer_basic_pointer(
      "fBasketBytes",
      "[fMaxBaskets] Lenght of baskets on file",
      offset,
      streamer_info::INT,"fMaxBaskets","TBranch",6,"Int_t*"));
  offset += size_POINTER;

  info->add(new streamer_basic_pointer(
      "fBasketEntry",
      "[fMaxBaskets] Table of first entry in eack basket",
      offset,
      streamer_info::INT,"fMaxBaskets","TBranch",6,"Int_t*"));
  offset += size_POINTER;

  info->add(new streamer_basic_pointer(
      "fBasketSeek",
      "[fMaxBaskets] Addresses of baskets on file",
      offset,
      streamer_info::INT,"fMaxBaskets","TBranch",6,"Seek_t*"));
  offset += size_POINTER;

  offset += 3*size_POINTER; 

  info->add(new streamer_string(
      "fFileName",
      "Name of file where buffers are stored (\"\" if in same file as Tree header)",
      offset));

  if(offset!=256) {
    a_out << "inlib::wroot::fill_infos :"
          << " Branch " << offset << " (256 expected.)"
          << std::endl;
  }}

 {unsigned int check = 0;  
  //this :
  scs(check,"TBranchObject");
  //bases :
  scs(check,"TBranch");
  //members :
  scs(check,"fClassName");
  scs(check,"TString");

  //Should be : 2857878535U

  StreamerInfo* info = new StreamerInfo("TBranchObject",1,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TBranch","Branch descriptor",0,TBranch_version));
  info->add(new streamer_string("fClassName","Class name of referenced object",256));
  }

  //---------------------------------------------------------------------
 {unsigned int check = 0;  
  //this :
  scs(check,"TBranchElement");
  //bases :
  scs(check,"TBranch");
  //members :
  scs(check,"fClassName");
  scs(check,"TString");

  scs(check,"fClassVersion");
  scs(check,"Int_t");

  scs(check,"fID");
  scs(check,"Int_t");

  scs(check,"fType");
  scs(check,"Int_t");

  scs(check,"fStreamerType");
  scs(check,"Int_t");

  StreamerInfo* info = new StreamerInfo("TBranchElement",1,check);
  a_infos.push_back(info);
  // Elements :
  int offset = 0;
  info->add(new streamer_base("TBranch","Branch descriptor",offset,TBranch_version));
  offset += size_TBranch;

  info->add(new streamer_string("fClassName","Class name of referenced object",offset));
  offset += size_TString;

  info->add(new streamer_basic_type("fClassVersion","Version number of class",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type("fID","element serial number in fInfo",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type("fType","branch type",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type("fStreamerType","branch streamer type",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeaf");
  //bases :
  scs(check,"TNamed");
  //members :
  scs(check,"fLen");
  scs(check,"Int_t");

  scs(check,"fLenType");
  scs(check,"Int_t");

  scs(check,"fOffset");
  scs(check,"Int_t");

  scs(check,"fIsRange");
  scs(check,"Bool_t");

  scs(check,"fIsUnsigned");
  scs(check,"Bool_t");

  scs(check,"fLeafCount");
  scs(check,"TLeaf*");

  //Should be : 727988519U

  StreamerInfo* info = new StreamerInfo("TLeaf",2,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version));
  info->add(new streamer_basic_type("fLen","Number of fixed length elements",32,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fLenType","Number of bytes for this data type",36,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fOffset","Offset in ClonesArray object (if one)",40,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fIsRange","(=kTRUE if leaf has a range, kFALSE otherwise)",44,streamer_info::UNSIGNED_CHAR,"Bool_t"));
  info->add(new streamer_basic_type("fIsUnsigned","(=kTRUE if unsigned, kFALSE otherwise)",45,streamer_info::UNSIGNED_CHAR,"Bool_t"));
  info->add(new streamer_object_pointer("fLeafCount","Pointer to Leaf count if variable length",48,"TLeaf*"));

  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafS");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Short_t");

  scs(check,"fMaximum");
  scs(check,"Short_t");

  //Should be : FIXME

  StreamerInfo* info = new StreamerInfo("TLeafS",1,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::SHORT,"Short_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",58,streamer_info::SHORT,"Short_t"));

  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafI");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Int_t");

  scs(check,"fMaximum");
  scs(check,"Int_t");

    //Should be : 3495201397U

  StreamerInfo* info = new StreamerInfo("TLeafI",1,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",60,streamer_info::INT,"Int_t"));

  }

 {unsigned int check = 0;  
  //name :
  scs(check,"TLeafF");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Float_t");

  scs(check,"fMaximum");
  scs(check,"Float_t");

  //Should be 1366318032U

  StreamerInfo* info = new StreamerInfo("TLeafF",1,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::FLOAT,"Float_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",60,streamer_info::FLOAT,"Float_t"));
 
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafD");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Double_t");

  scs(check,"fMaximum");
  scs(check,"Double_t");

  //Should be

  StreamerInfo* info = new StreamerInfo("TLeafD",1,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::DOUBLE,"Double_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",64,streamer_info::DOUBLE,"Double_t"));
 
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafB");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Char_t");

  scs(check,"fMaximum");
  scs(check,"Char_t");

  //Should be : FIXME

  StreamerInfo* info = new StreamerInfo("TLeafB",1,check);
  a_infos.push_back(info);
  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::CHAR,"Char_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",57,streamer_info::CHAR,"Char_t"));
 
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafC");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fMinimum");
  scs(check,"Int_t");

  scs(check,"fMaximum");
  scs(check,"Int_t");

  //Should be : FIXME

  StreamerInfo* info = new StreamerInfo("TLeafC",1,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fMinimum","Minimum value if leaf range is specified",56,streamer_info::INT,"Int_t"));
  info->add(new streamer_basic_type("fMaximum","Maximum value if leaf range is specified",60,streamer_info::INT,"Int_t"));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafObject");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fVirtual");
  scs(check,"Bool_t");

  //Should be 2312661809U

  StreamerInfo* info = new StreamerInfo("TLeafObject",4,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",0,TLeaf_version));
  info->add(new streamer_basic_type("fVirtual","Support for Virtuality",64,streamer_info::UNSIGNED_CHAR,"Bool_t"));}

 {unsigned int check = 0;  
  //this :
  scs(check,"TLeafElement");
  //bases :
  scs(check,"TLeaf");
  //members :
  scs(check,"fID");
  scs(check,"Int_t");

  scs(check,"fType");
  scs(check,"Int_t");

  StreamerInfo* info = new StreamerInfo("TLeafElement",1,check);
  a_infos.push_back(info);

  // Elements :
  int offset = 0;
  info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",offset,TLeaf_version));
  offset += size_TLeaf;

  offset += size_POINTER;

  info->add(new streamer_basic_type("fID","element serial number in fInfo",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;

  info->add(new streamer_basic_type("fType","leaf type",offset,streamer_info::INT,"Int_t"));
  offset += size_INT;}

  short TAttAxis_version = 4;

 {unsigned int check = 0;  
  //this :
  scs(check,"TAttAxis");
  //members :
  scs(check,"fNdivisions");
  scs(check,"Int_t");

  scs(check,"fAxisColor");
  scs(check,"Color_t");

  scs(check,"fLabelColor");
  scs(check,"Color_t");

  scs(check,"fLabelFont");
  scs(check,"Style_t");

  scs(check,"fLabelOffset");
  scs(check,"Float_t");

  scs(check,"fLabelSize");
  scs(check,"Float_t");

  scs(check,"fTickLength");
  scs(check,"Float_t");

  scs(check,"fTitleOffset");
  scs(check,"Float_t");

  scs(check,"fTitleSize");
  scs(check,"Float_t");

  scs(check,"fTitleColor");
  scs(check,"Color_t");

  scs(check,"fTitleFont");
  scs(check,"Style_t");

  StreamerInfo* info = new StreamerInfo("TAttAxis",4,check);
  a_infos.push_back(info);

  // Elements :
  //4 (virtual ~)
  info->add(new streamer_basic_type("fNdivisions","Number of divisions(10000*n3 + 100*n2 + n1)",4,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fAxisColor","color of the line axis",8,streamer_info::SHORT,"Color_t")); //2
  info->add(new streamer_basic_type("fLabelColor","color of labels",10,streamer_info::SHORT,"Color_t")); //2
  info->add(new streamer_basic_type("fLabelFont","font for labels",12,streamer_info::SHORT,"Style_t")); //2
  info->add(new streamer_basic_type("fLabelOffset","offset of labels",16,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fLabelSize","size of labels",20,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fTickLength","length of tick marks",24,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fTitleOffset","offset of axis title",28,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fTitleSize","size of axis title",32,streamer_info::FLOAT,"Float_t")); //4
  info->add(new streamer_basic_type("fTitleColor","color of axis title",36,streamer_info::SHORT,"Color_t")); //2 
  info->add(new streamer_basic_type("fTitleFont","font for axis title",38,streamer_info::SHORT,"Style_t")); //2
  //40
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TAxis");
  //bases :
  scs(check,"TNamed");
  scs(check,"TAttAxis");
  //members :
  scs(check,"fNbins");
  scs(check,"Int_t");

  scs(check,"fXmin");
  scs(check,"Axis_t");

  scs(check,"fXmax");
  scs(check,"Axis_t");

  scs(check,"fXbins");
  scs(check,"TArrayD");

  scs(check,"fFirst");
  scs(check,"Int_t");
    
  scs(check,"fLast");
  scs(check,"Int_t");

  scs(check,"fTimeDisplay");
  scs(check,"Bool_t");

  scs(check,"fTimeFormat");
  scs(check,"TString");

  StreamerInfo* info = new StreamerInfo("TAxis",6,check);
  a_infos.push_back(info);

  // Elements :
  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version)); //28
  info->add(new streamer_base("TAttAxis","Axis attributes",28,TAttAxis_version)); //40
  info->add(new streamer_basic_type("fNbins","Number of bins",68,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fXmin","low edge of first bin",72,streamer_info::DOUBLE,"Axis_t")); //8
  info->add(new streamer_basic_type("fXmax","upper edge of last bin",80,streamer_info::DOUBLE,"Axis_t")); //8
  info->add(new streamer_basic_type("fXbins","Bin edges array in X",88,streamer_info::OBJECT_ANY,"TArrayD")); //12
  info->add(new streamer_basic_type("fFirst","first bin to display",100,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fLast","last bin to display",104,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fTimeDisplay","on/off displaying time values instead of numerics",108,streamer_info::UNSIGNED_CHAR,"Bool_t")); //4 (Bool_t = 1 + 3 for alignement)
  info->add(new streamer_basic_type("fTimeFormat","Date&time format, ex: 09/12/99 12:34:00",112,streamer_info::TSTRING,"TString")); //8
  //offset 120 //4
  //offset 124 //4
  //128

  //v3-05-07 : 124 (stored) + 4  = 128
  }

  short TH1_version = 3;
 {unsigned int check = 0;  
  //this :
  scs(check,"TH1");
  //bases :
  scs(check,"TNamed");
  scs(check,"TAttLine");
  scs(check,"TAttFill");
  scs(check,"TAttMarker");
  //members :
  scs(check,"fNcells");
  scs(check,"Int_t");

  scs(check,"fXaxis");
  scs(check,"TAxis");

  scs(check,"fBarOffset");
  scs(check,"Short_t");

  scs(check,"fBarWidth");
  scs(check,"Short_t");

  scs(check,"fEntries");
  scs(check,"Stat_t");

  scs(check,"fTsumw");
  scs(check,"Stat_t");

  scs(check,"fTsumw2");
  scs(check,"Stat_t");

  scs(check,"fTsumwx");
  scs(check,"Stat_t");

  scs(check,"fTsumwx2");
  scs(check,"Stat_t");

  scs(check,"fMaximum");
  scs(check,"Double_t");

  scs(check,"fMinimum");
  scs(check,"Double_t");

  scs(check,"fNormFactor");
  scs(check,"Double_t");

  scs(check,"fContour");
  scs(check,"TArrayD");

  scs(check,"fSumw2");
  scs(check,"TArrayD");

  scs(check,"fOption");
  scs(check,"TString");

  scs(check,"fFunctions");
  scs(check,"TList*");

  StreamerInfo* info = new StreamerInfo("TH1",TH1_version,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TNamed","The basis for a named object (name, title)",0,TNamed_version)); //28
  info->add(new streamer_base("TAttLine","Line attributes",28,TAttLine_version)); //12
  info->add(new streamer_base("TAttFill","Fill area attributes",40,TAttFill_version)); //8
  info->add(new streamer_base("TAttMarker","Marker attributes",48,TAttMarker_version)); //12
  info->add(new streamer_basic_type("fNcells","number of bins(1D), cells (2D) +U/Overflows",60,streamer_info::INT,"Int_t")); //4
  info->add(new streamer_basic_type("fXaxis","X axis descriptor",64,streamer_info::OBJECT_ANY,"TAxis")); //128
  info->add(new streamer_basic_type("fYaxis","Y axis descriptor",192,streamer_info::OBJECT_ANY,"TAxis")); //128
  info->add(new streamer_basic_type("fZaxis","Z axis descriptor",320,streamer_info::OBJECT_ANY,"TAxis")); //128
  info->add(new streamer_basic_type("fBarOffset","(1000*offset) for bar charts or legos",448,streamer_info::SHORT,"Short_t"));//2
  info->add(new streamer_basic_type("fBarWidth","(1000*width) for bar charts or legos",450,streamer_info::SHORT,"Short_t"));//2
  info->add(new streamer_basic_type("fEntries","Number of entries",452,streamer_info::DOUBLE,"Stat_t"));//2
  info->add(new streamer_basic_type("fTsumw","Total Sum of weights",460,streamer_info::DOUBLE,"Stat_t"));//8
  info->add(new streamer_basic_type("fTsumw2","Total Sum of squares of weights",468,streamer_info::DOUBLE,"Stat_t"));//8
  info->add(new streamer_basic_type("fTsumwx","Total Sum of weight*X",476,streamer_info::DOUBLE,"Stat_t"));//8
  info->add(new streamer_basic_type("fTsumwx2","Total Sum of weight*X*X",484,streamer_info::DOUBLE,"Stat_t"));//8
  info->add(new streamer_basic_type("fMaximum","Maximum value for plotting",492,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fMinimum","Minimum value for plotting",500,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fNormFactor","Normalization factor",508,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fContour","Array to display contour levels",516,streamer_info::OBJECT_ANY,"TArrayD"));//12
  info->add(new streamer_basic_type("fSumw2","Array of sum of squares of weights",528,streamer_info::OBJECT_ANY,"TArrayD"));//12
  info->add(new streamer_basic_type("fOption","histogram options",540,streamer_info::TSTRING,"TString"));//8
  info->add(new streamer_basic_type("fFunctions","->Pointer to list of functions (fits and user)",548,streamer_info::OBJECT_ARROW,"TList*"));//4
  //568

  //v3-05-07 : 576  = 568 + 2 * 4 = ok
 }

 {unsigned int check = 0;  
  //this :
  scs(check,"TH1F");
  //base :
  scs(check,"TH1");
  scs(check,"TArrayF");

  StreamerInfo* info = new StreamerInfo("TH1F",1,check);
  a_infos.push_back(info);
  info->add(new streamer_base("TH1","1-Dim histogram base class",0,TH1_version));//568
  info->add(new streamer_base("TArrayF","Array of floats",568,TArrayF_version));//12
 }

  short TH1D_version = 1;
 {unsigned int check = 0;  
  //this :
  scs(check,"TH1D");
  //base :
  scs(check,"TH1");
  scs(check,"TArrayD");

  StreamerInfo* info = new StreamerInfo("TH1D",TH1D_version,check);
  a_infos.push_back(info);
  info->add(new streamer_base("TH1","1-Dim histogram base class",0,TH1_version));//568
  info->add(new streamer_base("TArrayD","Array of doubles",568,TArrayD_version));//12
  //580

  //v3-05-07 : 588 = 576 + 12 = ok
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TProfile");
  //base :
  scs(check,"TH1D");
  //members :
  scs(check,"fBinEntries");
  scs(check,"TArrayD");

  scs(check,"fErrorMode");
  scs(check,"EErrorType");//FIXME : ok ?

  scs(check,"fYmin");
  scs(check,"Double_t");

  scs(check,"fYmax");
  scs(check,"Double_t");

  StreamerInfo* info = new StreamerInfo("TProfile",3,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TH1D","1-Dim histograms (one double per channel)",0,TH1D_version));//580
  info->add(new streamer_basic_type("fBinEntries","number of entries per bin",580,streamer_info::OBJECT_ANY,"TArrayD"));//12
  info->add(new streamer_basic_type("fErrorMode","Option to compute errors",592,streamer_info::DOUBLE,"EErrorType"));//4
  info->add(new streamer_basic_type("fYmin","Lower limit in Y (if set)",596,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fYmax","Upper limit in Y (if set)",604,streamer_info::DOUBLE,"Double_t"));//8
  //612

  //v3-05-07 : 624 = 612 + 4 + 8 (diff TH1D) = ok
  }

  short TH2_version = 3;
 {unsigned int check = 0;  
  //this :
  scs(check,"TH2");
  //bases :
  scs(check,"TH1");
  //members :
  scs(check,"fScaleFactor");
  scs(check,"Double_t");

  scs(check,"fTsumwy");
  scs(check,"Double_t");

  scs(check,"fTsumwy2");
  scs(check,"Double_t");

  scs(check,"fTsumwxy");
  scs(check,"Double_t");

  StreamerInfo* info = new StreamerInfo("TH2",TH2_version,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TH1","1-Dim histogram base class",0,TH1_version));//568
  info->add(new streamer_basic_type("fScaleFactor","Scale Factor",576,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fTsumwy","Total Sum of weight*Y",584,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fTsumwy2","Total Sum of weight*Y*Y",592,streamer_info::DOUBLE,"Double_t"));//8
  info->add(new streamer_basic_type("fTsumwxy","Total Sum of weight*X*Y",600,streamer_info::DOUBLE,"Double_t"));//8
  //600

  //v3-05-07 : <to be checked>
  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TH2F");
  //base :
  scs(check,"TH2");
  scs(check,"TArrayF");

  StreamerInfo* info = new StreamerInfo("TH2F",3,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TH2","2-Dim histogram base class",0,TH2_version));//600
  info->add(new streamer_base("TArrayF","Array of floats",600,TArrayF_version));//12
  //612

  }

 {unsigned int check = 0;  
  //this :
  scs(check,"TH2D");
  //base :
  scs(check,"TH2");
  scs(check,"TArrayD");

  StreamerInfo* info = new StreamerInfo("TH2D",3,check);
  a_infos.push_back(info);

  info->add(new streamer_base("TH2","2-Dim histogram base class",0,TH2_version));//600
  info->add(new streamer_base("TArrayD","Array of doubles",600,TArrayD_version));//12
  //612

  }

  return true;
}

void inlib::wroot::fill_vec	(	List< StreamerInfo > &	a_infos,
		const std::string &	a_type,
		streamer_info::Type	a_si_type
	)		[inline]

Definition at line 21 of file infos.

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

date inlib::wroot::get_date

(

)

[inline]

Definition at line 18 of file date.

                      {
  // Set Date/Time to current time as reported by the system.
  // Date and Time are encoded into one single unsigned 32 bit word.
  // Date is stored with the origin being the 1st january 1995.
  // Time has 1 second precision.
#ifdef WIN32
  SYSTEMTIME tp;
  ::GetLocalTime(&tp);
  unsigned int year   = tp.wYear-1900;
  unsigned int month  = tp.wMonth;
  unsigned int day    = tp.wDay;
  unsigned int hour   = tp.wHour;
  unsigned int min    = tp.wMinute;
  unsigned int sec    = tp.wSecond;
#else
  time_t tloc = ::time(0);
  struct tm *tp = (tm*)::localtime(&tloc);
  unsigned int year   = tp->tm_year;
  unsigned int month  = tp->tm_mon + 1;
  unsigned int day    = tp->tm_mday;
  unsigned int hour   = tp->tm_hour;
  unsigned int min    = tp->tm_min;
  unsigned int sec    = tp->tm_sec;
#endif
  return ((year-95)<<26 | month<<22 | day<<17 | hour<<12 | min<<6 | sec);
}

const std::string& inlib::wroot::leaf_store_class

(

char

)

[inline]

Definition at line 12 of file leaf.

                                               {
  static const std::string s_v("TLeafB");
  return s_v;
}

const std::string& inlib::wroot::leaf_store_class

(

short

)

[inline]

Definition at line 16 of file leaf.

                                                {
  static const std::string s_v("TLeafS");
  return s_v;
}

const std::string& inlib::wroot::leaf_store_class

(

int

)

[inline]

Definition at line 20 of file leaf.

                                              {
  static const std::string s_v("TLeafI");
  return s_v;
}

const std::string& inlib::wroot::leaf_store_class

(

float

)

[inline]

Definition at line 24 of file leaf.

                                                {
  static const std::string s_v("TLeafF");
  return s_v;
}

const std::string& inlib::wroot::leaf_store_class

(

double

)

[inline]

Definition at line 28 of file leaf.

                                                 {
  static const std::string s_v("TLeafD");
  return s_v;
}

bool inlib::wroot::List_empty_stream

(

buffer &

a_buffer

)

[inline]

Definition at line 98 of file streamers.

                                                {
  unsigned int beg;
  if(!a_buffer.write_version(4,beg)) return false;
  if(!Object_stream(a_buffer)) return false;
  std::string name;
  if(!a_buffer.write(name)) return false;
  int nobjects = 0;
  if(!a_buffer.write(nobjects)) return false;
  if(!a_buffer.set_byte_count(beg)) return false;
  return true;
}

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

Definition at line 23 of file named.

                                                   {
  unsigned int beg;
  if(!a_buffer.write_version(1,beg)) return false;
  if(!Object_stream(a_buffer)) return false;
  if(!a_buffer.write(a_name)) return false;
  if(!a_buffer.write(a_title)) return false;
  if(!a_buffer.set_byte_count(beg)) return false;
  return true;
}

bool inlib::wroot::Object_stream

(

buffer &

a_buffer

)

[inline]

Definition at line 14 of file named.

                                            {
  short v = 1;
  if(!a_buffer.write_version(v)) return false;
  if(!a_buffer.write((unsigned int)0)) return false;
  static const unsigned int kNotDeleted = 0x02000000;
  if(!a_buffer.write(kNotDeleted)) return false;
  return true;
}

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

Definition at line 12 of file infos.

                                                         {
  unsigned int l = a_s.size();
  for(unsigned int i=0;i<l;i++) a_cs = a_cs*3+a_s[i];
}

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

Definition at line 212 of file streamers.

                                                 {
  if(!a_buffer.write_version(1)) return false;
  hd_data data = a_h.get_histo_data();
  if(!TH_write_1D(a_buffer,data,a_name)) return false;
  if(!Array_stream(a_buffer,data.m_bin_Sw)) return false; //fArray TArrayD
  return true;
}

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

Definition at line 201 of file streamers.

                                                 {
  if(!a_buffer.write_version(1)) return false;
  hd_data data = a_h.get_histo_data();
  if(!TH_write_1D(a_buffer,data,a_name)) return false;
  if(!Array_stream(a_buffer,convert<double,float>(data.m_bin_Sw)))
    return false; //TH1D::TArrayD::fArray
  return true;
}

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

Definition at line 233 of file streamers.

                                                {
  if(!a_buffer.write_version(3)) return false;
  hd_data data = a_h.get_histo_data();
  if(!TH_write_2D(a_buffer,data,a_name)) return false;
  if(!Array_stream(a_buffer,data.m_bin_Sw)) return false; //fArray TArrayD
  return true;
}

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

Definition at line 222 of file streamers.

                                                {
  if(!a_buffer.write_version(3)) return false;
  hd_data data = a_h.get_histo_data();
  if(!TH_write_2D(a_buffer,data,a_name)) return false;
  if(!Array_stream(a_buffer,convert<double,float>(data.m_bin_Sw)))
    return false; //fArray TArrayD
  return true;
}

bool inlib::wroot::TH_write_1D	(	buffer &	a_buffer,
		const hd_data &	a_data,
		const std::string &	a_name
	)		[inline]

Definition at line 110 of file streamers.

                                                 {

    if(!a_buffer.write_version(3)) return false;

    if(!Named_stream(a_buffer,a_name,a_data.m_title)) return false;

    if(!AttLine_stream(a_buffer)) return false;
    if(!AttFill_stream(a_buffer)) return false;
    if(!AttMarker_stream(a_buffer)) return false;

    if(!a_buffer.write((int)a_data.m_bin_number)) return false;

    //fXAxis
   {//have a copy because of const.
    histo::axis<double> haxis(a_data.m_axes[0]);
    if(!axis_stream(a_buffer,haxis,"xaxis")) return false;}

    if(a_data.m_dimension==2) {
     {histo::axis<double> haxis(a_data.m_axes[1]);
      if(!axis_stream(a_buffer,haxis,"yaxis")) return false;}

      histo::axis<double> dummy;
      dummy.configure(1,0,1);
      if(!axis_stream(a_buffer,dummy,"zaxis")) return false;
    } else {
      histo::axis<double> dummy;
      dummy.configure(1,0,1);
      if(!axis_stream(a_buffer,dummy,"yaxis")) return false;
      if(!axis_stream(a_buffer,dummy,"zaxis")) return false;
    }

    if(!a_buffer.write((short)(1000 * 0.25))) return false; //fBarOffset
    if(!a_buffer.write((short)(1000 * 0.5))) return false; //fBarWidth

    if(!a_buffer.write((double)a_data.get_entries())) return false;
    if(!a_buffer.write(a_data.get_Sw())) return false;
    if(!a_buffer.write(a_data.get_Sw2())) return false;

   {double value;
    a_data.get_ith_axis_Sxw(0,value);  
    if(!a_buffer.write(value)) return false;}

   {double value;
    a_data.get_ith_axis_Sx2w(0,value);  
    if(!a_buffer.write(value)) return false;}

    if(!a_buffer.write((double)-1111)) return false; //fMaximum
    if(!a_buffer.write((double)-1111)) return false; //fMinimum
    if(!a_buffer.write((double)0)) return false; //NormFactor

    if(!Array_stream(a_buffer,std::vector<double>()))
      return false; //fContour TArrayD

    if(!Array_stream(a_buffer,a_data.m_bin_Sw2)) return false; //fSumw2 TArrayD

    // store annotation on fOption    
    // but try to fool ROOT in order that it does not
    // understand fOption as.. ROOT options !
   //{std::string opt = " "+fAnnotation;   
   // opt[0] = 0; //awfull trick
   // if(!a_buffer.write(opt)) return false;} //TString fOption
   {std::string opt;   
    if(!a_buffer.write(opt)) return false;} //TString fOption

    if(!List_empty_stream(a_buffer)) return false; //Functions

    return true;
}

bool inlib::wroot::TH_write_2D	(	buffer &	a_buffer,
		const hd_data &	a_data,
		const std::string &	a_name
	)		[inline]

Definition at line 181 of file streamers.

                                                 {
  if(!a_buffer.write_version(3)) return false;
  if(!TH_write_1D(a_buffer,a_data,a_name)) return false;
  if(!a_buffer.write((double)1)) return false; //ScaleFactor

 {double value;
  a_data.get_ith_axis_Sxw(1,value);  
  if(!a_buffer.write(value)) return false;}

 {double value;
  a_data.get_ith_axis_Sx2w(1,value);  
  if(!a_buffer.write(value)) return false;}

  if(!a_buffer.write((double)0)) return false; //Tsumwxy //FIXME.

  return true;
}

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

Definition at line 14 of file to.

                                                                {
  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
                          a_name,a_histo.title(),"TH1D");
  if(!TH1D_stream(*bo,a_histo,a_name)) {
    a_dir.file().out() << "inlib::wroot::to :"
                       << " TH1D_stream failed."
                       << std::endl;
    delete bo;
    return false;
  }
  a_dir.append_object(bo); //a_dir takes ownership of bo.
  return true;
}

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

Definition at line 29 of file to.

                                                                {
  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
                          a_name,a_histo.title(),"TH2D");
  if(!TH2D_stream(*bo,a_histo,a_name)) {
    a_dir.file().out() << "inlib::wroot::to :"
                       << " TH2D_stream failed."
                       << std::endl;
    delete bo;
    return false;
  }
  a_dir.append_object(bo); //a_dir takes ownership of bo.
  return true;
}

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

Definition at line 44 of file to.

                                                                {
  bufobj* bo = new bufobj(a_dir.file().out(),a_dir.file().byte_swap(),256,
                          a_name,a_histo.title(),"TProfile");
  if(!TProfile_stream(*bo,a_histo,a_name)) {
    a_dir.file().out() << "inlib::wroot::to :"
                       << " TProfile_stream failed."
                       << std::endl;
    delete bo;
    return false;
  }
  a_dir.append_object(bo); //a_dir takes ownership of bo.
  return true;
}

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

Definition at line 243 of file streamers.

                                                    {
    if(!a_buffer.write_version(3)) return false;

    //WARNING : the mapping histo::p1d / TProfile is not obvious.
    //HCL::m_bin_Svw  <---> TProfile::fArray
    //HCL::m_bin_Sv2w <---> TProfile::fSumw2
    //HCL::m_bin_Sw   <---> TProfile::fBinEntries

    pd_data data = a_p.get_histo_data();
    //NOTE : histo.m_bin_Sw <---> TH1D::TArrayD::fArray
    //       then have to copy histo.m_bin_Svw on histo.m_bin_Sw
    //       before streaming.

    //save histo.m_bin_Sw on a ::Rio::Array_double :
    std::vector<double> vbins;
   {unsigned int binn = data.m_bin_number;
    vbins.resize(binn);
    for(unsigned int index=0;index<binn;index++){
      vbins[index] = data.m_bin_Sw[index];
    }}

    // copy histo.m_bin_Svw on histo.m_bin_Sw :
    data.m_bin_Sw = data.m_bin_Svw;    

    //WARNING : should create a valid Rio::TH1D::fHistogram
    //          being a histo::h1d.
    //          But the histo::p1d does not inherit histo::h1d.

    histo::h1d h("",10,0,1);
    h.copy_from_data(data);
    h.update_fast_getters();
    if(!TH1D_stream(a_buffer,h,a_name)) return false;

    //TProfile specific :
    if(!Array_stream(a_buffer,vbins)) return false; //fBinEntries TArrayD

    int errorMode = 0;
    if(!a_buffer.write(errorMode)) return false;
    if(!a_buffer.write(data.m_min_v)) return false;
    if(!a_buffer.write(data.m_max_v)) return false;

    return true;
}