| Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 1 // Copyright (C) 2010, Guy Barrand. All rights reserved.
2 // See the file tools.license for terms. 2 // See the file tools.license for terms.
3 3
4 #ifndef tools_wroot_infos 4 #ifndef tools_wroot_infos
5 #define tools_wroot_infos 5 #define tools_wroot_infos
6 6
7 #include "info" 7 #include "info"
8 8
9 namespace tools { 9 namespace tools {
10 namespace wroot { 10 namespace wroot {
11 11
12 inline void scs(unsigned int& a_cs,const std:: 12 inline void scs(unsigned int& a_cs,const std::string& a_s) {
13 size_t l = a_s.size(); 13 size_t l = a_s.size();
14 for(size_t i=0;i<l;i++) a_cs = a_cs*3+a_s[i] 14 for(size_t i=0;i<l;i++) a_cs = a_cs*3+a_s[i];
15 } 15 }
16 16
17 inline void acs(unsigned int& a_cs,int a_n,int 17 inline void acs(unsigned int& a_cs,int a_n,int* a_dims) {
18 for(int i=0;i<a_n;i++) a_cs = a_cs*3+(unsign 18 for(int i=0;i<a_n;i++) a_cs = a_cs*3+(unsigned int)a_dims[i];
19 } 19 }
20 20
21 inline void fill_vec(obj_list<streamer_info>& 21 inline void fill_vec(obj_list<streamer_info>& a_infos,const std::string& a_type,streamer__info::Type a_si_type) {
22 unsigned int check = 196608; 22 unsigned int check = 196608;
23 streamer_info* info = new streamer_info(std: 23 streamer_info* info = new streamer_info(std::string("vector<")+a_type+">",4,check);
24 a_infos.push_back(info); 24 a_infos.push_back(info);
25 info->add(new streamer_STL("This","Used to c 25 info->add(new streamer_STL("This","Used to call the proper TStreamerInfo case",0,a_si_type,std::string("vector<")+a_type+">"));
26 } 26 }
27 27
28 inline int size_VIRTUAL() {return 4;} 28 inline int size_VIRTUAL() {return 4;}
29 29
30 inline int size_TObject() {return 12;} 30 inline int size_TObject() {return 12;}
31 inline int size_TNamed() {return 28;} 31 inline int size_TNamed() {return 28;}
32 32
33 inline void fill_infos_core(obj_list<streamer_ 33 inline void fill_infos_core(obj_list<streamer_info>& a_infos,std::ostream& a_out) {
34 34
35 // sizeof(TString) = 8 (4 (virtual ~) + 1 35 // sizeof(TString) = 8 (4 (virtual ~) + 1 + 3 (align))
36 // sizeof(TObject) = 12 36 // sizeof(TObject) = 12
37 // sizeof(TNamed) = 28 37 // sizeof(TNamed) = 28
38 // sizeof(TObjArray) = 40 38 // sizeof(TObjArray) = 40
39 // sizeof(TArray) = 8 39 // sizeof(TArray) = 8
40 // sizeof(TArrayI) = 12 40 // sizeof(TArrayI) = 12
41 // sizeof(TArrayD) = 12 41 // sizeof(TArrayD) = 12
42 // sizeof(TArrayF) = 12 42 // sizeof(TArrayF) = 12
43 43
44 const int size_POINTER = 4; 44 const int size_POINTER = 4;
45 //const int size_OBJECT_POINTER = 4; 45 //const int size_OBJECT_POINTER = 4;
46 //const int size_COUNTER = 4; 46 //const int size_COUNTER = 4;
47 47
48 const int size_TArray = 8; 48 const int size_TArray = 8;
49 49
50 short TArray_version = 1; 50 short TArray_version = 1;
51 51
52 short TObject_version = 1; 52 short TObject_version = 1;
53 {unsigned int check = 0; 53 {unsigned int check = 0;
54 //this : 54 //this :
55 scs(check,"TObject"); 55 scs(check,"TObject");
56 //members : 56 //members :
57 scs(check,"fUniqueID"); 57 scs(check,"fUniqueID");
58 scs(check,"UInt_t"); 58 scs(check,"UInt_t");
59 59
60 scs(check,"fBits"); 60 scs(check,"fBits");
61 scs(check,"UInt_t"); 61 scs(check,"UInt_t");
62 62
63 streamer_info* info = new streamer_info("TOb 63 streamer_info* info = new streamer_info("TObject",1,check);
64 a_infos.push_back(info); 64 a_infos.push_back(info);
65 // Elements : 65 // Elements :
66 int ofs = size_VIRTUAL(); 66 int ofs = size_VIRTUAL();
67 info->add(new streamer_uint(ofs,"fUniqueID", 67 info->add(new streamer_uint(ofs,"fUniqueID","object unique identifier"));
68 info->add(new streamer_uint(ofs,"fBits","bit 68 info->add(new streamer_uint(ofs,"fBits","bit field status word"));
69 if(ofs!=size_TObject()) { 69 if(ofs!=size_TObject()) {
70 a_out << "tools::wroot::fill_infos :" 70 a_out << "tools::wroot::fill_infos :"
71 << " TObject " << ofs << " (" << siz 71 << " TObject " << ofs << " (" << size_TObject() << " expected.)"
72 << std::endl; 72 << std::endl;
73 }} 73 }}
74 74
75 short TNamed_version = 1; 75 short TNamed_version = 1;
76 {unsigned int check = 0; 76 {unsigned int check = 0;
77 //this : 77 //this :
78 scs(check,"TNamed"); 78 scs(check,"TNamed");
79 //base : 79 //base :
80 scs(check,"TObject"); 80 scs(check,"TObject");
81 //members : 81 //members :
82 scs(check,"fName"); 82 scs(check,"fName");
83 scs(check,"TString"); 83 scs(check,"TString");
84 84
85 scs(check,"fTitle"); 85 scs(check,"fTitle");
86 scs(check,"TString"); 86 scs(check,"TString");
87 87
88 streamer_info* info = new streamer_info("TNa 88 streamer_info* info = new streamer_info("TNamed",1,check);
89 a_infos.push_back(info); 89 a_infos.push_back(info);
90 // Elements : 90 // Elements :
91 int ofs = 0; 91 int ofs = 0;
92 info->add(new streamer_base("TObject","Basic 92 info->add(new streamer_base("TObject","Basic ROOT object",ofs,TObject_version));ofs += size_TObject();
93 info->add(new streamer_string(ofs,"fName","o 93 info->add(new streamer_string(ofs,"fName","object identifier"));
94 info->add(new streamer_string(ofs,"fTitle"," 94 info->add(new streamer_string(ofs,"fTitle","object title"));
95 if(ofs!=size_TNamed()){ 95 if(ofs!=size_TNamed()){
96 a_out << "tools::wroot::fill_infos :" 96 a_out << "tools::wroot::fill_infos :"
97 << " TNamed " << ofs << " (" << size 97 << " TNamed " << ofs << " (" << size_TNamed() << " expected.)"
98 << std::endl; 98 << std::endl;
99 }} 99 }}
100 100
101 {unsigned int check = 0; 101 {unsigned int check = 0;
102 //this : 102 //this :
103 scs(check,"TStreamerInfo"); 103 scs(check,"TStreamerInfo");
104 //bases : 104 //bases :
105 scs(check,"TNamed"); 105 scs(check,"TNamed");
106 //members : 106 //members :
107 scs(check,"fCheckSum"); 107 scs(check,"fCheckSum");
108 scs(check,"UInt_t"); 108 scs(check,"UInt_t");
109 109
110 scs(check,"fClassVersion"); 110 scs(check,"fClassVersion");
111 scs(check,"Int_t"); 111 scs(check,"Int_t");
112 112
113 scs(check,"fElements"); 113 scs(check,"fElements");
114 scs(check,"TObjArray*"); 114 scs(check,"TObjArray*");
115 115
116 streamer_info* info = new streamer_info("TSt 116 streamer_info* info = new streamer_info("TStreamerInfo",2,check);
117 a_infos.push_back(info); 117 a_infos.push_back(info);
118 // Elements : 118 // Elements :
119 info->add(new streamer_base("TNamed","The ba 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","che 120 info->add(new streamer_uint("fCheckSum","checksum of original class",28));//4
121 info->add(new streamer_int("fClassVersion"," 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= 122 //40 = 2*int+4*int_p+2*ulong_p+bool+p (bool=4 !)
123 info->add(new streamer_object_pointer("fElem 123 info->add(new streamer_object_pointer("fElements","Array of TStreamerElements",76,"TObjArray*"));//4
124 124
125 //80 125 //80
126 } 126 }
127 127
128 short TStreamerElement_version = 2; 128 short TStreamerElement_version = 2;
129 {unsigned int check = 0; 129 {unsigned int check = 0;
130 //this : 130 //this :
131 scs(check,"TStreamerElement"); 131 scs(check,"TStreamerElement");
132 //bases : 132 //bases :
133 scs(check,"TNamed"); 133 scs(check,"TNamed");
134 //members : 134 //members :
135 scs(check,"fType"); 135 scs(check,"fType");
136 scs(check,"Int_t"); 136 scs(check,"Int_t");
137 137
138 scs(check,"fSize"); 138 scs(check,"fSize");
139 scs(check,"Int_t"); 139 scs(check,"Int_t");
140 140
141 scs(check,"fArrayLength"); 141 scs(check,"fArrayLength");
142 scs(check,"Int_t"); 142 scs(check,"Int_t");
143 143
144 scs(check,"fArrayDim"); 144 scs(check,"fArrayDim");
145 scs(check,"Int_t"); 145 scs(check,"Int_t");
146 146
147 scs(check,"fMaxIndex"); 147 scs(check,"fMaxIndex");
148 scs(check,"Int_t"); 148 scs(check,"Int_t");
149 int dim = 5; 149 int dim = 5;
150 acs(check,1,&dim); 150 acs(check,1,&dim);
151 151
152 scs(check,"fTypeName"); 152 scs(check,"fTypeName");
153 scs(check,"TString"); 153 scs(check,"TString");
154 //Should be : 2369818458U 154 //Should be : 2369818458U
155 155
156 streamer_info* info = new streamer_info("TSt 156 streamer_info* info = new streamer_info("TStreamerElement",2,check);
157 a_infos.push_back(info); 157 a_infos.push_back(info);
158 // Elements : 158 // Elements :
159 info->add(new streamer_base("TNamed","The ba 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 160 info->add(new streamer_int("fType","element type",28));
161 info->add(new streamer_int("fSize","sizeof e 161 info->add(new streamer_int("fSize","sizeof element",32));
162 info->add(new streamer_int("fArrayLength","c 162 info->add(new streamer_int("fArrayLength","cumulative size of all array dims",36));
163 info->add(new streamer_int("fArrayDim","numb 163 info->add(new streamer_int("fArrayDim","number of array dimensions",40));
164 164
165 {streamer_element* elem = new streamer_int("f 165 {streamer_element* elem = new streamer_int("fMaxIndex","Maximum array index for array dimension \"dim\"",44);
166 info->add(elem); 166 info->add(elem);
167 elem->setArrayDimension(1); 167 elem->setArrayDimension(1);
168 elem->setMaxIndex(0,5);} 168 elem->setMaxIndex(0,5);}
169 169
170 info->add(new streamer_string("fTypeName","D 170 info->add(new streamer_string("fTypeName","Data type name of data member",72));}
171 171
172 {unsigned int check = 0; 172 {unsigned int check = 0;
173 //this : 173 //this :
174 scs(check,"TStreamerBase"); 174 scs(check,"TStreamerBase");
175 //bases : 175 //bases :
176 scs(check,"TStreamerElement"); 176 scs(check,"TStreamerElement");
177 //members : 177 //members :
178 scs(check,"fBaseVersion"); 178 scs(check,"fBaseVersion");
179 scs(check,"Int_t"); 179 scs(check,"Int_t");
180 //Should be : 2671078514U 180 //Should be : 2671078514U
181 181
182 streamer_info* info = new streamer_info("TSt 182 streamer_info* info = new streamer_info("TStreamerBase",3,check);
183 a_infos.push_back(info); 183 a_infos.push_back(info);
184 // Elements : 184 // Elements :
185 info->add(new streamer_base("TStreamerElemen 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","v 186 info->add(new streamer_int("fBaseVersion","version number of the base class",88));}
187 187
188 {unsigned int check = 0; 188 {unsigned int check = 0;
189 //this : 189 //this :
190 scs(check,"TStreamerString"); 190 scs(check,"TStreamerString");
191 //bases : 191 //bases :
192 scs(check,"TStreamerElement"); 192 scs(check,"TStreamerElement");
193 //Should be : 2525579865U 193 //Should be : 2525579865U
194 194
195 streamer_info* info = new streamer_info("TSt 195 streamer_info* info = new streamer_info("TStreamerString",2,check);
196 a_infos.push_back(info); 196 a_infos.push_back(info);
197 // Elements : 197 // Elements :
198 info->add(new streamer_base("TStreamerElemen 198 info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
199 199
200 {unsigned int check = 0; 200 {unsigned int check = 0;
201 //this : 201 //this :
202 scs(check,"TStreamerBasicType"); 202 scs(check,"TStreamerBasicType");
203 //bases : 203 //bases :
204 scs(check,"TStreamerElement"); 204 scs(check,"TStreamerElement");
205 //Should be : 3001875966U; 205 //Should be : 3001875966U;
206 206
207 streamer_info* info = new streamer_info("TSt 207 streamer_info* info = new streamer_info("TStreamerBasicType",2,check);
208 a_infos.push_back(info); 208 a_infos.push_back(info);
209 // Elements : 209 // Elements :
210 info->add(new streamer_base("TStreamerElemen 210 info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
211 211
212 {unsigned int check = 0; 212 {unsigned int check = 0;
213 //this : 213 //this :
214 scs(check,"TStreamerBasicPointer"); 214 scs(check,"TStreamerBasicPointer");
215 //bases : 215 //bases :
216 scs(check,"TStreamerElement"); 216 scs(check,"TStreamerElement");
217 //members : 217 //members :
218 scs(check,"fCountVersion"); 218 scs(check,"fCountVersion");
219 scs(check,"Int_t"); 219 scs(check,"Int_t");
220 220
221 scs(check,"fCountName"); 221 scs(check,"fCountName");
222 scs(check,"TString"); 222 scs(check,"TString");
223 223
224 scs(check,"fCountClass"); 224 scs(check,"fCountClass");
225 scs(check,"TString"); 225 scs(check,"TString");
226 //Should be : 1587298059U 226 //Should be : 1587298059U
227 227
228 streamer_info* info = new streamer_info("TSt 228 streamer_info* info = new streamer_info("TStreamerBasicPointer",2,check);
229 a_infos.push_back(info); 229 a_infos.push_back(info);
230 // Elements : 230 // Elements :
231 info->add(new streamer_base("TStreamerElemen 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"," 232 info->add(new streamer_int("fCountVersion","version number of the class with the counter",88));
233 info->add(new streamer_string("fCountName"," 233 info->add(new streamer_string("fCountName","name of data member holding the array count",92));
234 info->add(new streamer_string("fCountClass", 234 info->add(new streamer_string("fCountClass","name of the class with the counter",100));}
235 235
236 {unsigned int check = 0; 236 {unsigned int check = 0;
237 //this : 237 //this :
238 scs(check,"TStreamerObject"); 238 scs(check,"TStreamerObject");
239 //bases : 239 //bases :
240 scs(check,"TStreamerElement"); 240 scs(check,"TStreamerElement");
241 //Should be : 2177456715U 241 //Should be : 2177456715U
242 242
243 streamer_info* info = new streamer_info("TSt 243 streamer_info* info = new streamer_info("TStreamerObject",2,check);
244 a_infos.push_back(info); 244 a_infos.push_back(info);
245 // Elements : 245 // Elements :
246 info->add(new streamer_base("TStreamerElemen 246 info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
247 247
248 {unsigned int check = 0; 248 {unsigned int check = 0;
249 //this : 249 //this :
250 scs(check,"TStreamerObjectPointer"); 250 scs(check,"TStreamerObjectPointer");
251 //bases : 251 //bases :
252 scs(check,"TStreamerElement"); 252 scs(check,"TStreamerElement");
253 //Should be : 720556968U 253 //Should be : 720556968U
254 254
255 streamer_info* info = new streamer_info("TSt 255 streamer_info* info = new streamer_info("TStreamerObjectPointer",2,check);
256 a_infos.push_back(info); 256 a_infos.push_back(info);
257 // Elements : 257 // Elements :
258 info->add(new streamer_base("TStreamerElemen 258 info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
259 259
260 {unsigned int check = 0; 260 {unsigned int check = 0;
261 //this : 261 //this :
262 scs(check,"TStreamerObjectAny"); 262 scs(check,"TStreamerObjectAny");
263 //bases : 263 //bases :
264 scs(check,"TStreamerElement"); 264 scs(check,"TStreamerElement");
265 //Should be : 3108880127U 265 //Should be : 3108880127U
266 266
267 streamer_info* info = new streamer_info("TSt 267 streamer_info* info = new streamer_info("TStreamerObjectAny",2,check);
268 a_infos.push_back(info); 268 a_infos.push_back(info);
269 // Elements : 269 // Elements :
270 info->add(new streamer_base("TStreamerElemen 270 info->add(new streamer_base("TStreamerElement","base class for one element (data member) to be Streamed",0,TStreamerElement_version));}
271 271
272 {unsigned int check = 0; 272 {unsigned int check = 0;
273 //this : 273 //this :
274 scs(check,"TArray"); 274 scs(check,"TArray");
275 //members : 275 //members :
276 scs(check,"fN"); 276 scs(check,"fN");
277 scs(check,"Int_t"); 277 scs(check,"Int_t");
278 278
279 streamer_info* info = new streamer_info("TAr 279 streamer_info* info = new streamer_info("TArray",1,check);
280 a_infos.push_back(info); 280 a_infos.push_back(info);
281 281
282 // Elements : 282 // Elements :
283 int ofs = 0; 283 int ofs = 0;
284 ofs += size_VIRTUAL(); 284 ofs += size_VIRTUAL();
285 info->add(new streamer_int(ofs,"fN","Number 285 info->add(new streamer_int(ofs,"fN","Number of array elements"));
286 //size_TArray = ofs; //8 286 //size_TArray = ofs; //8
287 } 287 }
288 288
289 {unsigned int check = 0; 289 {unsigned int check = 0;
290 //this : 290 //this :
291 scs(check,"TArrayI"); 291 scs(check,"TArrayI");
292 //base : 292 //base :
293 scs(check,"TArray"); 293 scs(check,"TArray");
294 //members : 294 //members :
295 scs(check,"fArray"); 295 scs(check,"fArray");
296 scs(check,"Int_t*"); 296 scs(check,"Int_t*");
297 297
298 streamer_info* info = new streamer_info("TAr 298 streamer_info* info = new streamer_info("TArrayI",1,check);
299 a_infos.push_back(info); 299 a_infos.push_back(info);
300 300
301 // Elements : 301 // Elements :
302 int offset = 0; 302 int offset = 0;
303 info->add(new streamer_base("TArray","Abstra 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 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 305
306 //12 306 //12
307 } 307 }
308 308
309 {unsigned int check = 0; 309 {unsigned int check = 0;
310 //this : 310 //this :
311 scs(check,"TArrayD"); 311 scs(check,"TArrayD");
312 //base : 312 //base :
313 scs(check,"TArray"); 313 scs(check,"TArray");
314 //members : 314 //members :
315 scs(check,"fArray"); 315 scs(check,"fArray");
316 scs(check,"Double_t*"); 316 scs(check,"Double_t*");
317 317
318 streamer_info* info = new streamer_info("TAr 318 streamer_info* info = new streamer_info("TArrayD",1,check);
319 a_infos.push_back(info); 319 a_infos.push_back(info);
320 320
321 // Elements : 321 // Elements :
322 int offset = 0; 322 int offset = 0;
323 info->add(new streamer_base("TArray","Abstra 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 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 325
326 //12 326 //12
327 } 327 }
328 328
329 {unsigned int check = 0; 329 {unsigned int check = 0;
330 //this : 330 //this :
331 scs(check,"TArrayF"); 331 scs(check,"TArrayF");
332 //base : 332 //base :
333 scs(check,"TArray"); 333 scs(check,"TArray");
334 //members : 334 //members :
335 scs(check,"fArray"); 335 scs(check,"fArray");
336 scs(check,"Float_t*"); 336 scs(check,"Float_t*");
337 337
338 streamer_info* info = new streamer_info("TAr 338 streamer_info* info = new streamer_info("TArrayF",1,check);
339 a_infos.push_back(info); 339 a_infos.push_back(info);
340 340
341 // Elements : 341 // Elements :
342 int offset = 0; 342 int offset = 0;
343 info->add(new streamer_base("TArray","Abstra 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 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 345
346 //12 346 //12
347 } 347 }
348 348
349 fill_vec(a_infos,"char",streamer__info::CHAR 349 fill_vec(a_infos,"char",streamer__info::CHAR);
350 fill_vec(a_infos,"short",streamer__info::SHO 350 fill_vec(a_infos,"short",streamer__info::SHORT);
351 fill_vec(a_infos,"int",streamer__info::INT); 351 fill_vec(a_infos,"int",streamer__info::INT);
352 fill_vec(a_infos,"unsigned char",streamer__i 352 fill_vec(a_infos,"unsigned char",streamer__info::UNSIGNED_CHAR);
353 fill_vec(a_infos,"unsigned short",streamer__ 353 fill_vec(a_infos,"unsigned short",streamer__info::UNSIGNED_SHORT);
354 fill_vec(a_infos,"unsigned int",streamer__in 354 fill_vec(a_infos,"unsigned int",streamer__info::UNSIGNED_INT);
355 fill_vec(a_infos,"float",streamer__info::FLO 355 fill_vec(a_infos,"float",streamer__info::FLOAT);
356 fill_vec(a_infos,"double",streamer__info::DO 356 fill_vec(a_infos,"double",streamer__info::DOUBLE);
357 fill_vec(a_infos,"bool",streamer__info::BOOL 357 fill_vec(a_infos,"bool",streamer__info::BOOL);
358 358
359 } 359 }
360 360
361 inline void fill_infos_cont(obj_list<streamer_ 361 inline void fill_infos_cont(obj_list<streamer_info>& a_infos,std::ostream&) {
362 362
363 // sizeof(TString) = 8 (4 (virtual ~) + 1 363 // sizeof(TString) = 8 (4 (virtual ~) + 1 + 3 (align))
364 // sizeof(TObject) = 12 364 // sizeof(TObject) = 12
365 365
366 short TObject_version = 1; 366 short TObject_version = 1;
367 367
368 const int size_POINTER = 4; 368 const int size_POINTER = 4;
369 const int size_BOOL = 4; 369 const int size_BOOL = 4;
370 370
371 int size_TCollection = 0; 371 int size_TCollection = 0;
372 short TCollection_version = 3; 372 short TCollection_version = 3;
373 {unsigned int check = 0; 373 {unsigned int check = 0;
374 //this : 374 //this :
375 scs(check,"TCollection"); 375 scs(check,"TCollection");
376 //base : 376 //base :
377 scs(check,"TObject"); 377 scs(check,"TObject");
378 //members : 378 //members :
379 scs(check,"fName"); 379 scs(check,"fName");
380 scs(check,"TString"); 380 scs(check,"TString");
381 381
382 scs(check,"fSize"); 382 scs(check,"fSize");
383 scs(check,"Int_t"); 383 scs(check,"Int_t");
384 384
385 streamer_info* info = new streamer_info("TCo 385 streamer_info* info = new streamer_info("TCollection",TCollection_version,check);
386 a_infos.push_back(info); 386 a_infos.push_back(info);
387 // Elements : 387 // Elements :
388 int ofs = 0; 388 int ofs = 0;
389 info->add(new streamer_base("TObject","Basic 389 info->add(new streamer_base("TObject","Basic ROOT object",ofs,TObject_version));ofs += size_TObject();
390 info->add(new streamer_string(ofs,"fName","n 390 info->add(new streamer_string(ofs,"fName","name of the collection"));
391 info->add(new streamer_int(ofs,"fSize","numb 391 info->add(new streamer_int(ofs,"fSize","number of elements in collection"));
392 size_TCollection = ofs; 392 size_TCollection = ofs;
393 } 393 }
394 394
395 int size_TSeqCollection = 0; 395 int size_TSeqCollection = 0;
396 short TSeqCollection_version = 0; 396 short TSeqCollection_version = 0;
397 {unsigned int check = 0; 397 {unsigned int check = 0;
398 //this : 398 //this :
399 scs(check,"TSeqCollection"); 399 scs(check,"TSeqCollection");
400 //base : 400 //base :
401 scs(check,"TCollection"); 401 scs(check,"TCollection");
402 //members : 402 //members :
403 scs(check,"fSorted"); 403 scs(check,"fSorted");
404 scs(check,"Bool_t"); 404 scs(check,"Bool_t");
405 405
406 streamer_info* info = new streamer_info("TSe 406 streamer_info* info = new streamer_info("TSeqCollection",TSeqCollection_version,check);
407 a_infos.push_back(info); 407 a_infos.push_back(info);
408 // Elements : 408 // Elements :
409 int ofs = 0; 409 int ofs = 0;
410 info->add(new streamer_base("TCollection","C 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"," 411 info->add(new streamer_bool(ofs,"fSorted"," true if collection has been sorted"));
412 size_TSeqCollection = ofs; 412 size_TSeqCollection = ofs;
413 } 413 }
414 414
415 //int size_TList = 0; 415 //int size_TList = 0;
416 short TList_version = 4; 416 short TList_version = 4;
417 {unsigned int check = 0; 417 {unsigned int check = 0;
418 //this : 418 //this :
419 scs(check,"TList"); 419 scs(check,"TList");
420 //base : 420 //base :
421 scs(check,"TSeqCollection"); 421 scs(check,"TSeqCollection");
422 //members : 422 //members :
423 423
424 streamer_info* info = new streamer_info("TLi 424 streamer_info* info = new streamer_info("TList",TList_version,check);
425 a_infos.push_back(info); 425 a_infos.push_back(info);
426 // Elements : 426 // Elements :
427 int ofs = 0; 427 int ofs = 0;
428 info->add(new streamer_base("TSeqCollection" 428 info->add(new streamer_base("TSeqCollection","Sequenceable collection abstract base class",ofs,TSeqCollection_version));ofs += size_TSeqCollection;
429 ofs += size_POINTER; //!*fFirst 429 ofs += size_POINTER; //!*fFirst
430 ofs += size_POINTER; //!*fLast 430 ofs += size_POINTER; //!*fLast
431 ofs += size_POINTER; //!*fCache 431 ofs += size_POINTER; //!*fCache
432 ofs += size_BOOL; //!fAscending 432 ofs += size_BOOL; //!fAscending
433 //size_TList = ofs; 433 //size_TList = ofs;
434 } 434 }
435 } 435 }
436 436
437 inline int size_TAttLine() {return 10;} //12? 437 inline int size_TAttLine() {return 10;} //12?
438 inline int size_TAttFill() {return 8;} 438 inline int size_TAttFill() {return 8;}
439 inline int size_TAttMarker() {return 12;} 439 inline int size_TAttMarker() {return 12;}
440 440
441 inline void fill_infos_graf(obj_list<streamer_ 441 inline void fill_infos_graf(obj_list<streamer_info>& a_infos,std::ostream& a_out) {
442 442
443 //sizeof(Font_t) = 2 443 //sizeof(Font_t) = 2
444 //sizeof(Style_t) = 2 444 //sizeof(Style_t) = 2
445 //sizeof(Marker_t) = 2 445 //sizeof(Marker_t) = 2
446 //sizeof(Width_t) = 2 446 //sizeof(Width_t) = 2
447 //sizeof(Size_t) = 4 447 //sizeof(Size_t) = 4
448 448
449 const int size_SHORT = 2; 449 const int size_SHORT = 2;
450 const int size_FLOAT = 4; 450 const int size_FLOAT = 4;
451 451
452 {unsigned int check = 0; 452 {unsigned int check = 0;
453 //this : 453 //this :
454 scs(check,"TAttLine"); 454 scs(check,"TAttLine");
455 //members : 455 //members :
456 scs(check,"fLineColor"); 456 scs(check,"fLineColor");
457 scs(check,"Color_t"); 457 scs(check,"Color_t");
458 458
459 scs(check,"fLineStyle"); 459 scs(check,"fLineStyle");
460 scs(check,"Style_t"); 460 scs(check,"Style_t");
461 461
462 scs(check,"fLineWidth"); 462 scs(check,"fLineWidth");
463 scs(check,"Width_t"); 463 scs(check,"Width_t");
464 464
465 //Should be : 1369587346U 465 //Should be : 1369587346U
466 466
467 // Beurk ; but the ROOT TTree compells indir 467 // Beurk ; but the ROOT TTree compells indirectly the below.
468 streamer_info* info = new streamer_info("TAt 468 streamer_info* info = new streamer_info("TAttLine",1,check);
469 a_infos.push_back(info); 469 a_infos.push_back(info);
470 // Elements : 470 // Elements :
471 int ofs = size_VIRTUAL(); 471 int ofs = size_VIRTUAL();
472 info->add(new streamer_basic_type("fLineColo 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("fLineStyl 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("fLineWidt 474 info->add(new streamer_basic_type("fLineWidth","line width",ofs,streamer__info::SHORT,"Width_t"));ofs += size_SHORT;
475 //2 (alignement ???) 475 //2 (alignement ???)
476 if(ofs!=size_TAttLine()) { 476 if(ofs!=size_TAttLine()) {
477 a_out << "tools::wroot::fill_infos :" 477 a_out << "tools::wroot::fill_infos :"
478 << " TAttLine " << ofs << " (" << si 478 << " TAttLine " << ofs << " (" << size_TAttLine() << " expected.)"
479 << std::endl; 479 << std::endl;
480 }} 480 }}
481 481
482 {unsigned int check = 0; 482 {unsigned int check = 0;
483 //this : 483 //this :
484 scs(check,"TAttFill"); 484 scs(check,"TAttFill");
485 //members : 485 //members :
486 scs(check,"fFillColor"); 486 scs(check,"fFillColor");
487 scs(check,"Color_t"); 487 scs(check,"Color_t");
488 488
489 scs(check,"fFillStyle"); 489 scs(check,"fFillStyle");
490 scs(check,"Style_t"); 490 scs(check,"Style_t");
491 491
492 //Should be : 1204118360U 492 //Should be : 1204118360U
493 streamer_info* info = new streamer_info("TAt 493 streamer_info* info = new streamer_info("TAttFill",1,check);
494 a_infos.push_back(info); 494 a_infos.push_back(info);
495 // Elements : 495 // Elements :
496 int ofs = size_VIRTUAL(); 496 int ofs = size_VIRTUAL();
497 info->add(new streamer_basic_type("fFillColo 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("fFillStyl 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()) { 499 if(ofs!=size_TAttFill()) {
500 a_out << "tools::wroot::fill_infos :" 500 a_out << "tools::wroot::fill_infos :"
501 << " TAttFill " << ofs << " (" << si 501 << " TAttFill " << ofs << " (" << size_TAttFill() << " expected.)"
502 << std::endl; 502 << std::endl;
503 }} 503 }}
504 504
505 {unsigned int check = 0; 505 {unsigned int check = 0;
506 //this : 506 //this :
507 scs(check,"TAttMarker"); 507 scs(check,"TAttMarker");
508 //members : 508 //members :
509 scs(check,"fMarkerColor"); 509 scs(check,"fMarkerColor");
510 scs(check,"Color_t"); 510 scs(check,"Color_t");
511 511
512 scs(check,"fMarkerStyle"); 512 scs(check,"fMarkerStyle");
513 scs(check,"Style_t"); 513 scs(check,"Style_t");
514 514
515 scs(check,"fMarkerSize"); 515 scs(check,"fMarkerSize");
516 scs(check,"Size_t"); 516 scs(check,"Size_t");
517 517
518 //Should be 4207747460U 518 //Should be 4207747460U
519 519
520 streamer_info* info = new streamer_info("TAt 520 streamer_info* info = new streamer_info("TAttMarker",1,check);
521 a_infos.push_back(info); 521 a_infos.push_back(info);
522 // Elements : 522 // Elements :
523 int ofs = size_VIRTUAL(); 523 int ofs = size_VIRTUAL();
524 info->add(new streamer_basic_type("fMarkerCo 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("fMarkerSt 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("fMarkerSi 526 info->add(new streamer_basic_type("fMarkerSize","Marker size",ofs,streamer__info::FLOAT,"Size_t"));ofs += size_FLOAT;
527 if(ofs!=size_TAttMarker()) { 527 if(ofs!=size_TAttMarker()) {
528 a_out << "tools::wroot::fill_infos :" 528 a_out << "tools::wroot::fill_infos :"
529 << " TAttMarker " << ofs << " (" << 529 << " TAttMarker " << ofs << " (" << size_TAttMarker() << " expected.)"
530 << std::endl; 530 << std::endl;
531 }} 531 }}
532 532
533 } 533 }
534 534
535 inline int size_TBranch() {return 264;} //256? 535 inline int size_TBranch() {return 264;} //256?
536 inline int size_TLeaf() {return 60;} //52? 536 inline int size_TLeaf() {return 60;} //52?
537 inline int size_TTree() {return 254;} //240? 537 inline int size_TTree() {return 254;} //240?
538 538
539 inline void fill_infos_tree(obj_list<streamer_ 539 inline void fill_infos_tree(obj_list<streamer_info>& a_infos,std::ostream& a_out) {
540 540
541 const int size_CHAR = 1; 541 const int size_CHAR = 1;
542 const int size_INT = 4; 542 const int size_INT = 4;
543 const int size_POINTER = 4; 543 const int size_POINTER = 4;
544 const int size_COUNTER = 4; 544 const int size_COUNTER = 4;
545 545
546 const int size_TObjArray = 40; 546 const int size_TObjArray = 40;
547 const int size_TArrayD = 12; 547 const int size_TArrayD = 12;
548 const int size_TArrayI = 12; 548 const int size_TArrayI = 12;
549 549
550 short TNamed_version = 1; 550 short TNamed_version = 1;
551 551
552 short TAttLine_version = 1; 552 short TAttLine_version = 1;
553 short TAttFill_version = 1; 553 short TAttFill_version = 1;
554 short TAttMarker_version = 1; 554 short TAttMarker_version = 1;
555 short TBranch_version = 8; 555 short TBranch_version = 8;
556 short TLeaf_version = 2; 556 short TLeaf_version = 2;
557 557
558 {unsigned int check = 0; 558 {unsigned int check = 0;
559 //this : 559 //this :
560 scs(check,"TTree"); 560 scs(check,"TTree");
561 //bases : 561 //bases :
562 scs(check,"TNamed"); 562 scs(check,"TNamed");
563 scs(check,"TAttLine"); 563 scs(check,"TAttLine");
564 scs(check,"TAttFill"); 564 scs(check,"TAttFill");
565 scs(check,"TAttMarker"); 565 scs(check,"TAttMarker");
566 //members : 566 //members :
567 scs(check,"fEntries"); 567 scs(check,"fEntries");
568 scs(check,"Stat_t"); 568 scs(check,"Stat_t");
569 569
570 scs(check,"fTotBytes"); 570 scs(check,"fTotBytes");
571 scs(check,"Stat_t"); 571 scs(check,"Stat_t");
572 572
573 scs(check,"fZipBytes"); 573 scs(check,"fZipBytes");
574 scs(check,"Stat_t"); 574 scs(check,"Stat_t");
575 575
576 scs(check,"fSavedBytes"); 576 scs(check,"fSavedBytes");
577 scs(check,"Stat_t"); 577 scs(check,"Stat_t");
578 578
579 scs(check,"fTimerInterval"); 579 scs(check,"fTimerInterval");
580 scs(check,"Int_t"); 580 scs(check,"Int_t");
581 581
582 scs(check,"fScanField"); 582 scs(check,"fScanField");
583 scs(check,"Int_t"); 583 scs(check,"Int_t");
584 584
585 scs(check,"fUpdate"); 585 scs(check,"fUpdate");
586 scs(check,"Int_t"); 586 scs(check,"Int_t");
587 587
588 scs(check,"fMaxEntryLoop"); 588 scs(check,"fMaxEntryLoop");
589 scs(check,"Int_t"); 589 scs(check,"Int_t");
590 590
591 scs(check,"fMaxVirtualSize"); 591 scs(check,"fMaxVirtualSize");
592 scs(check,"Int_t"); 592 scs(check,"Int_t");
593 593
594 scs(check,"fAutoSave"); 594 scs(check,"fAutoSave");
595 scs(check,"Int_t"); 595 scs(check,"Int_t");
596 596
597 scs(check,"fEstimate"); 597 scs(check,"fEstimate");
598 scs(check,"Int_t"); 598 scs(check,"Int_t");
599 599
600 scs(check,"fBranches"); 600 scs(check,"fBranches");
601 scs(check,"TObjArray"); 601 scs(check,"TObjArray");
602 602
603 scs(check,"fLeaves"); 603 scs(check,"fLeaves");
604 scs(check,"TObjArray"); 604 scs(check,"TObjArray");
605 605
606 //scs(check,"fAliases"); 606 //scs(check,"fAliases");
607 //scs(check,"TList*"); 607 //scs(check,"TList*");
608 608
609 scs(check,"fIndexValues"); 609 scs(check,"fIndexValues");
610 scs(check,"TArrayD"); 610 scs(check,"TArrayD");
611 611
612 scs(check,"fIndex"); 612 scs(check,"fIndex");
613 scs(check,"TArrayI"); 613 scs(check,"TArrayI");
614 614
615 //scs(check,"fFriends"); 615 //scs(check,"fFriends");
616 //scs(check,"TList*"); 616 //scs(check,"TList*");
617 //Should be : 3245044844U //3.00.06 617 //Should be : 3245044844U //3.00.06
618 //Should be : FIXME //3.10.02 618 //Should be : FIXME //3.10.02
619 619
620 streamer_info* info = new streamer_info("TTr 620 streamer_info* info = new streamer_info("TTree",5,check);
621 a_infos.push_back(info); 621 a_infos.push_back(info);
622 622
623 // Elements : 623 // Elements :
624 int ofs = 0; 624 int ofs = 0;
625 info->add(new streamer_base("TNamed","The ba 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 626 info->add(new streamer_base("TAttLine","Line attributes",ofs,TAttLine_version));ofs += size_TAttLine();
627 info->add(new streamer_base("TAttFill","Fill 627 info->add(new streamer_base("TAttFill","Fill area attributes",ofs,TAttFill_version));ofs += size_TAttFill();
628 info->add(new streamer_base("TAttMarker","Ma 628 info->add(new streamer_base("TAttMarker","Marker attributes",ofs,TAttMarker_version));ofs += size_TAttMarker();
629 629
630 info->add(new streamer_stat_t(ofs,"fEntries" 630 info->add(new streamer_stat_t(ofs,"fEntries","Number of entries"));
631 info->add(new streamer_stat_t(ofs,"fTotBytes 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 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,"fSavedByt 633 info->add(new streamer_stat_t(ofs,"fSavedBytes","Number of autosaved bytes"));
634 634
635 info->add(new streamer_int(ofs,"fTimerInterv 635 info->add(new streamer_int(ofs,"fTimerInterval","Timer interval in milliseconds"));
636 info->add(new streamer_int(ofs,"fScanField", 636 info->add(new streamer_int(ofs,"fScanField","Number of runs before prompting in Scan"));
637 info->add(new streamer_int(ofs,"fUpdate","Up 637 info->add(new streamer_int(ofs,"fUpdate","Update frequency for EntryLoop"));
638 info->add(new streamer_int(ofs,"fMaxEntryLoo 638 info->add(new streamer_int(ofs,"fMaxEntryLoop","Maximum number of entries to process"));
639 info->add(new streamer_int(ofs,"fMaxVirtualS 639 info->add(new streamer_int(ofs,"fMaxVirtualSize","Maximum total size of buffers kept in memory"));
640 info->add(new streamer_int(ofs,"fAutoSave"," 640 info->add(new streamer_int(ofs,"fAutoSave","Autosave tree when fAutoSave bytes produced"));
641 info->add(new streamer_int(ofs,"fEstimate"," 641 info->add(new streamer_int(ofs,"fEstimate","Number of entries to estimate histogram limits"));
642 ofs += size_INT; //!fChainOffset 642 ofs += size_INT; //!fChainOffset
643 ofs += size_INT; //!fReadEntry 643 ofs += size_INT; //!fReadEntry
644 ofs += size_INT; //!fTotalBuffers 644 ofs += size_INT; //!fTotalBuffers
645 ofs += size_INT; //!fPacketSize 645 ofs += size_INT; //!fPacketSize
646 ofs += size_INT; //!fNfill 646 ofs += size_INT; //!fNfill
647 ofs += size_POINTER; //!*fDirectory 647 ofs += size_POINTER; //!*fDirectory
648 info->add(new streamer_object("fBranches","L 648 info->add(new streamer_object("fBranches","List of Branches",ofs,"TObjArray"));ofs += size_TObjArray;
649 info->add(new streamer_object("fLeaves","Dir 649 info->add(new streamer_object("fLeaves","Direct pointers to individual branch leaves",ofs,"TObjArray"));ofs += size_TObjArray;
650 ofs += size_POINTER; //!*fEventList 650 ofs += size_POINTER; //!*fEventList
651 info->add(new streamer_object_any("fIndexVal 651 info->add(new streamer_object_any("fIndexValues","Sorted index values",ofs,"TArrayD"));ofs += size_TArrayD;
652 info->add(new streamer_object_any("fIndex"," 652 info->add(new streamer_object_any("fIndex","Index of sorted values",ofs,"TArrayI"));ofs += size_TArrayI;
653 ofs += size_POINTER; //!*fPlayer 653 ofs += size_POINTER; //!*fPlayer
654 654
655 if(ofs!=size_TTree()) { 655 if(ofs!=size_TTree()) {
656 a_out << "tools::wroot::fill_infos :" 656 a_out << "tools::wroot::fill_infos :"
657 << " TTree " << ofs << " (" << size_ 657 << " TTree " << ofs << " (" << size_TTree() << " expected.)"
658 << std::endl; 658 << std::endl;
659 } 659 }
660 660
661 //info->add(new streamer_object_pointer("fAl 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("fFr 662 //info->add(new streamer_object_pointer("fFriends","pointer to list of friend elements",offset,"TList*"));offset += size_OBJECT_POINTER;
663 } 663 }
664 664
665 //------------------------------------------ 665 //---------------------------------------------------------------------
666 {unsigned int check = 0; 666 {unsigned int check = 0;
667 //this : 667 //this :
668 scs(check,"TBranch"); 668 scs(check,"TBranch");
669 //bases : 669 //bases :
670 scs(check,"TNamed"); 670 scs(check,"TNamed");
671 scs(check,"TAttFill"); 671 scs(check,"TAttFill");
672 //members : 672 //members :
673 scs(check,"fCompress"); 673 scs(check,"fCompress");
674 scs(check,"Int_t"); 674 scs(check,"Int_t");
675 675
676 scs(check,"fBasketSize"); 676 scs(check,"fBasketSize");
677 scs(check,"Int_t"); 677 scs(check,"Int_t");
678 678
679 scs(check,"fEntryOffsetLen"); 679 scs(check,"fEntryOffsetLen");
680 scs(check,"Int_t"); 680 scs(check,"Int_t");
681 681
682 scs(check,"fWriteBasket"); 682 scs(check,"fWriteBasket");
683 scs(check,"Int_t"); 683 scs(check,"Int_t");
684 684
685 scs(check,"fEntryNumber"); 685 scs(check,"fEntryNumber");
686 scs(check,"Int_t"); 686 scs(check,"Int_t");
687 687
688 scs(check,"fOffset"); 688 scs(check,"fOffset");
689 scs(check,"Int_t"); 689 scs(check,"Int_t");
690 690
691 scs(check,"fMaxBaskets"); 691 scs(check,"fMaxBaskets");
692 scs(check,"Int_t"); 692 scs(check,"Int_t");
693 693
694 scs(check,"fSplitLevel"); 694 scs(check,"fSplitLevel");
695 scs(check,"Int_t"); 695 scs(check,"Int_t");
696 696
697 scs(check,"fEntries"); 697 scs(check,"fEntries");
698 scs(check,"Stat_t"); 698 scs(check,"Stat_t");
699 699
700 scs(check,"fTotBytes"); 700 scs(check,"fTotBytes");
701 scs(check,"Stat_t"); 701 scs(check,"Stat_t");
702 702
703 scs(check,"fZipBytes"); 703 scs(check,"fZipBytes");
704 scs(check,"Stat_t"); 704 scs(check,"Stat_t");
705 705
706 scs(check,"fBranches"); 706 scs(check,"fBranches");
707 scs(check,"TObjArray"); 707 scs(check,"TObjArray");
708 708
709 scs(check,"fLeaves"); 709 scs(check,"fLeaves");
710 scs(check,"TObjArray"); 710 scs(check,"TObjArray");
711 711
712 scs(check,"fBaskets"); 712 scs(check,"fBaskets");
713 scs(check,"TObjArray"); 713 scs(check,"TObjArray");
714 714
715 scs(check,"fBasketBytes"); 715 scs(check,"fBasketBytes");
716 scs(check,"Int_t*"); 716 scs(check,"Int_t*");
717 717
718 scs(check,"fBasketEntry"); 718 scs(check,"fBasketEntry");
719 scs(check,"Int_t*"); 719 scs(check,"Int_t*");
720 720
721 scs(check,"fBasketSeek"); 721 scs(check,"fBasketSeek");
722 scs(check,"Seek_t*"); 722 scs(check,"Seek_t*");
723 723
724 scs(check,"fFileName"); 724 scs(check,"fFileName");
725 scs(check,"TString"); 725 scs(check,"TString");
726 //Should be : 2056727376U (6 3.00.06) 726 //Should be : 2056727376U (6 3.00.06)
727 //Should be : FIXME (7 3.03.01) 727 //Should be : FIXME (7 3.03.01)
728 728
729 streamer_info* info = new streamer_info("TBr 729 streamer_info* info = new streamer_info("TBranch",8,check);
730 a_infos.push_back(info); 730 a_infos.push_back(info);
731 // Elements : 731 // Elements :
732 int ofs = 0; 732 int ofs = 0;
733 info->add(new streamer_base("TNamed","The ba 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 734 info->add(new streamer_base("TAttFill","Fill area attributes",ofs,TAttFill_version));ofs += size_TAttFill();
735 info->add(new streamer_int(ofs,"fCompress"," 735 info->add(new streamer_int(ofs,"fCompress","(=1 branch is compressed, 0 otherwise)"));
736 info->add(new streamer_int(ofs,"fBasketSize" 736 info->add(new streamer_int(ofs,"fBasketSize","Initial Size of Basket Buffer"));
737 info->add(new streamer_int(ofs,"fEntryOffset 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 738 info->add(new streamer_int(ofs,"fWriteBasket","Last basket number written"));
739 info->add(new streamer_int(ofs,"fEntryNumber 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","Of 740 info->add(new streamer_int(ofs,"fOffset","Offset of this branch"));
741 info->add(new streamer_basic_type("fMaxBaske 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" 742 info->add(new streamer_int(ofs,"fSplitLevel","Branch split level")); //3.03.01
743 ofs += size_INT; //!fNLeaves 743 ofs += size_INT; //!fNLeaves
744 ofs += size_INT; //!fReadBasket 744 ofs += size_INT; //!fReadBasket
745 ofs += size_INT; //!fReadEntry 745 ofs += size_INT; //!fReadEntry
746 info->add(new streamer_stat_t(ofs,"fEntries" 746 info->add(new streamer_stat_t(ofs,"fEntries","Number of entries"));
747 info->add(new streamer_stat_t(ofs,"fTotBytes 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 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","- 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","-> 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","-> 751 info->add(new streamer_object("fBaskets","-> List of baskets of this branch",ofs,"TObjArray"));ofs += size_TObjArray;
752 ofs += size_INT; //!fNBasketRAM 752 ofs += size_INT; //!fNBasketRAM
753 ofs += size_POINTER; //!*fBasketRAM 753 ofs += size_POINTER; //!*fBasketRAM
754 info->add(new streamer_basic_pointer("fBaske 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("fBaske 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("fBaske 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; //!*fTree 757 ofs += size_POINTER; //!*fTree
758 ofs += size_POINTER; //!*fAddress 758 ofs += size_POINTER; //!*fAddress
759 ofs += size_POINTER; //!*fDirectory 759 ofs += size_POINTER; //!*fDirectory
760 info->add(new streamer_string(ofs,"fFileName 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()) { 761 if(ofs!=size_TBranch()) {
762 a_out << "tools::wroot::fill_infos :" 762 a_out << "tools::wroot::fill_infos :"
763 << " TBranch " << ofs << " (" << siz 763 << " TBranch " << ofs << " (" << size_TBranch() << " expected.)"
764 << std::endl; 764 << std::endl;
765 }} 765 }}
766 766
767 {unsigned int check = 0; 767 {unsigned int check = 0;
768 //this : 768 //this :
769 scs(check,"TBranchObject"); 769 scs(check,"TBranchObject");
770 //bases : 770 //bases :
771 scs(check,"TBranch"); 771 scs(check,"TBranch");
772 //members : 772 //members :
773 scs(check,"fClassName"); 773 scs(check,"fClassName");
774 scs(check,"TString"); 774 scs(check,"TString");
775 775
776 //Should be : 2857878535U 776 //Should be : 2857878535U
777 777
778 streamer_info* info = new streamer_info("TBr 778 streamer_info* info = new streamer_info("TBranchObject",1,check);
779 a_infos.push_back(info); 779 a_infos.push_back(info);
780 // Elements : 780 // Elements :
781 int ofs = 0; 781 int ofs = 0;
782 info->add(new streamer_base("TBranch","Branc 782 info->add(new streamer_base("TBranch","Branch descriptor",ofs,TBranch_version));ofs += size_TBranch();
783 info->add(new streamer_string(ofs,"fClassNam 783 info->add(new streamer_string(ofs,"fClassName","Class name of referenced object"));
784 } 784 }
785 785
786 //------------------------------------------ 786 //---------------------------------------------------------------------
787 {unsigned int check = 0; 787 {unsigned int check = 0;
788 //this : 788 //this :
789 scs(check,"TBranchElement"); 789 scs(check,"TBranchElement");
790 //bases : 790 //bases :
791 scs(check,"TBranch"); 791 scs(check,"TBranch");
792 //members : 792 //members :
793 scs(check,"fClassName"); 793 scs(check,"fClassName");
794 scs(check,"TString"); 794 scs(check,"TString");
795 795
796 scs(check,"fClassVersion"); 796 scs(check,"fClassVersion");
797 scs(check,"Int_t"); 797 scs(check,"Int_t");
798 798
799 scs(check,"fID"); 799 scs(check,"fID");
800 scs(check,"Int_t"); 800 scs(check,"Int_t");
801 801
802 scs(check,"fType"); 802 scs(check,"fType");
803 scs(check,"Int_t"); 803 scs(check,"Int_t");
804 804
805 scs(check,"fStreamerType"); 805 scs(check,"fStreamerType");
806 scs(check,"Int_t"); 806 scs(check,"Int_t");
807 807
808 streamer_info* info = new streamer_info("TBr 808 streamer_info* info = new streamer_info("TBranchElement",1,check);
809 a_infos.push_back(info); 809 a_infos.push_back(info);
810 // Elements : 810 // Elements :
811 int offset = 0; 811 int offset = 0;
812 info->add(new streamer_base("TBranch","Branc 812 info->add(new streamer_base("TBranch","Branch descriptor",offset,TBranch_version));offset += size_TBranch();
813 info->add(new streamer_string(offset,"fClass 813 info->add(new streamer_string(offset,"fClassName","Class name of referenced object"));
814 info->add(new streamer_int(offset,"fClassVer 814 info->add(new streamer_int(offset,"fClassVersion","Version number of class"));
815 info->add(new streamer_int(offset,"fID","ele 815 info->add(new streamer_int(offset,"fID","element serial number in fInfo"));
816 info->add(new streamer_int(offset,"fType","b 816 info->add(new streamer_int(offset,"fType","branch type"));
817 info->add(new streamer_int(offset,"fStreamer 817 info->add(new streamer_int(offset,"fStreamerType","branch streamer type"));
818 818
819 } 819 }
820 820
821 {unsigned int check = 0; 821 {unsigned int check = 0;
822 //this : 822 //this :
823 scs(check,"TLeaf"); 823 scs(check,"TLeaf");
824 //bases : 824 //bases :
825 scs(check,"TNamed"); 825 scs(check,"TNamed");
826 //members : 826 //members :
827 scs(check,"fLen"); 827 scs(check,"fLen");
828 scs(check,"Int_t"); 828 scs(check,"Int_t");
829 829
830 scs(check,"fLenType"); 830 scs(check,"fLenType");
831 scs(check,"Int_t"); 831 scs(check,"Int_t");
832 832
833 scs(check,"fOffset"); 833 scs(check,"fOffset");
834 scs(check,"Int_t"); 834 scs(check,"Int_t");
835 835
836 scs(check,"fIsRange"); 836 scs(check,"fIsRange");
837 scs(check,"Bool_t"); 837 scs(check,"Bool_t");
838 838
839 scs(check,"fIsUnsigned"); 839 scs(check,"fIsUnsigned");
840 scs(check,"Bool_t"); 840 scs(check,"Bool_t");
841 841
842 scs(check,"fLeafCount"); 842 scs(check,"fLeafCount");
843 scs(check,"TLeaf*"); 843 scs(check,"TLeaf*");
844 844
845 //Should be : 727988519U 845 //Should be : 727988519U
846 846
847 streamer_info* info = new streamer_info("TLe 847 streamer_info* info = new streamer_info("TLeaf",2,check);
848 a_infos.push_back(info); 848 a_infos.push_back(info);
849 849
850 // Elements : 850 // Elements :
851 int ofs = 0; 851 int ofs = 0;
852 info->add(new streamer_base("TNamed","The ba 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; //!fNdata 853 ofs += size_INT; //!fNdata
854 info->add(new streamer_int(ofs,"fLen","Numbe 854 info->add(new streamer_int(ofs,"fLen","Number of fixed length elements"));
855 info->add(new streamer_int(ofs,"fLenType","N 855 info->add(new streamer_int(ofs,"fLenType","Number of bytes for this data type"));
856 info->add(new streamer_int(ofs,"fOffset","Of 856 info->add(new streamer_int(ofs,"fOffset","Offset in ClonesArray object (if one)"));
857 info->add(new streamer_bool(ofs,"fIsRange"," 857 info->add(new streamer_bool(ofs,"fIsRange","(=kTRUE if leaf has a range, kFALSE otherwise)"));
858 info->add(new streamer_bool(ofs,"fIsUnsigned 858 info->add(new streamer_bool(ofs,"fIsUnsigned","(=kTRUE if unsigned, kFALSE otherwise)"));
859 info->add(new streamer_object_pointer("fLeaf 859 info->add(new streamer_object_pointer("fLeafCount","Pointer to Leaf count if variable length",ofs,"TLeaf*"));ofs += size_POINTER;
860 ofs += size_POINTER; //!*fBranch 860 ofs += size_POINTER; //!*fBranch
861 if(ofs!=size_TLeaf()) { 861 if(ofs!=size_TLeaf()) {
862 a_out << "tools::wroot::fill_infos :" 862 a_out << "tools::wroot::fill_infos :"
863 << " TLeaf " << ofs << " (" << size_ 863 << " TLeaf " << ofs << " (" << size_TLeaf() << " expected.)"
864 << std::endl; 864 << std::endl;
865 }} 865 }}
866 866
867 {unsigned int check = 0; 867 {unsigned int check = 0;
868 //this : 868 //this :
869 scs(check,"TLeafS"); 869 scs(check,"TLeafS");
870 //bases : 870 //bases :
871 scs(check,"TLeaf"); 871 scs(check,"TLeaf");
872 //members : 872 //members :
873 scs(check,"fMinimum"); 873 scs(check,"fMinimum");
874 scs(check,"Short_t"); 874 scs(check,"Short_t");
875 875
876 scs(check,"fMaximum"); 876 scs(check,"fMaximum");
877 scs(check,"Short_t"); 877 scs(check,"Short_t");
878 878
879 //Should be : FIXME 879 //Should be : FIXME
880 880
881 streamer_info* info = new streamer_info("TLe 881 streamer_info* info = new streamer_info("TLeafS",1,check);
882 a_infos.push_back(info); 882 a_infos.push_back(info);
883 // Elements : 883 // Elements :
884 int ofs = 0; 884 int ofs = 0;
885 info->add(new streamer_base("TLeaf","Leaf: d 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", 886 info->add(new streamer_short(ofs,"fMinimum","Minimum value if leaf range is specified"));
887 info->add(new streamer_short(ofs,"fMaximum", 887 info->add(new streamer_short(ofs,"fMaximum","Maximum value if leaf range is specified"));
888 888
889 } 889 }
890 890
891 {unsigned int check = 0; 891 {unsigned int check = 0;
892 //this : 892 //this :
893 scs(check,"TLeafI"); 893 scs(check,"TLeafI");
894 //bases : 894 //bases :
895 scs(check,"TLeaf"); 895 scs(check,"TLeaf");
896 //members : 896 //members :
897 scs(check,"fMinimum"); 897 scs(check,"fMinimum");
898 scs(check,"Int_t"); 898 scs(check,"Int_t");
899 899
900 scs(check,"fMaximum"); 900 scs(check,"fMaximum");
901 scs(check,"Int_t"); 901 scs(check,"Int_t");
902 902
903 //Should be : 3495201397U 903 //Should be : 3495201397U
904 904
905 streamer_info* info = new streamer_info("TLe 905 streamer_info* info = new streamer_info("TLeafI",1,check);
906 a_infos.push_back(info); 906 a_infos.push_back(info);
907 907
908 // Elements : 908 // Elements :
909 int ofs = 0; 909 int ofs = 0;
910 info->add(new streamer_base("TLeaf","Leaf: d 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","M 911 info->add(new streamer_int(ofs,"fMinimum","Minimum value if leaf range is specified"));
912 info->add(new streamer_int(ofs,"fMaximum","M 912 info->add(new streamer_int(ofs,"fMaximum","Maximum value if leaf range is specified"));
913 //size_TLeafI = ofs; 913 //size_TLeafI = ofs;
914 } 914 }
915 915
916 {unsigned int check = 0; 916 {unsigned int check = 0;
917 //name : 917 //name :
918 scs(check,"TLeafF"); 918 scs(check,"TLeafF");
919 //bases : 919 //bases :
920 scs(check,"TLeaf"); 920 scs(check,"TLeaf");
921 //members : 921 //members :
922 scs(check,"fMinimum"); 922 scs(check,"fMinimum");
923 scs(check,"Float_t"); 923 scs(check,"Float_t");
924 924
925 scs(check,"fMaximum"); 925 scs(check,"fMaximum");
926 scs(check,"Float_t"); 926 scs(check,"Float_t");
927 927
928 //Should be 1366318032U 928 //Should be 1366318032U
929 929
930 streamer_info* info = new streamer_info("TLe 930 streamer_info* info = new streamer_info("TLeafF",1,check);
931 a_infos.push_back(info); 931 a_infos.push_back(info);
932 932
933 // Elements : 933 // Elements :
934 int ofs = 0; 934 int ofs = 0;
935 info->add(new streamer_base("TLeaf","Leaf: d 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", 936 info->add(new streamer_float(ofs,"fMinimum","Minimum value if leaf range is specified"));
937 info->add(new streamer_float(ofs,"fMaximum", 937 info->add(new streamer_float(ofs,"fMaximum","Maximum value if leaf range is specified"));
938 //size_TLeafF = ofs; 938 //size_TLeafF = ofs;
939 } 939 }
940 940
941 {unsigned int check = 0; 941 {unsigned int check = 0;
942 //this : 942 //this :
943 scs(check,"TLeafD"); 943 scs(check,"TLeafD");
944 //bases : 944 //bases :
945 scs(check,"TLeaf"); 945 scs(check,"TLeaf");
946 //members : 946 //members :
947 scs(check,"fMinimum"); 947 scs(check,"fMinimum");
948 scs(check,"Double_t"); 948 scs(check,"Double_t");
949 949
950 scs(check,"fMaximum"); 950 scs(check,"fMaximum");
951 scs(check,"Double_t"); 951 scs(check,"Double_t");
952 952
953 //Should be 953 //Should be
954 954
955 streamer_info* info = new streamer_info("TLe 955 streamer_info* info = new streamer_info("TLeafD",1,check);
956 a_infos.push_back(info); 956 a_infos.push_back(info);
957 957
958 // Elements : 958 // Elements :
959 int ofs = 0; 959 int ofs = 0;
960 info->add(new streamer_base("TLeaf","Leaf: d 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" 961 info->add(new streamer_double(ofs,"fMinimum","Minimum value if leaf range is specified"));
962 info->add(new streamer_double(ofs,"fMaximum" 962 info->add(new streamer_double(ofs,"fMaximum","Maximum value if leaf range is specified"));
963 963
964 } 964 }
965 965
966 {unsigned int check = 0; 966 {unsigned int check = 0;
967 //this : 967 //this :
968 scs(check,"TLeafB"); 968 scs(check,"TLeafB");
969 //bases : 969 //bases :
970 scs(check,"TLeaf"); 970 scs(check,"TLeaf");
971 //members : 971 //members :
972 scs(check,"fMinimum"); 972 scs(check,"fMinimum");
973 scs(check,"Char_t"); 973 scs(check,"Char_t");
974 974
975 scs(check,"fMaximum"); 975 scs(check,"fMaximum");
976 scs(check,"Char_t"); 976 scs(check,"Char_t");
977 977
978 //Should be : FIXME 978 //Should be : FIXME
979 979
980 streamer_info* info = new streamer_info("TLe 980 streamer_info* info = new streamer_info("TLeafB",1,check);
981 a_infos.push_back(info); 981 a_infos.push_back(info);
982 // Elements : 982 // Elements :
983 int ofs = 0; 983 int ofs = 0;
984 info->add(new streamer_base("TLeaf","Leaf: d 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" 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" 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 987
988 } 988 }
989 989
990 {unsigned int check = 0; 990 {unsigned int check = 0;
991 //this : 991 //this :
992 scs(check,"TLeafC"); 992 scs(check,"TLeafC");
993 //bases : 993 //bases :
994 scs(check,"TLeaf"); 994 scs(check,"TLeaf");
995 //members : 995 //members :
996 scs(check,"fMinimum"); 996 scs(check,"fMinimum");
997 scs(check,"Int_t"); 997 scs(check,"Int_t");
998 998
999 scs(check,"fMaximum"); 999 scs(check,"fMaximum");
1000 scs(check,"Int_t"); 1000 scs(check,"Int_t");
1001 1001
1002 //Should be : FIXME 1002 //Should be : FIXME
1003 1003
1004 streamer_info* info = new streamer_info("TL 1004 streamer_info* info = new streamer_info("TLeafC",1,check);
1005 a_infos.push_back(info); 1005 a_infos.push_back(info);
1006 1006
1007 // Elements : 1007 // Elements :
1008 int ofs = 0; 1008 int ofs = 0;
1009 info->add(new streamer_base("TLeaf","Leaf: 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"," 1010 info->add(new streamer_int(ofs,"fMinimum","Minimum value if leaf range is specified"));
1011 info->add(new streamer_int(ofs,"fMaximum"," 1011 info->add(new streamer_int(ofs,"fMaximum","Maximum value if leaf range is specified"));}
1012 1012
1013 {unsigned int check = 0; 1013 {unsigned int check = 0;
1014 //this : 1014 //this :
1015 scs(check,"TLeafObject"); 1015 scs(check,"TLeafObject");
1016 //bases : 1016 //bases :
1017 scs(check,"TLeaf"); 1017 scs(check,"TLeaf");
1018 //members : 1018 //members :
1019 scs(check,"fVirtual"); 1019 scs(check,"fVirtual");
1020 scs(check,"Bool_t"); 1020 scs(check,"Bool_t");
1021 1021
1022 //Should be 2312661809U 1022 //Should be 2312661809U
1023 1023
1024 streamer_info* info = new streamer_info("TL 1024 streamer_info* info = new streamer_info("TLeafObject",4,check);
1025 a_infos.push_back(info); 1025 a_infos.push_back(info);
1026 1026
1027 // Elements : 1027 // Elements :
1028 int ofs = 0; 1028 int ofs = 0;
1029 info->add(new streamer_base("TLeaf","Leaf: 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", 1030 info->add(new streamer_bool(ofs,"fVirtual","Support for Virtuality"));}
1031 1031
1032 {unsigned int check = 0; 1032 {unsigned int check = 0;
1033 //this : 1033 //this :
1034 scs(check,"TLeafElement"); 1034 scs(check,"TLeafElement");
1035 //bases : 1035 //bases :
1036 scs(check,"TLeaf"); 1036 scs(check,"TLeaf");
1037 //members : 1037 //members :
1038 scs(check,"fID"); 1038 scs(check,"fID");
1039 scs(check,"Int_t"); 1039 scs(check,"Int_t");
1040 1040
1041 scs(check,"fType"); 1041 scs(check,"fType");
1042 scs(check,"Int_t"); 1042 scs(check,"Int_t");
1043 1043
1044 streamer_info* info = new streamer_info("TL 1044 streamer_info* info = new streamer_info("TLeafElement",1,check);
1045 a_infos.push_back(info); 1045 a_infos.push_back(info);
1046 1046
1047 // Elements : 1047 // Elements :
1048 int ofs = 0; 1048 int ofs = 0;
1049 info->add(new streamer_base("TLeaf","Leaf: 1049 info->add(new streamer_base("TLeaf","Leaf: description of a Branch data type",ofs,TLeaf_version));ofs += size_TLeaf();
1050 ofs += size_POINTER; //!*fAbsAddress 1050 ofs += size_POINTER; //!*fAbsAddress
1051 info->add(new streamer_int(ofs,"fID","eleme 1051 info->add(new streamer_int(ofs,"fID","element serial number in fInfo"));
1052 info->add(new streamer_int(ofs,"fType","lea 1052 info->add(new streamer_int(ofs,"fType","leaf type"));
1053 //size_TLeafElement = ofs; 1053 //size_TLeafElement = ofs;
1054 } 1054 }
1055 1055
1056 } 1056 }
1057 1057
1058 inline int size_TAttAxis() {return 38;} //40? 1058 inline int size_TAttAxis() {return 38;} //40?
1059 inline int size_TAxis() {return 126;} //128? 1059 inline int size_TAxis() {return 126;} //128?
1060 inline int size_TH1() {return 560;} //568? 1060 inline int size_TH1() {return 560;} //568?
1061 inline int size_TH2() {return 592;} //600? 1061 inline int size_TH2() {return 592;} //600?
1062 inline int size_TH2D() {return 604;} //612? 1062 inline int size_TH2D() {return 604;} //612?
1063 1063
1064 inline void fill_infos_histo(obj_list<streame 1064 inline void fill_infos_histo(obj_list<streamer_info>& a_infos,std::ostream& a_out) {
1065 1065
1066 typedef streamer_basic_type sbt; 1066 typedef streamer_basic_type sbt;
1067 1067
1068 const int size_POINTER = 4; 1068 const int size_POINTER = 4;
1069 1069
1070 const int size_DOUBLE = 8; 1070 const int size_DOUBLE = 8;
1071 const int size_SHORT = 2; 1071 const int size_SHORT = 2;
1072 const int size_INT = 4; 1072 const int size_INT = 4;
1073 1073
1074 //const int size_TObjArray = 40; 1074 //const int size_TObjArray = 40;
1075 const int size_TArrayD = 12; 1075 const int size_TArrayD = 12;
1076 const int size_TArrayF = 12; 1076 const int size_TArrayF = 12;
1077 1077
1078 short TNamed_version = 1; 1078 short TNamed_version = 1;
1079 short TArrayF_version = 1; 1079 short TArrayF_version = 1;
1080 short TArrayD_version = 1; 1080 short TArrayD_version = 1;
1081 1081
1082 short TAttLine_version = 1; 1082 short TAttLine_version = 1;
1083 short TAttFill_version = 1; 1083 short TAttFill_version = 1;
1084 short TAttMarker_version = 1; 1084 short TAttMarker_version = 1;
1085 1085
1086 short TAttAxis_version = 4; 1086 short TAttAxis_version = 4;
1087 1087
1088 1088
1089 {unsigned int check = 0; 1089 {unsigned int check = 0;
1090 //this : 1090 //this :
1091 scs(check,"TAttAxis"); 1091 scs(check,"TAttAxis");
1092 //members : 1092 //members :
1093 scs(check,"fNdivisions"); 1093 scs(check,"fNdivisions");
1094 scs(check,"Int_t"); 1094 scs(check,"Int_t");
1095 1095
1096 scs(check,"fAxisColor"); 1096 scs(check,"fAxisColor");
1097 scs(check,"Color_t"); 1097 scs(check,"Color_t");
1098 1098
1099 scs(check,"fLabelColor"); 1099 scs(check,"fLabelColor");
1100 scs(check,"Color_t"); 1100 scs(check,"Color_t");
1101 1101
1102 scs(check,"fLabelFont"); 1102 scs(check,"fLabelFont");
1103 scs(check,"Style_t"); 1103 scs(check,"Style_t");
1104 1104
1105 scs(check,"fLabelOffset"); 1105 scs(check,"fLabelOffset");
1106 scs(check,"Float_t"); 1106 scs(check,"Float_t");
1107 1107
1108 scs(check,"fLabelSize"); 1108 scs(check,"fLabelSize");
1109 scs(check,"Float_t"); 1109 scs(check,"Float_t");
1110 1110
1111 scs(check,"fTickLength"); 1111 scs(check,"fTickLength");
1112 scs(check,"Float_t"); 1112 scs(check,"Float_t");
1113 1113
1114 scs(check,"fTitleOffset"); 1114 scs(check,"fTitleOffset");
1115 scs(check,"Float_t"); 1115 scs(check,"Float_t");
1116 1116
1117 scs(check,"fTitleSize"); 1117 scs(check,"fTitleSize");
1118 scs(check,"Float_t"); 1118 scs(check,"Float_t");
1119 1119
1120 scs(check,"fTitleColor"); 1120 scs(check,"fTitleColor");
1121 scs(check,"Color_t"); 1121 scs(check,"Color_t");
1122 1122
1123 scs(check,"fTitleFont"); 1123 scs(check,"fTitleFont");
1124 scs(check,"Style_t"); 1124 scs(check,"Style_t");
1125 1125
1126 streamer_info* info = new streamer_info("TA 1126 streamer_info* info = new streamer_info("TAttAxis",4,check);
1127 a_infos.push_back(info); 1127 a_infos.push_back(info);
1128 // Elements : 1128 // Elements :
1129 int ofs = size_VIRTUAL(); 1129 int ofs = size_VIRTUAL();
1130 info->add(new streamer_int(ofs,"fNdivisions 1130 info->add(new streamer_int(ofs,"fNdivisions","Number of divisions(10000*n3 + 100*n2 + n1)"));
1131 info->add(new sbt("fAxisColor","color of th 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 l 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 la 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,"fLabelOff 1134 info->add(new streamer_float(ofs,"fLabelOffset","offset of labels"));
1135 info->add(new streamer_float(ofs,"fLabelSiz 1135 info->add(new streamer_float(ofs,"fLabelSize","size of labels"));
1136 info->add(new streamer_float(ofs,"fTickLeng 1136 info->add(new streamer_float(ofs,"fTickLength","length of tick marks"));
1137 info->add(new streamer_float(ofs,"fTitleOff 1137 info->add(new streamer_float(ofs,"fTitleOffset","offset of axis title"));
1138 info->add(new streamer_float(ofs,"fTitleSiz 1138 info->add(new streamer_float(ofs,"fTitleSize","size of axis title"));
1139 info->add(new sbt("fTitleColor","color of a 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 ax 1140 info->add(new sbt("fTitleFont","font for axis title",ofs,streamer__info::SHORT,"Style_t"));ofs += size_SHORT;
1141 //uuuu ofs += 2; //alignement ??? 1141 //uuuu ofs += 2; //alignement ???
1142 if(ofs!=size_TAttAxis()) { 1142 if(ofs!=size_TAttAxis()) {
1143 a_out << "tools::wroot::fill_infos :" 1143 a_out << "tools::wroot::fill_infos :"
1144 << " TAttAxis " << ofs << " (" << s 1144 << " TAttAxis " << ofs << " (" << size_TAttAxis() << " expected.)"
1145 << std::endl; 1145 << std::endl;
1146 }} 1146 }}
1147 1147
1148 {unsigned int check = 0; 1148 {unsigned int check = 0;
1149 //this : 1149 //this :
1150 scs(check,"TAxis"); 1150 scs(check,"TAxis");
1151 //bases : 1151 //bases :
1152 scs(check,"TNamed"); 1152 scs(check,"TNamed");
1153 scs(check,"TAttAxis"); 1153 scs(check,"TAttAxis");
1154 //members : 1154 //members :
1155 scs(check,"fNbins"); 1155 scs(check,"fNbins");
1156 scs(check,"Int_t"); 1156 scs(check,"Int_t");
1157 1157
1158 scs(check,"fXmin"); 1158 scs(check,"fXmin");
1159 scs(check,"Axis_t"); 1159 scs(check,"Axis_t");
1160 1160
1161 scs(check,"fXmax"); 1161 scs(check,"fXmax");
1162 scs(check,"Axis_t"); 1162 scs(check,"Axis_t");
1163 1163
1164 scs(check,"fXbins"); 1164 scs(check,"fXbins");
1165 scs(check,"TArrayD"); 1165 scs(check,"TArrayD");
1166 1166
1167 scs(check,"fFirst"); 1167 scs(check,"fFirst");
1168 scs(check,"Int_t"); 1168 scs(check,"Int_t");
1169 1169
1170 scs(check,"fLast"); 1170 scs(check,"fLast");
1171 scs(check,"Int_t"); 1171 scs(check,"Int_t");
1172 1172
1173 scs(check,"fTimeDisplay"); 1173 scs(check,"fTimeDisplay");
1174 scs(check,"Bool_t"); 1174 scs(check,"Bool_t");
1175 1175
1176 scs(check,"fTimeFormat"); 1176 scs(check,"fTimeFormat");
1177 scs(check,"TString"); 1177 scs(check,"TString");
1178 1178
1179 streamer_info* info = new streamer_info("TA 1179 streamer_info* info = new streamer_info("TAxis",6,check);
1180 a_infos.push_back(info); 1180 a_infos.push_back(info);
1181 1181
1182 // Elements : 1182 // Elements :
1183 int ofs = 0; 1183 int ofs = 0;
1184 info->add(new streamer_base("TNamed","The b 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","Axi 1185 info->add(new streamer_base("TAttAxis","Axis attributes",ofs,TAttAxis_version));ofs += size_TAttAxis();
1186 info->add(new streamer_int(ofs,"fNbins","Nu 1186 info->add(new streamer_int(ofs,"fNbins","Number of bins"));
1187 info->add(new sbt("fXmin","low edge of firs 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 la 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", 1189 info->add(new streamer_object_any("fXbins","Bin edges array in X",ofs,"TArrayD"));ofs += size_TArrayD;
1190 ofs += size_POINTER; //!*fXlabels 1190 ofs += size_POINTER; //!*fXlabels
1191 info->add(new streamer_int(ofs,"fFirst","fi 1191 info->add(new streamer_int(ofs,"fFirst","first bin to display"));
1192 info->add(new streamer_int(ofs,"fLast","las 1192 info->add(new streamer_int(ofs,"fLast","last bin to display"));
1193 info->add(new streamer_bool(ofs,"fTimeDispl 1193 info->add(new streamer_bool(ofs,"fTimeDisplay","on/off displaying time values instead of numerics"));
1194 info->add(new streamer_string(ofs,"fTimeFor 1194 info->add(new streamer_string(ofs,"fTimeFormat","Date&time format, ex: 09/12/99 12:34:00"));
1195 ofs += size_POINTER; //!*fParent 1195 ofs += size_POINTER; //!*fParent
1196 //v3-05-07 : 124 (stored) + 4 = 128 1196 //v3-05-07 : 124 (stored) + 4 = 128
1197 if(ofs!=size_TAxis()) { 1197 if(ofs!=size_TAxis()) {
1198 a_out << "tools::wroot::fill_infos :" 1198 a_out << "tools::wroot::fill_infos :"
1199 << " TAxis " << ofs << " (" << size 1199 << " TAxis " << ofs << " (" << size_TAxis() << " expected.)"
1200 << std::endl; 1200 << std::endl;
1201 }} 1201 }}
1202 1202
1203 short TH1_version = 3; 1203 short TH1_version = 3;
1204 {unsigned int check = 0; 1204 {unsigned int check = 0;
1205 //this : 1205 //this :
1206 scs(check,"TH1"); 1206 scs(check,"TH1");
1207 //bases : 1207 //bases :
1208 scs(check,"TNamed"); 1208 scs(check,"TNamed");
1209 scs(check,"TAttLine"); 1209 scs(check,"TAttLine");
1210 scs(check,"TAttFill"); 1210 scs(check,"TAttFill");
1211 scs(check,"TAttMarker"); 1211 scs(check,"TAttMarker");
1212 //members : 1212 //members :
1213 scs(check,"fNcells"); 1213 scs(check,"fNcells");
1214 scs(check,"Int_t"); 1214 scs(check,"Int_t");
1215 1215
1216 scs(check,"fXaxis"); 1216 scs(check,"fXaxis");
1217 scs(check,"TAxis"); 1217 scs(check,"TAxis");
1218 1218
1219 scs(check,"fBarOffset"); 1219 scs(check,"fBarOffset");
1220 scs(check,"Short_t"); 1220 scs(check,"Short_t");
1221 1221
1222 scs(check,"fBarWidth"); 1222 scs(check,"fBarWidth");
1223 scs(check,"Short_t"); 1223 scs(check,"Short_t");
1224 1224
1225 scs(check,"fEntries"); 1225 scs(check,"fEntries");
1226 scs(check,"Stat_t"); 1226 scs(check,"Stat_t");
1227 1227
1228 scs(check,"fTsumw"); 1228 scs(check,"fTsumw");
1229 scs(check,"Stat_t"); 1229 scs(check,"Stat_t");
1230 1230
1231 scs(check,"fTsumw2"); 1231 scs(check,"fTsumw2");
1232 scs(check,"Stat_t"); 1232 scs(check,"Stat_t");
1233 1233
1234 scs(check,"fTsumwx"); 1234 scs(check,"fTsumwx");
1235 scs(check,"Stat_t"); 1235 scs(check,"Stat_t");
1236 1236
1237 scs(check,"fTsumwx2"); 1237 scs(check,"fTsumwx2");
1238 scs(check,"Stat_t"); 1238 scs(check,"Stat_t");
1239 1239
1240 scs(check,"fMaximum"); 1240 scs(check,"fMaximum");
1241 scs(check,"Double_t"); 1241 scs(check,"Double_t");
1242 1242
1243 scs(check,"fMinimum"); 1243 scs(check,"fMinimum");
1244 scs(check,"Double_t"); 1244 scs(check,"Double_t");
1245 1245
1246 scs(check,"fNormFactor"); 1246 scs(check,"fNormFactor");
1247 scs(check,"Double_t"); 1247 scs(check,"Double_t");
1248 1248
1249 scs(check,"fContour"); 1249 scs(check,"fContour");
1250 scs(check,"TArrayD"); 1250 scs(check,"TArrayD");
1251 1251
1252 scs(check,"fSumw2"); 1252 scs(check,"fSumw2");
1253 scs(check,"TArrayD"); 1253 scs(check,"TArrayD");
1254 1254
1255 scs(check,"fOption"); 1255 scs(check,"fOption");
1256 scs(check,"TString"); 1256 scs(check,"TString");
1257 1257
1258 scs(check,"fFunctions"); 1258 scs(check,"fFunctions");
1259 scs(check,"TList*"); 1259 scs(check,"TList*");
1260 1260
1261 streamer_info* info = new streamer_info("TH 1261 streamer_info* info = new streamer_info("TH1",TH1_version,check);
1262 a_infos.push_back(info); 1262 a_infos.push_back(info);
1263 1263
1264 int ofs = 0; 1264 int ofs = 0;
1265 info->add(new streamer_base("TNamed","The b 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","Lin 1266 info->add(new streamer_base("TAttLine","Line attributes",ofs,TAttLine_version));ofs += size_TAttLine();
1267 info->add(new streamer_base("TAttFill","Fil 1267 info->add(new streamer_base("TAttFill","Fill area attributes",ofs,TAttFill_version));ofs += size_TAttFill();
1268 info->add(new streamer_base("TAttMarker","M 1268 info->add(new streamer_base("TAttMarker","Marker attributes",ofs,TAttMarker_version));ofs += size_TAttMarker();
1269 info->add(new streamer_int(ofs,"fNcells","n 1269 info->add(new streamer_int(ofs,"fNcells","number of bins(1D), cells (2D) +U/Overflows"));
1270 info->add(new streamer_object("fXaxis","X a 1270 info->add(new streamer_object("fXaxis","X axis descriptor",ofs,"TAxis"));ofs += size_TAxis();
1271 info->add(new streamer_object("fYaxis","Y a 1271 info->add(new streamer_object("fYaxis","Y axis descriptor",ofs,"TAxis"));ofs += size_TAxis();
1272 info->add(new streamer_object("fZaxis","Z a 1272 info->add(new streamer_object("fZaxis","Z axis descriptor",ofs,"TAxis"));ofs += size_TAxis();
1273 info->add(new streamer_short(ofs,"fBarOffse 1273 info->add(new streamer_short(ofs,"fBarOffset","(1000*offset) for bar charts or legos"));
1274 info->add(new streamer_short(ofs,"fBarWidth 1274 info->add(new streamer_short(ofs,"fBarWidth","(1000*width) for bar charts or legos"));
1275 info->add(new streamer_stat_t(ofs,"fEntries 1275 info->add(new streamer_stat_t(ofs,"fEntries","Number of entries"));
1276 info->add(new streamer_stat_t(ofs,"fTsumw", 1276 info->add(new streamer_stat_t(ofs,"fTsumw","Total Sum of weights"));
1277 info->add(new streamer_stat_t(ofs,"fTsumw2" 1277 info->add(new streamer_stat_t(ofs,"fTsumw2","Total Sum of squares of weights"));
1278 info->add(new streamer_stat_t(ofs,"fTsumwx" 1278 info->add(new streamer_stat_t(ofs,"fTsumwx","Total Sum of weight*X"));
1279 info->add(new streamer_stat_t(ofs,"fTsumwx2 1279 info->add(new streamer_stat_t(ofs,"fTsumwx2","Total Sum of weight*X*X"));
1280 info->add(new streamer_double(ofs,"fMaximum 1280 info->add(new streamer_double(ofs,"fMaximum","Maximum value for plotting"));
1281 info->add(new streamer_double(ofs,"fMinimum 1281 info->add(new streamer_double(ofs,"fMinimum","Minimum value for plotting"));
1282 info->add(new streamer_double(ofs,"fNormFac 1282 info->add(new streamer_double(ofs,"fNormFactor","Normalization factor"));
1283 info->add(new streamer_object_any("fContour 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", 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" 1285 info->add(new streamer_string(ofs,"fOption","histogram options"));
1286 info->add(new streamer_object_pointer("fFun 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; //!*fDirectory 1287 ofs += size_POINTER; //!*fDirectory
1288 ofs += size_INT; //!fDimension 1288 ofs += size_INT; //!fDimension
1289 ofs += size_POINTER; //!*fIntegral 1289 ofs += size_POINTER; //!*fIntegral
1290 ofs += size_POINTER; //!*fPainter 1290 ofs += size_POINTER; //!*fPainter
1291 //v3-05-07 : 576 = 568 + 2 * 4 = ok 1291 //v3-05-07 : 576 = 568 + 2 * 4 = ok
1292 if(ofs!=size_TH1()) { 1292 if(ofs!=size_TH1()) {
1293 a_out << "tools::wroot::fill_infos :" 1293 a_out << "tools::wroot::fill_infos :"
1294 << " TH1 " << ofs << " (" << size_T 1294 << " TH1 " << ofs << " (" << size_TH1() << " expected.)"
1295 << std::endl; 1295 << std::endl;
1296 }} 1296 }}
1297 1297
1298 {unsigned int check = 0; 1298 {unsigned int check = 0;
1299 //this : 1299 //this :
1300 scs(check,"TH1F"); 1300 scs(check,"TH1F");
1301 //base : 1301 //base :
1302 scs(check,"TH1"); 1302 scs(check,"TH1");
1303 scs(check,"TArrayF"); 1303 scs(check,"TArrayF");
1304 1304
1305 streamer_info* info = new streamer_info("TH 1305 streamer_info* info = new streamer_info("TH1F",1,check);
1306 a_infos.push_back(info); 1306 a_infos.push_back(info);
1307 int ofs = 0; 1307 int ofs = 0;
1308 info->add(new streamer_base("TH1","1-Dim hi 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","Arra 1309 info->add(new streamer_base("TArrayF","Array of floats",ofs,TArrayF_version));ofs += size_TArrayF;
1310 } 1310 }
1311 1311
1312 int size_TH1D = 0; 1312 int size_TH1D = 0;
1313 short TH1D_version = 1; 1313 short TH1D_version = 1;
1314 {unsigned int check = 0; 1314 {unsigned int check = 0;
1315 //this : 1315 //this :
1316 scs(check,"TH1D"); 1316 scs(check,"TH1D");
1317 //base : 1317 //base :
1318 scs(check,"TH1"); 1318 scs(check,"TH1");
1319 scs(check,"TArrayD"); 1319 scs(check,"TArrayD");
1320 1320
1321 streamer_info* info = new streamer_info("TH 1321 streamer_info* info = new streamer_info("TH1D",TH1D_version,check);
1322 a_infos.push_back(info); 1322 a_infos.push_back(info);
1323 int ofs = 0; 1323 int ofs = 0;
1324 info->add(new streamer_base("TH1","1-Dim hi 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","Arra 1325 info->add(new streamer_base("TArrayD","Array of doubles",ofs,TArrayD_version));ofs += size_TArrayD;
1326 size_TH1D = ofs; //580 1326 size_TH1D = ofs; //580
1327 1327
1328 //v3-05-07 : 588 = 576 + 12 = ok 1328 //v3-05-07 : 588 = 576 + 12 = ok
1329 } 1329 }
1330 1330
1331 {unsigned int check = 0; 1331 {unsigned int check = 0;
1332 //this : 1332 //this :
1333 scs(check,"TProfile"); 1333 scs(check,"TProfile");
1334 //base : 1334 //base :
1335 scs(check,"TH1D"); 1335 scs(check,"TH1D");
1336 //members : 1336 //members :
1337 scs(check,"fBinEntries"); 1337 scs(check,"fBinEntries");
1338 scs(check,"TArrayD"); 1338 scs(check,"TArrayD");
1339 1339
1340 scs(check,"fErrorMode"); 1340 scs(check,"fErrorMode");
1341 scs(check,"EErrorType");//FIXME : ok ? 1341 scs(check,"EErrorType");//FIXME : ok ?
1342 1342
1343 scs(check,"fYmin"); 1343 scs(check,"fYmin");
1344 scs(check,"Double_t"); 1344 scs(check,"Double_t");
1345 1345
1346 scs(check,"fYmax"); 1346 scs(check,"fYmax");
1347 scs(check,"Double_t"); 1347 scs(check,"Double_t");
1348 1348
1349 scs(check,"fTsumwy"); 1349 scs(check,"fTsumwy");
1350 scs(check,"Double_t"); 1350 scs(check,"Double_t");
1351 1351
1352 scs(check,"fTsumwy2"); 1352 scs(check,"fTsumwy2");
1353 scs(check,"Double_t"); 1353 scs(check,"Double_t");
1354 1354
1355 streamer_info* info = new streamer_info("TP 1355 streamer_info* info = new streamer_info("TProfile",4,check);
1356 a_infos.push_back(info); 1356 a_infos.push_back(info);
1357 1357
1358 int ofs = 0; 1358 int ofs = 0;
1359 info->add(new streamer_base("TH1D","1-Dim h 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("fBinEntr 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("fErrorMo 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"," 1362 info->add(new streamer_double(ofs,"fYmin","Lower limit in Y (if set)"));
1363 info->add(new streamer_double(ofs,"fYmax"," 1363 info->add(new streamer_double(ofs,"fYmax","Upper limit in Y (if set)"));
1364 info->add(new streamer_double(ofs,"fTsumwy" 1364 info->add(new streamer_double(ofs,"fTsumwy","Total Sum of weight*Y"));
1365 info->add(new streamer_double(ofs,"fTsumwy2 1365 info->add(new streamer_double(ofs,"fTsumwy2","Total Sum of weight*Y*Y"));
1366 //628 1366 //628
1367 1367
1368 //v3-05-07 : 624 = 612 + 4 + 8 (diff TH1D) 1368 //v3-05-07 : 624 = 612 + 4 + 8 (diff TH1D) = ok
1369 } 1369 }
1370 1370
1371 short TH2_version = 3; 1371 short TH2_version = 3;
1372 {unsigned int check = 0; 1372 {unsigned int check = 0;
1373 //this : 1373 //this :
1374 scs(check,"TH2"); 1374 scs(check,"TH2");
1375 //bases : 1375 //bases :
1376 scs(check,"TH1"); 1376 scs(check,"TH1");
1377 //members : 1377 //members :
1378 scs(check,"fScalefactor"); 1378 scs(check,"fScalefactor");
1379 scs(check,"Stat_t"); 1379 scs(check,"Stat_t");
1380 1380
1381 scs(check,"fTsumwy"); 1381 scs(check,"fTsumwy");
1382 scs(check,"Stat_t"); 1382 scs(check,"Stat_t");
1383 1383
1384 scs(check,"fTsumwy2"); 1384 scs(check,"fTsumwy2");
1385 scs(check,"Stat_t"); 1385 scs(check,"Stat_t");
1386 1386
1387 scs(check,"fTsumwxy"); 1387 scs(check,"fTsumwxy");
1388 scs(check,"Stat_t"); 1388 scs(check,"Stat_t");
1389 1389
1390 streamer_info* info = new streamer_info("TH 1390 streamer_info* info = new streamer_info("TH2",TH2_version,check);
1391 a_infos.push_back(info); 1391 a_infos.push_back(info);
1392 1392
1393 int ofs = 0; 1393 int ofs = 0;
1394 info->add(new streamer_base("TH1","1-Dim hi 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,"fScalefa 1395 info->add(new streamer_stat_t(ofs,"fScalefactor","Scale factor"));
1396 info->add(new streamer_stat_t(ofs,"fTsumwy" 1396 info->add(new streamer_stat_t(ofs,"fTsumwy","Total Sum of weight*Y"));
1397 info->add(new streamer_stat_t(ofs,"fTsumwy2 1397 info->add(new streamer_stat_t(ofs,"fTsumwy2","Total Sum of weight*Y*Y"));
1398 info->add(new streamer_stat_t(ofs,"fTsumwxy 1398 info->add(new streamer_stat_t(ofs,"fTsumwxy","Total Sum of weight*X*Y"));
1399 //v3-05-07 : <to be checked> 1399 //v3-05-07 : <to be checked>
1400 if(ofs!=size_TH2()) { 1400 if(ofs!=size_TH2()) {
1401 a_out << "tools::wroot::fill_infos :" 1401 a_out << "tools::wroot::fill_infos :"
1402 << " TH2 " << ofs << " (" << size_T 1402 << " TH2 " << ofs << " (" << size_TH2() << " expected.)"
1403 << std::endl; 1403 << std::endl;
1404 }} 1404 }}
1405 1405
1406 {unsigned int check = 0; 1406 {unsigned int check = 0;
1407 //this : 1407 //this :
1408 scs(check,"TH2F"); 1408 scs(check,"TH2F");
1409 //base : 1409 //base :
1410 scs(check,"TH2"); 1410 scs(check,"TH2");
1411 scs(check,"TArrayF"); 1411 scs(check,"TArrayF");
1412 1412
1413 streamer_info* info = new streamer_info("TH 1413 streamer_info* info = new streamer_info("TH2F",3,check);
1414 a_infos.push_back(info); 1414 a_infos.push_back(info);
1415 1415
1416 int ofs = 0; 1416 int ofs = 0;
1417 info->add(new streamer_base("TH2","2-Dim hi 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","Arra 1418 info->add(new streamer_base("TArrayF","Array of floats",ofs,TArrayF_version));ofs += size_TArrayF;
1419 //612 1419 //612
1420 1420
1421 } 1421 }
1422 1422
1423 short TH2D_version = 3; 1423 short TH2D_version = 3;
1424 {unsigned int check = 0; 1424 {unsigned int check = 0;
1425 //this : 1425 //this :
1426 scs(check,"TH2D"); 1426 scs(check,"TH2D");
1427 //base : 1427 //base :
1428 scs(check,"TH2"); 1428 scs(check,"TH2");
1429 scs(check,"TArrayD"); 1429 scs(check,"TArrayD");
1430 1430
1431 streamer_info* info = new streamer_info("TH 1431 streamer_info* info = new streamer_info("TH2D",TH2D_version,check);
1432 a_infos.push_back(info); 1432 a_infos.push_back(info);
1433 1433
1434 int ofs = 0; 1434 int ofs = 0;
1435 info->add(new streamer_base("TH2","2-Dim hi 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","Arra 1436 info->add(new streamer_base("TArrayD","Array of doubles",ofs,TArrayD_version));ofs += size_TArrayD;
1437 if(ofs!=size_TH2D()) { 1437 if(ofs!=size_TH2D()) {
1438 a_out << "tools::wroot::fill_infos :" 1438 a_out << "tools::wroot::fill_infos :"
1439 << " TH2D " << ofs << " (" << size_ 1439 << " TH2D " << ofs << " (" << size_TH2D() << " expected.)"
1440 << std::endl; 1440 << std::endl;
1441 }} 1441 }}
1442 1442
1443 {unsigned int check = 0; 1443 {unsigned int check = 0;
1444 //this : 1444 //this :
1445 scs(check,"TProfile2D"); 1445 scs(check,"TProfile2D");
1446 //base : 1446 //base :
1447 scs(check,"TH2D"); 1447 scs(check,"TH2D");
1448 //members : 1448 //members :
1449 scs(check,"fBinEntries"); 1449 scs(check,"fBinEntries");
1450 scs(check,"TArrayD"); 1450 scs(check,"TArrayD");
1451 1451
1452 scs(check,"fErrorMode"); 1452 scs(check,"fErrorMode");
1453 scs(check,"EErrorType");//FIXME : ok ? 1453 scs(check,"EErrorType");//FIXME : ok ?
1454 1454
1455 scs(check,"fZmin"); 1455 scs(check,"fZmin");
1456 scs(check,"Double_t"); 1456 scs(check,"Double_t");
1457 1457
1458 scs(check,"fZmax"); 1458 scs(check,"fZmax");
1459 scs(check,"Double_t"); 1459 scs(check,"Double_t");
1460 1460
1461 scs(check,"fTsumwz"); 1461 scs(check,"fTsumwz");
1462 scs(check,"Double_t"); 1462 scs(check,"Double_t");
1463 1463
1464 scs(check,"fTsumwz2"); 1464 scs(check,"fTsumwz2");
1465 scs(check,"Double_t"); 1465 scs(check,"Double_t");
1466 1466
1467 streamer_info* info = new streamer_info("TP 1467 streamer_info* info = new streamer_info("TProfile2D",5,check);
1468 a_infos.push_back(info); 1468 a_infos.push_back(info);
1469 1469
1470 int ofs = 0; 1470 int ofs = 0;
1471 info->add(new streamer_base("TH2D","2-Dim h 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("fBinEntr 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 c 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"," 1474 info->add(new streamer_double(ofs,"fZmin","Lower limit in Z (if set)"));
1475 info->add(new streamer_double(ofs,"fZmax"," 1475 info->add(new streamer_double(ofs,"fZmax","Upper limit in Z (if set)"));
1476 info->add(new streamer_double(ofs,"fTsumwz" 1476 info->add(new streamer_double(ofs,"fTsumwz","Total Sum of weight*Z"));
1477 info->add(new streamer_double(ofs,"fTsumwz2 1477 info->add(new streamer_double(ofs,"fTsumwz2","Total Sum of weight*Z*Z"));
1478 //660 1478 //660
1479 1479
1480 } 1480 }
1481 1481
1482 int size_TH3 = 0; 1482 int size_TH3 = 0;
1483 short TH3_version = 4; 1483 short TH3_version = 4;
1484 short TAtt3D_version = 1; 1484 short TAtt3D_version = 1;
1485 {unsigned int check = 0; 1485 {unsigned int check = 0;
1486 //this : 1486 //this :
1487 scs(check,"TH3"); 1487 scs(check,"TH3");
1488 //bases : 1488 //bases :
1489 scs(check,"TH1"); 1489 scs(check,"TH1");
1490 scs(check,"TAtt3D"); 1490 scs(check,"TAtt3D");
1491 //members : 1491 //members :
1492 scs(check,"fTsumwy"); 1492 scs(check,"fTsumwy");
1493 scs(check,"Double_t"); 1493 scs(check,"Double_t");
1494 scs(check,"fTsumwy2"); 1494 scs(check,"fTsumwy2");
1495 scs(check,"Double_t"); 1495 scs(check,"Double_t");
1496 scs(check,"fTsumwxy"); 1496 scs(check,"fTsumwxy");
1497 scs(check,"Double_t"); 1497 scs(check,"Double_t");
1498 1498
1499 scs(check,"fTsumwz"); 1499 scs(check,"fTsumwz");
1500 scs(check,"Double_t"); 1500 scs(check,"Double_t");
1501 scs(check,"fTsumwz2"); 1501 scs(check,"fTsumwz2");
1502 scs(check,"Double_t"); 1502 scs(check,"Double_t");
1503 scs(check,"fTsumwxz"); 1503 scs(check,"fTsumwxz");
1504 scs(check,"Double_t"); 1504 scs(check,"Double_t");
1505 scs(check,"fTsumwyz"); 1505 scs(check,"fTsumwyz");
1506 scs(check,"Double_t"); 1506 scs(check,"Double_t");
1507 1507
1508 streamer_info* info = new streamer_info("TH 1508 streamer_info* info = new streamer_info("TH3",TH3_version,check);
1509 a_infos.push_back(info); 1509 a_infos.push_back(info);
1510 1510
1511 int ofs = 0; 1511 int ofs = 0;
1512 info->add(new streamer_base("TH1","1-Dim hi 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 at 1513 info->add(new streamer_base("TAtt3D","3D attributes",ofs,TAtt3D_version));ofs += 0;
1514 info->add(new streamer_double(ofs,"fTsumwy" 1514 info->add(new streamer_double(ofs,"fTsumwy","Total Sum of weight*Y"));
1515 info->add(new streamer_double(ofs,"fTsumwy2 1515 info->add(new streamer_double(ofs,"fTsumwy2","Total Sum of weight*Y*Y"));
1516 info->add(new streamer_double(ofs,"fTsumwxy 1516 info->add(new streamer_double(ofs,"fTsumwxy","Total Sum of weight*X*Y"));
1517 1517
1518 info->add(new streamer_double(ofs,"fTsumwz" 1518 info->add(new streamer_double(ofs,"fTsumwz","Total Sum of weight*Z"));
1519 info->add(new streamer_double(ofs,"fTsumwz2 1519 info->add(new streamer_double(ofs,"fTsumwz2","Total Sum of weight*Z*Z"));
1520 info->add(new streamer_double(ofs,"fTsumwxz 1520 info->add(new streamer_double(ofs,"fTsumwxz","Total Sum of weight*X*Z"));
1521 info->add(new streamer_double(ofs,"fTsumwyz 1521 info->add(new streamer_double(ofs,"fTsumwyz","Total Sum of weight*Y*Z"));
1522 size_TH3 = ofs; //624 1522 size_TH3 = ofs; //624
1523 1523
1524 //v4-00-02 : <to be checked> 1524 //v4-00-02 : <to be checked>
1525 } 1525 }
1526 1526
1527 {unsigned int check = 0; 1527 {unsigned int check = 0;
1528 //this : 1528 //this :
1529 scs(check,"TH3F"); 1529 scs(check,"TH3F");
1530 //base : 1530 //base :
1531 scs(check,"TH3"); 1531 scs(check,"TH3");
1532 scs(check,"TArrayF"); 1532 scs(check,"TArrayF");
1533 1533
1534 streamer_info* info = new streamer_info("TH 1534 streamer_info* info = new streamer_info("TH3F",3,check);
1535 a_infos.push_back(info); 1535 a_infos.push_back(info);
1536 1536
1537 int ofs = 0; 1537 int ofs = 0;
1538 info->add(new streamer_base("TH3","3-Dim hi 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","Arra 1539 info->add(new streamer_base("TArrayF","Array of floats",ofs,TArrayF_version));ofs += size_TArrayF;
1540 //636 1540 //636
1541 1541
1542 } 1542 }
1543 1543
1544 {unsigned int check = 0; 1544 {unsigned int check = 0;
1545 //this : 1545 //this :
1546 scs(check,"TH3D"); 1546 scs(check,"TH3D");
1547 //base : 1547 //base :
1548 scs(check,"TH3"); 1548 scs(check,"TH3");
1549 scs(check,"TArrayD"); 1549 scs(check,"TArrayD");
1550 1550
1551 streamer_info* info = new streamer_info("TH 1551 streamer_info* info = new streamer_info("TH3D",3,check);
1552 a_infos.push_back(info); 1552 a_infos.push_back(info);
1553 1553
1554 int ofs = 0; 1554 int ofs = 0;
1555 info->add(new streamer_base("TH3","3-Dim hi 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","Arra 1556 info->add(new streamer_base("TArrayD","Array of doubles",ofs,TArrayD_version));ofs += size_TArrayD;
1557 //636 1557 //636
1558 1558
1559 } 1559 }
1560 1560
1561 1561
1562 } 1562 }
1563 1563
1564 inline void fill_infos(obj_list<streamer_info 1564 inline void fill_infos(obj_list<streamer_info>& a_infos,std::ostream& a_out) {
1565 1565
1566 fill_infos_core(a_infos,a_out); 1566 fill_infos_core(a_infos,a_out);
1567 fill_infos_cont(a_infos,a_out); 1567 fill_infos_cont(a_infos,a_out);
1568 fill_infos_graf(a_infos,a_out); 1568 fill_infos_graf(a_infos,a_out);
1569 fill_infos_tree(a_infos,a_out); 1569 fill_infos_tree(a_infos,a_out);
1570 fill_infos_histo(a_infos,a_out); 1570 fill_infos_histo(a_infos,a_out);
1571 1571
1572 } 1572 }
1573 1573
1574 }} 1574 }}
1575 1575
1576 #endif 1576 #endif