Warning, /include/Geant4/tools/rroot/streamers is written in an unsupported language. File is not indexed.
0001 // Copyright (C) 2010, Guy Barrand. All rights reserved.
0002 // See the file tools.license for terms.
0003
0004 #ifndef tools_rroot_streamers
0005 #define tools_rroot_streamers
0006
0007 #include "dummy_fac"
0008
0009 #include "named"
0010 #include "date"
0011 #include "directory"
0012 #include "clss"
0013 #include "dummy"
0014 #include "obj_list"
0015
0016 #include "../sout"
0017 #include "../vmanip"
0018
0019 #include "../histo/profile_data"
0020
0021 #include "../histo/h1d"
0022 #include "../histo/h2d"
0023 #include "../histo/h3d"
0024 #include "../histo/p1d"
0025 #include "../histo/p2d"
0026
0027 #include <list>
0028 #include <cmath> //::log10, ::fabs.
0029 #include <utility>
0030
0031 namespace tools {
0032 namespace rroot {
0033
0034 typedef histo::histo_data<double,unsigned int,unsigned int,double> hd_data;
0035 typedef histo::profile_data<double,unsigned int,unsigned int,double,double> pd_data;
0036
0037 inline bool AttAxis_stream(buffer& a_buffer){
0038 int fNdivisions = 510; //Number of divisions(10000*n3 + 100*n2 + n1)
0039 short fAxisColor = 1; //color of the line axis
0040 short fLabelColor = 1; //color of labels
0041 short fLabelFont = 62; //font for labels
0042 float fLabelOffset = 0.005F; //offset of labels
0043 float fLabelSize = 0.04F; //size of labels
0044 float fTickLength = 0.03F; //length of tick marks
0045 float fTitleOffset = 1; //offset of axis title
0046 float fTitleSize = 0.04F; //size of axis title
0047 short fTitleColor = 1; //color of axis title
0048 short fTitleFont = 62; //font for axis title
0049
0050 // Version 4 streaming (ROOT/v3-00-6).
0051 short v;
0052 unsigned int _s,_c;
0053 if(!a_buffer.read_version(v,_s,_c)) return false;
0054
0055 if(!a_buffer.read(fNdivisions)) return false;
0056 if(!a_buffer.read(fAxisColor)) return false;
0057 if(!a_buffer.read(fLabelColor)) return false;
0058 if(!a_buffer.read(fLabelFont)) return false;
0059 if(!a_buffer.read(fLabelOffset)) return false;
0060 if(!a_buffer.read(fLabelSize)) return false;
0061 if(!a_buffer.read(fTickLength)) return false;
0062 if(!a_buffer.read(fTitleOffset)) return false;
0063 if(!a_buffer.read(fTitleSize)) return false;
0064 if(!a_buffer.read(fTitleColor)) return false;
0065 if(!a_buffer.read(fTitleFont)) return false;
0066
0067 if(!a_buffer.check_byte_count(_s,_c,"TAttAxis")) return false;
0068 return true;
0069 }
0070
0071 inline bool Axis_stream(buffer& a_buffer,histo::axis<double,unsigned int>& a_fAxis){
0072 // Version 6 streaming (ROOT/v3-00-6).
0073 short v;
0074 unsigned int _s,_c;
0075 if(!a_buffer.read_version(v,_s,_c)) return false;
0076
0077 std::string name;
0078 std::string title;
0079 if(!Named_stream(a_buffer,name,title)) return false;
0080
0081 if(!AttAxis_stream(a_buffer)) return false;
0082
0083 int number;
0084 if(!a_buffer.read(number)) return false;
0085 double min;
0086 if(!a_buffer.read(min)) return false;
0087 double max;
0088 if(!a_buffer.read(max)) return false;
0089
0090 std::vector<double> edges;
0091 if(!Array_stream<double>(a_buffer,edges)) return false; //fXbins TArrayD
0092
0093 size_t edgen = edges.size();
0094 if(!edgen) {
0095 a_fAxis.configure(number,min,max);
0096 } else {
0097 std::vector<double> vedges;
0098 for(size_t index=0;index<edgen;index++) {
0099 vedges.push_back(edges[index]);
0100 }
0101 a_fAxis.configure(vedges);
0102 }
0103
0104 int First;
0105 if(!a_buffer.read(First)) return false;
0106 int Last;
0107 if(!a_buffer.read(Last)) return false;
0108
0109 if(v>=8) { //fBits2.
0110 unsigned short dummy;
0111 if(!a_buffer.read(dummy)) return false;
0112 }
0113
0114 //Bool_t
0115 unsigned char TimeDisplay;
0116 if(!a_buffer.read(TimeDisplay)) return false;
0117
0118 //TString
0119 std::string TimeFormat;
0120 if(!a_buffer.read(TimeFormat)) return false;
0121
0122 if(v>=7) {
0123 //THashList*
0124 dummy_fac fac(a_buffer.out());
0125 if(!dummy_TXxx_pointer_stream(a_buffer,fac)) return false;
0126 }
0127
0128 if(!a_buffer.check_byte_count(_s,_c,"TAxis")) return false;
0129 return true;
0130 }
0131
0132 inline bool null_epsil(double a_1,double a_2,double a_prec = -5) {
0133 return (::log10(::fabs(a_1-a_2))<a_prec?true:false);
0134 }
0135
0136 inline bool TH_read_1D(buffer& a_buffer,hd_data& a_data,
0137 double& a_entries,double& a_Sw,double& a_Sw2,double& a_Sxw,double& a_Sx2w){
0138 a_entries = 0;
0139 a_Sw = 0;
0140 a_Sw2 = 0;
0141 a_Sxw = 0;
0142 a_Sx2w = 0;
0143
0144 unsigned int _s,_c;
0145 short vers;
0146 if(!a_buffer.read_version(vers,_s,_c)) return false;
0147
0148 // Version 3 streaming (ROOT/v3-00-6).
0149
0150 std::string name;
0151 std::string title;
0152 if(!Named_stream(a_buffer,name,title)) return false;
0153
0154 a_data.m_title = std::move(title);
0155
0156 {short color,style,width;
0157 if(!AttLine_stream(a_buffer,color,style,width)) return false;}
0158 {short color,style;
0159 if(!AttFill_stream(a_buffer,color,style)) return false;}
0160 if(!AttMarker_stream(a_buffer)) return false;
0161
0162 int Ncells;
0163 if(!a_buffer.read(Ncells)) return false;
0164
0165 //fXAxis
0166 if(!Axis_stream(a_buffer,a_data.m_axes[0])) return false;
0167 a_data.m_axes[0].m_offset = 1;
0168
0169 if(a_data.m_dimension==3) {
0170 if(!Axis_stream(a_buffer,a_data.m_axes[1])) return false; //fYAxis
0171 a_data.m_axes[1].m_offset = a_data.m_axes[0].m_offset * (a_data.m_axes[0].bins()+2);
0172
0173 if(!Axis_stream(a_buffer,a_data.m_axes[2])) return false; //fZAxis
0174 a_data.m_axes[2].m_offset = a_data.m_axes[1].m_offset * (a_data.m_axes[1].bins()+2);
0175
0176 } else if(a_data.m_dimension==2) {
0177 if(!Axis_stream(a_buffer,a_data.m_axes[1])) return false; //fYAxis
0178 a_data.m_axes[1].m_offset = a_data.m_axes[0].m_offset * (a_data.m_axes[0].bins()+2);
0179
0180 histo::axis<double,unsigned int> dummy;
0181 if(!Axis_stream(a_buffer,dummy)) return false; //fZAxis
0182 } else {
0183 histo::axis<double,unsigned int> dummy;
0184 if(!Axis_stream(a_buffer,dummy)) return false; //fYAxis
0185 if(!Axis_stream(a_buffer,dummy)) return false; //fZAxis
0186 }
0187
0188 short barOffset;
0189 if(!a_buffer.read(barOffset)) return false;
0190
0191 short barWidth;
0192 if(!a_buffer.read(barWidth)) return false;
0193
0194 if(!a_buffer.read(a_entries)) return false;
0195
0196 if(!a_buffer.read(a_Sw)) return false; //fTsumw
0197
0198 if(!a_buffer.read(a_Sw2)) return false;
0199
0200 if(!a_buffer.read(a_Sxw)) return false;
0201
0202 if(!a_buffer.read(a_Sx2w)) return false;
0203
0204 double max;
0205 if(!a_buffer.read(max)) return false;
0206
0207 double min;
0208 if(!a_buffer.read(min)) return false;
0209
0210 double NormFactor;
0211 if(!a_buffer.read(NormFactor)) return false;
0212
0213 {std::vector<double> v;
0214 if(!Array_stream<double>(a_buffer,v)) return false;} //fContour TArrayD
0215
0216 std::vector<double> sumw2; //fSumw2 TArrayD
0217 if(!Array_stream<double>(a_buffer,sumw2)) return false;
0218
0219 {std::string opt;
0220 if(!a_buffer.read(opt)) return false; //TString fOption
0221 }
0222
0223 {dummy_fac fac(a_buffer.out());
0224 obj_list dummy(fac);
0225 if(!dummy.stream(a_buffer)) {
0226 a_buffer.out() << "tools::rroot::TH_read_1D :"
0227 << " obj_list stream failed."
0228 << std::endl;
0229 return false;
0230 }} //Functions
0231
0232 if(vers>=4) {
0233 int BufferSize;
0234 if(!a_buffer.read(BufferSize)) return false;
0235
0236 //Double_t* Buffer; //[fBufferSize]
0237 if(!dummy_array_stream<double>(a_buffer,BufferSize)) return false;
0238 }
0239
0240 if(vers>=7) {
0241 //EBinErrorOpt fBinStatErrOpt;
0242 int dummy;
0243 if(!a_buffer.read(dummy)) return false;
0244 }
0245
0246 // Add two for outflows.
0247 if(a_data.m_dimension==1) {
0248 a_data.m_bin_number = a_data.m_axes[0].m_number_of_bins + 2;
0249 } else if(a_data.m_dimension==2) {
0250 a_data.m_bin_number =
0251 (a_data.m_axes[0].m_number_of_bins + 2) *
0252 (a_data.m_axes[1].m_number_of_bins + 2);
0253 } else if(a_data.m_dimension==3) {
0254 a_data.m_bin_number =
0255 (a_data.m_axes[0].m_number_of_bins + 2) *
0256 (a_data.m_axes[1].m_number_of_bins + 2) *
0257 (a_data.m_axes[2].m_number_of_bins + 2);
0258 }
0259
0260 unsigned int binn = a_data.m_bin_number;
0261 a_data.m_bin_Sw2.resize(binn);
0262 if(binn==sumw2.size()) {
0263 for(unsigned int index=0;index<binn;index++){
0264 a_data.m_bin_Sw2[index] = sumw2[index];
0265 }
0266 } else {
0267 a_data.m_bin_Sw2.assign(binn,0);
0268 }
0269
0270 if(!a_buffer.check_byte_count(_s,_c,"TH")) return false;
0271
0272 return true;
0273 }
0274
0275
0276 inline bool TH_read_2D(buffer& a_buffer,hd_data& a_data,
0277 double& a_entries,double& a_Sw,double& a_Sw2,
0278 double& a_Sxw,double& a_Sx2w,double& a_Syw,double& a_Sy2w){
0279 unsigned int _s,_c;
0280 short v;
0281 if(!a_buffer.read_version(v,_s,_c)) return false;
0282
0283 // Version 3 streaming (ROOT/v3-00-6).
0284
0285 if(!TH_read_1D(a_buffer,a_data,a_entries,a_Sw,a_Sw2,a_Sxw,a_Sx2w)) return false;
0286 // the upper set :
0287 //data.m_title
0288 //data.m_bin_number
0289 //data.m_axes
0290 //data.m_bin_Sw2
0291
0292 double ScaleFactor;
0293 if(!a_buffer.read(ScaleFactor)) return false;
0294 if(!a_buffer.read(a_Syw)) return false;
0295 if(!a_buffer.read(a_Sy2w)) return false;
0296
0297 double Tsumwxy;
0298 if(!a_buffer.read(Tsumwxy)) return false;
0299 a_data.m_in_range_plane_Sxyw[0] = Tsumwxy;
0300
0301 if(!a_buffer.check_byte_count(_s,_c,"TH2")) return false;
0302
0303 return true;
0304 }
0305
0306 inline bool TH_read_3D(buffer& a_buffer,hd_data& a_data,
0307 double& a_entries,double& a_Sw,double& a_Sw2,
0308 double& a_Sxw,double& a_Sx2w,
0309 double& a_Syw,double& a_Sy2w,
0310 double& a_Szw,double& a_Sz2w){
0311 unsigned int _s,_c;
0312 short v;
0313 if(!a_buffer.read_version(v,_s,_c)) return false;
0314
0315 if(!TH_read_1D(a_buffer,a_data,a_entries,a_Sw,a_Sw2,a_Sxw,a_Sx2w)) return false;
0316 if(!Att3D_stream(a_buffer)) return false;
0317
0318 // the upper set :
0319 //data.m_title
0320 //data.m_bin_number
0321 //data.m_axes
0322 //data.m_bin_Sw2
0323
0324 if(!a_buffer.read(a_Syw)) return false;
0325 if(!a_buffer.read(a_Sy2w)) return false;
0326 double Tsumwxy;
0327 if(!a_buffer.read(Tsumwxy)) return false;
0328
0329 if(!a_buffer.read(a_Szw)) return false;
0330 if(!a_buffer.read(a_Sz2w)) return false;
0331 double Tsumwxz;
0332 if(!a_buffer.read(Tsumwxz)) return false;
0333 double Tsumwyz;
0334 if(!a_buffer.read(Tsumwyz)) return false;
0335
0336 a_data.m_in_range_plane_Sxyw[0] = Tsumwxy;
0337 a_data.m_in_range_plane_Sxyw[1] = Tsumwyz;
0338 a_data.m_in_range_plane_Sxyw[2] = Tsumwxz;
0339
0340 if(!a_buffer.check_byte_count(_s,_c,"TH3")) return false;
0341
0342 return true;
0343 }
0344
0345 inline histo::h1d* TH1F_stream(buffer& a_buffer){
0346 unsigned int _s,_c;
0347 short v;
0348 if(!a_buffer.read_version(v,_s,_c)) return 0;
0349
0350 // Version 1 streaming (ROOT/v3-00-6).
0351
0352 // Now we have to reconstruct a valid Histogram from a_buffer :
0353 hd_data data;
0354
0355 data.m_dimension = 1;
0356 data.m_axes.resize(1);
0357
0358 double fEntries; //in range + outflow.
0359 double fSw; //in range.
0360 double fSw2; //in range.
0361 double fSxw; //in range.
0362 double fSx2w; //in range.
0363 if(!TH_read_1D(a_buffer,data,fEntries,fSw,fSw2,fSxw,fSx2w)) return 0;
0364 // the upper set :
0365 //data.m_title
0366 //data.m_bin_number
0367 //data.m_axes
0368 //data.m_bin_Sw2
0369
0370 std::vector<float> bins; //fArray TArrayF
0371 if(!Array_stream<float>(a_buffer,bins)) return 0;
0372 if(!a_buffer.check_byte_count(_s,_c,"TH1F")) return 0;
0373
0374 unsigned int binn = data.m_bin_number;
0375 data.m_bin_Sw.resize(binn,0);
0376 {for(unsigned int index=0;index<binn;index++){
0377 data.m_bin_Sw[index] = double(bins[index]);
0378 }}
0379
0380 data.m_bin_entries.resize(binn,0);
0381 {std::vector<double> empty;
0382 empty.resize(1,0);
0383 data.m_bin_Sxw.resize(binn,empty);
0384 data.m_bin_Sx2w.resize(binn,empty);}
0385 data.m_all_entries = static_cast<unsigned int>(fEntries);
0386 data.m_in_range_entries = 0;
0387 data.m_in_range_Sw = fSw;
0388 data.m_in_range_Sw2 = fSw2;
0389 data.m_in_range_Sxw.resize(1,0);
0390 data.m_in_range_Sx2w.resize(1,0);
0391 data.m_in_range_Sxw[0] = fSxw;
0392 data.m_in_range_Sx2w[0] = fSx2w;
0393
0394 histo::h1d* h = new histo::h1d("",10,0,1);
0395 h->copy_from_data(data);
0396 return h; //give ownership to caller.
0397 }
0398
0399 inline histo::h1d* TH1D_stream(buffer& a_buffer){
0400 unsigned int _s,_c;
0401 short v;
0402 if(!a_buffer.read_version(v,_s,_c)) return 0;
0403
0404 // Version 1 streaming (ROOT/v3-00-6).
0405
0406 // Now we have to reconstruct a valid Histogram from a_buffer :
0407 hd_data data;
0408
0409 data.m_dimension = 1;
0410 data.m_axes.resize(1);
0411
0412 double fEntries; //in range + outflow.
0413 double fSw; //in range.
0414 double fSw2; //in range.
0415 double fSxw; //in range.
0416 double fSx2w; //in range.
0417 if(!TH_read_1D(a_buffer,data,fEntries,fSw,fSw2,fSxw,fSx2w)) return 0;
0418 // the upper set :
0419 //data.m_title
0420 //data.m_bin_number
0421 //data.m_axes
0422 //data.m_bin_Sw2
0423
0424 std::vector<double> bins; //fArray TArrayD
0425 if(!Array_stream<double>(a_buffer,bins)) return 0;
0426 if(!a_buffer.check_byte_count(_s,_c,"TH1D")) return 0;
0427
0428 unsigned int binn = data.m_bin_number;
0429 data.m_bin_Sw = std::move(bins);
0430
0431 data.m_bin_entries.resize(binn,0);
0432 {std::vector<double> empty;
0433 empty.resize(1,0);
0434 data.m_bin_Sxw.resize(binn,empty);
0435 data.m_bin_Sx2w.resize(binn,empty);}
0436
0437 data.m_all_entries = static_cast<unsigned int>(fEntries);
0438 data.m_in_range_entries = 0;
0439 data.m_in_range_Sw = fSw;
0440 data.m_in_range_Sw2 = fSw2;
0441 data.m_in_range_Sxw.resize(1,0);
0442 data.m_in_range_Sx2w.resize(1,0);
0443 data.m_in_range_Sxw[0] = fSxw;
0444 data.m_in_range_Sx2w[0] = fSx2w;
0445
0446 histo::h1d* h = new histo::h1d("",10,0,1);
0447 h->copy_from_data(data);
0448 return h;
0449 }
0450
0451 inline histo::h2d* TH2F_stream(buffer& a_buffer){
0452 unsigned int _s,_c;
0453 short v;
0454 if(!a_buffer.read_version(v,_s,_c)) return 0;
0455
0456 // Version 3 streaming (ROOT/v3-00-6).
0457
0458 // Now we have to reconstruct a valid Histogram from a_buffer :
0459 hd_data data;
0460
0461 data.m_dimension = 2;
0462 //data.m_coords.resize(data.m_dimension,0);
0463 //data.m_ints.resize(data.m_dimension,0);
0464 data.m_axes.resize(2);
0465 data.m_in_range_plane_Sxyw.resize(1,0);
0466
0467 double fEntries; //in range + outflow.
0468 double fSw; //in range.
0469 double fSw2; //in range.
0470 double fSxw; //in range.
0471 double fSx2w; //in range.
0472 double fSyw; //in range.
0473 double fSy2w; //in range.
0474 if(!TH_read_2D(a_buffer,data,fEntries,fSw,fSw2,fSxw,fSx2w,fSyw,fSy2w)) return 0;
0475 // the upper set :
0476 //data.m_title
0477 //data.m_bin_number
0478 //data.m_axes
0479 //data.m_bin_Sw2
0480
0481 std::vector<float> bins; //fArray TArrayF
0482 if(!Array_stream<float>(a_buffer,bins)) return 0;
0483 if(!a_buffer.check_byte_count(_s,_c,"TH2F")) return 0;
0484
0485 unsigned int binn = data.m_bin_number;
0486 data.m_bin_Sw.resize(binn,0);
0487 {for(unsigned int index=0;index<binn;index++){
0488 data.m_bin_Sw[index] = double(bins[index]);
0489 }}
0490
0491 data.m_bin_entries.resize(binn,0);
0492 {std::vector<double> empty;
0493 empty.resize(2,0);
0494 data.m_bin_Sxw.resize(binn,empty);
0495 data.m_bin_Sx2w.resize(binn,empty);}
0496
0497 data.m_all_entries = static_cast<unsigned int>(fEntries);
0498 data.m_in_range_entries = 0;
0499 data.m_in_range_Sw = fSw;
0500 data.m_in_range_Sw2 = fSw2;
0501 data.m_in_range_Sxw.resize(2,0);
0502 data.m_in_range_Sx2w.resize(2,0);
0503 data.m_in_range_Sxw[0] = fSxw;
0504 data.m_in_range_Sx2w[0] = fSx2w;
0505 data.m_in_range_Sxw[1] = fSyw;
0506 data.m_in_range_Sx2w[1] = fSy2w;
0507
0508 histo::h2d* h = new histo::h2d("",10,0,1,10,0,1);
0509 h->copy_from_data(data);
0510 return h;
0511 }
0512
0513 inline histo::h2d* TH2D_stream(buffer& a_buffer){
0514 unsigned int _s,_c;
0515 short v;
0516 if(!a_buffer.read_version(v,_s,_c)) return 0;
0517
0518 // Version 3 streaming (ROOT/v3-00-6).
0519
0520 // Now we have to reconstruct a valid Histogram from a_buffer :
0521 hd_data data;
0522
0523 data.m_dimension = 2;
0524 data.m_axes.resize(2);
0525 data.m_in_range_plane_Sxyw.resize(1,0);
0526
0527 double fEntries; //in range + outflow.
0528 double fSw; //in range.
0529 double fSw2; //in range.
0530 double fSxw; //in range.
0531 double fSx2w; //in range.
0532 double fSyw; //in range.
0533 double fSy2w; //in range.
0534 if(!TH_read_2D(a_buffer,data,fEntries,fSw,fSw2,fSxw,fSx2w,fSyw,fSy2w)) return 0;
0535 // the upper set :
0536 //data.m_title
0537 //data.m_bin_number
0538 //data.m_axes
0539 //data.m_bin_Sw2
0540
0541 std::vector<double> bins; //fArray TArrayD
0542 if(!Array_stream<double>(a_buffer,bins)) return 0;
0543 if(!a_buffer.check_byte_count(_s,_c,"TH2D")) return 0;
0544
0545 unsigned int binn = data.m_bin_number;
0546 data.m_bin_Sw = std::move(bins);
0547
0548 data.m_bin_entries.resize(binn,0);
0549 {std::vector<double> empty;
0550 empty.resize(2,0);
0551 data.m_bin_Sxw.resize(binn,empty);
0552 data.m_bin_Sx2w.resize(binn,empty);}
0553
0554 data.m_all_entries = static_cast<unsigned int>(fEntries);
0555 data.m_in_range_entries = 0;
0556 data.m_in_range_Sw = fSw;
0557 data.m_in_range_Sw2 = fSw2;
0558 data.m_in_range_Sxw.resize(2,0);
0559 data.m_in_range_Sx2w.resize(2,0);
0560 data.m_in_range_Sxw[0] = fSxw;
0561 data.m_in_range_Sx2w[0] = fSx2w;
0562 data.m_in_range_Sxw[1] = fSyw;
0563 data.m_in_range_Sx2w[1] = fSy2w;
0564
0565 histo::h2d* h = new histo::h2d("",10,0,1,10,0,1);
0566 h->copy_from_data(data);
0567 return h;
0568 }
0569
0570 inline histo::h3d* TH3D_stream(buffer& a_buffer){
0571 unsigned int _s,_c;
0572 short v;
0573 if(!a_buffer.read_version(v,_s,_c)) return 0;
0574
0575 // Now we have to reconstruct a valid Histogram from a_buffer :
0576 hd_data data;
0577
0578 data.m_dimension = 3;
0579 data.m_axes.resize(3);
0580 data.m_in_range_plane_Sxyw.resize(3,0);
0581
0582 double fEntries; //in range + outflow.
0583 double fSw; //in range.
0584 double fSw2; //in range.
0585 double fSxw; //in range.
0586 double fSx2w; //in range.
0587 double fSyw; //in range.
0588 double fSy2w; //in range.
0589 double fSzw; //in range.
0590 double fSz2w; //in range.
0591 if(!TH_read_3D(a_buffer,data,fEntries,fSw,fSw2,fSxw,fSx2w,fSyw,fSy2w,fSzw,fSz2w)) return 0;
0592 // the upper set :
0593 //data.m_title
0594 //data.m_bin_number
0595 //data.m_axes
0596 //data.m_bin_Sw2
0597
0598 std::vector<double> bins; //fArray TArrayD
0599 if(!Array_stream<double>(a_buffer,bins)) return 0;
0600 if(!a_buffer.check_byte_count(_s,_c,"TH3D")) return 0;
0601
0602 unsigned int binn = data.m_bin_number;
0603 data.m_bin_Sw = std::move(bins);
0604
0605 data.m_bin_entries.resize(binn,0);
0606 {std::vector<double> empty;
0607 empty.resize(3,0);
0608 data.m_bin_Sxw.resize(binn,empty);
0609 data.m_bin_Sx2w.resize(binn,empty);}
0610
0611 data.m_all_entries = static_cast<unsigned int>(fEntries);
0612 data.m_in_range_entries = 0;
0613 data.m_in_range_Sw = fSw;
0614 data.m_in_range_Sw2 = fSw2;
0615 data.m_in_range_Sxw.resize(3,0);
0616 data.m_in_range_Sx2w.resize(3,0);
0617 data.m_in_range_Sxw[0] = fSxw;
0618 data.m_in_range_Sx2w[0] = fSx2w;
0619 data.m_in_range_Sxw[1] = fSyw;
0620 data.m_in_range_Sx2w[1] = fSy2w;
0621 data.m_in_range_Sxw[2] = fSzw;
0622 data.m_in_range_Sx2w[2] = fSz2w;
0623
0624 histo::h3d* h = new histo::h3d("",10,0,1,10,0,1,10,0,1);
0625 h->copy_from_data(data);
0626 return h;
0627 }
0628
0629 inline histo::p1d* TProfile_stream(buffer& a_buffer){
0630 unsigned int _s,_c;
0631 short v;
0632 if(!a_buffer.read_version(v,_s,_c)) return 0;
0633
0634 // Version 3 streaming (ROOT/v3-00-6).
0635
0636 //WARNING : the mapping histo::p1d / TProfile is not obvious.
0637 //p1d::m_bin_Svw <---> TProfile::fArray
0638 //p1d::m_bin_Sv2w <---> TProfile::fSumw2
0639 //p1d::m_bin_Sw <---> TProfile::fBinEntries
0640
0641 histo::h1d* h = TH1D_stream(a_buffer);
0642 if(!h) return 0;
0643
0644 //NOTE : histo.m_bin_Sw <---> TH1D::TArrayD::fArray
0645
0646 pd_data data(h->dac());
0647 delete h;
0648
0649 std::vector<double> bins; //fBinEntries TArrayD
0650 if(!Array_stream<double>(a_buffer,bins)) return 0;
0651 int errorMode;
0652 if(!a_buffer.read(errorMode)) return 0;
0653 double ymin;
0654 if(!a_buffer.read(ymin)) return 0;
0655 double ymax;
0656 if(!a_buffer.read(ymax)) return 0;
0657
0658 if(v>=4) {
0659 double sumwy;
0660 if(!a_buffer.read(sumwy)) return 0;
0661 double sumwy2;
0662 if(!a_buffer.read(sumwy2)) return 0;
0663 }
0664 if(v>=5) {
0665 std::vector<double> bins_sumw2; //fBinSumw2 TArrayD
0666 if(!Array_stream<double>(a_buffer,bins_sumw2)) return 0;
0667 }
0668
0669 if(!a_buffer.check_byte_count(_s,_c,"TProfile")) return 0;
0670
0671 data.m_is_profile = true;
0672 data.m_cut_v = true;
0673 data.m_min_v = ymin;
0674 data.m_max_v = ymax;
0675
0676 unsigned int binn = data.m_bin_number;
0677 data.m_bin_Svw.resize(binn);
0678 data.m_bin_Sv2w.resize(binn);
0679
0680 for(unsigned int index=0;index<binn;index++){
0681 double svw = data.m_bin_Sw[index];
0682 double sv2w = data.m_bin_Sw2[index];
0683 double sw = bins[index];
0684 //data.m_bin_entries[index] = (int)sw; //FIXME : ok for w = 1 only !
0685 data.m_bin_Sw[index] = (double)sw;
0686 //FIXME : data.m_bin_Sxw
0687 //FIXME : data.m_bin_Sx2w
0688 data.m_bin_Svw[index] = svw;
0689 data.m_bin_Sv2w[index] = sv2w;
0690 }
0691
0692 histo::p1d* p = new histo::p1d("",10,0,1);
0693 p->copy_from_data(data);
0694 // We have now a valid histo::p1d.
0695 return p;
0696 }
0697
0698 inline histo::p2d* TProfile2D_stream(buffer& a_buffer){
0699 unsigned int _s,_c;
0700 short v;
0701 if(!a_buffer.read_version(v,_s,_c)) return 0;
0702
0703 // Version 3 streaming (ROOT/v3-00-6).
0704
0705 //WARNING : the mapping histo::p1d / TProfile is not obvious.
0706 //p1d::m_bin_Svw <---> TProfile::fArray
0707 //p1d::m_bin_Sv2w <---> TProfile::fSumw2
0708 //p1d::m_bin_Sw <---> TProfile::fBinEntries
0709
0710 histo::h2d* h = TH2D_stream(a_buffer);
0711 if(!h) return 0;
0712
0713 //NOTE : histo.m_bin_Sw <---> TH2D::TArrayD::fArray
0714
0715 pd_data data(h->dac());
0716 delete h;
0717
0718 std::vector<double> bins; //fBinEntries TArrayD
0719 if(!Array_stream<double>(a_buffer,bins)) return 0;
0720 int errorMode;
0721 if(!a_buffer.read(errorMode)) return 0;
0722 double zmin;
0723 if(!a_buffer.read(zmin)) return 0;
0724 double zmax;
0725 if(!a_buffer.read(zmax)) return 0;
0726 if(v>=5) {
0727 double sumwz;
0728 if(!a_buffer.read(sumwz)) return 0;
0729 double sumwz2;
0730 if(!a_buffer.read(sumwz2)) return 0;
0731 }
0732 if(v>=7) {
0733 std::vector<double> bins_sumw2; //fBinSumw2 TArrayD
0734 if(!Array_stream<double>(a_buffer,bins_sumw2)) return 0;
0735 }
0736 if(!a_buffer.check_byte_count(_s,_c,"TProfile2D")) return 0;
0737
0738 data.m_is_profile = true;
0739 data.m_cut_v = true;
0740 data.m_min_v = zmin;
0741 data.m_max_v = zmax;
0742
0743 unsigned int binn = data.m_bin_number;
0744 data.m_bin_Svw.resize(binn);
0745 data.m_bin_Sv2w.resize(binn);
0746
0747 for(unsigned int index=0;index<binn;index++){
0748 double svw = data.m_bin_Sw[index];
0749 double sv2w = data.m_bin_Sw2[index];
0750 double sw = bins[index];
0751 //data.m_bin_entries[index] = (int)sw; //FIXME : ok for w = 1 only !
0752 data.m_bin_Sw[index] = (double)sw;
0753 //FIXME : data.m_bin_Sxw
0754 //FIXME : data.m_bin_Sx2w
0755 data.m_bin_Svw[index] = svw;
0756 data.m_bin_Sv2w[index] = sv2w;
0757 }
0758
0759 histo::p2d* p = new histo::p2d("",10,0,1,10,0,1);
0760 p->copy_from_data(data);
0761 return p;
0762 }
0763
0764 class TDirectory : public directory {
0765 public:
0766 TDirectory(ifile& a_file):directory(a_file){}
0767 virtual ~TDirectory(){}
0768 protected:
0769 TDirectory(const TDirectory& a_from):directory(a_from){}
0770 TDirectory& operator=(const TDirectory&){return *this;}
0771 public:
0772 bool stream(buffer& a_buffer){
0773 initialize();
0774 short version;
0775 if(!a_buffer.read_version(version)) return false;
0776 unsigned int _date;
0777 if(!a_buffer.read(_date)) return false;
0778 //m_date_C.setDate(_date);
0779 if(!a_buffer.read(_date)) return false;
0780 //m_date_M.setDate(_date);
0781 if(!a_buffer.read(m_nbytes_keys)) return false;
0782 if(!a_buffer.read(m_nbytes_name)) return false;
0783 if((uint32)version>big_file_version_tag()) {
0784 if(!a_buffer.read(m_seek_directory)) return false;
0785 if(!a_buffer.read(m_seek_parent)) return false;
0786 if(!a_buffer.read(m_seek_keys)) return false;
0787 } else {
0788 {seek32 i;
0789 if(!a_buffer.read(i)) return false;
0790 m_seek_directory = i;}
0791
0792 {seek32 i;
0793 if(!a_buffer.read(i)) return false;
0794 m_seek_parent = i;}
0795
0796 {seek32 i;
0797 if(!a_buffer.read(i)) return false;
0798 m_seek_keys = i;}
0799 }
0800
0801 if (m_seek_keys) {
0802 uint32 n;
0803 if(!read_keys(n)) {
0804 a_buffer.out() << "tools::rroot::TDirectory::stream :"
0805 << " cannot read keys."
0806 << std::endl;
0807 return false;
0808 }
0809 }
0810
0811 return true;
0812 }
0813 protected:
0814 void initialize(){
0815 // Initialise directory to defaults :
0816 // If directory is created via default ctor (when dir is read from file)
0817 // don't add it here to the directory since its name is not yet known.
0818 // It will be added to the directory in TKey::ReadObj().
0819 m_date_C = 0;//m_date_C.set();
0820 m_date_M = 0;//m_date_M.set();
0821 m_nbytes_keys = 0;
0822 m_seek_directory = 0;
0823 m_seek_parent = 0;
0824 m_seek_keys = 0;
0825 }
0826 };
0827
0828
0829 inline void dump(std::ostream& a_out,
0830 ifile& a_file,
0831 const std::vector<key*>& a_keys,
0832 bool a_recursive,
0833 unsigned int a_spaces = 0) {
0834
0835 // dump non directory objects :
0836 {std::vector<key*>::const_iterator it;
0837 for(it=a_keys.begin();it!=a_keys.end();++it) {
0838 key& k = *(*it);
0839 if(k.object_class()==TDirectory_cls()) continue;
0840 {for(unsigned int index=0;index<a_spaces;index++) a_out << " ";}
0841 k.dump(a_out);
0842 }}
0843
0844 // dump directories :
0845 {std::vector<key*>::const_iterator it;
0846 for(it=a_keys.begin();it!=a_keys.end();++it) {
0847 key& k = *(*it);
0848 if(k.object_class()!=TDirectory_cls()) continue;
0849
0850 std::string label = k.object_name();
0851 {for(unsigned int index=0;index<a_spaces;index++) a_out << " ";}
0852 a_out << "directory : " << label << std::endl;
0853
0854 if(!a_recursive) continue;
0855
0856 uint32 sz;
0857 char* buf = k.get_object_buffer(a_file,sz);
0858 //we don't have ownership of buf.
0859 if(!buf) {
0860 a_out << "tools::rroot::dump :"
0861 << " can't get directory data buffer."
0862 << std::endl;
0863 } else {
0864 buffer b(a_out,a_file.byte_swap(),sz,buf,k.key_length(),false);
0865 TDirectory tdir(a_file);
0866 if(!tdir.stream(b)) {
0867 a_out << "tools::rroot::dump :"
0868 << " can't stream TDirectory."
0869 << std::endl;
0870 } else {
0871 const std::vector<key*>& keys = tdir.keys();
0872 dump(a_out,a_file,keys,a_recursive,a_spaces+1);
0873 }
0874 }
0875 }}
0876 }
0877
0878 }}
0879
0880 #endif
