Warning, /include/Geant4/tools/rroot/THistogram 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_THistogram
0005 #define tools_rroot_THistogram
0006
0007 // to read some files produced with BatchLab (opaw/examples/osc/analysis.root).
0008
0009 #include "../histo/profile_data"
0010
0011 #include "named"
0012 #include "../vmanip"
0013
0014 namespace tools {
0015 namespace rroot {
0016
0017 typedef histo::profile_data<double,unsigned int,unsigned int,double,double> pd_data_t;
0018 typedef histo::axis<double,unsigned int> axis_t;
0019 typedef std::map<std::string,std::string> annotations_t;
0020
0021 inline bool Axis_read_v0_v3(buffer& a_buffer,axis_t& a_axis) {
0022 int idummy;
0023 double ddummy;
0024 if(!a_buffer.read(a_axis.m_minimum_value)) return false;
0025 if(!a_buffer.read(a_axis.m_maximum_value)) return false;
0026 if(!a_buffer.read(a_axis.m_offset)) return false;
0027 if(!a_buffer.read(a_axis.m_number_of_bins)) return false;
0028 if(!a_buffer.read(idummy)) return false; //fOverFlow
0029 if(!a_buffer.read(idummy)) return false; //fUnderFlow
0030 if(!a_buffer.read(a_axis.m_bin_width)) return false;
0031 if(!a_buffer.read(ddummy)) return false; //fSxw
0032 if(!a_buffer.read(ddummy)) return false; //fSx2w
0033 a_axis.m_fixed = true;
0034 a_axis.m_edges.clear();
0035 return true;
0036 }
0037
0038 inline bool Axis_read_v4_v6(buffer& a_buffer,axis_t& a_axis) {
0039 int idummy;
0040 double ddummy;
0041 if(!a_buffer.read(a_axis.m_offset)) return false;
0042 if(!a_buffer.read(idummy)) return false; //fOverFlow
0043 if(!a_buffer.read(idummy)) return false; //fUnderFlow
0044 if(!a_buffer.read(ddummy)) return false; //fSxw
0045 if(!a_buffer.read(ddummy)) return false; //fSx2w
0046 if(!a_buffer.read(a_axis.m_number_of_bins)) return false;
0047 if(!a_buffer.read(a_axis.m_minimum_value)) return false;
0048 if(!a_buffer.read(a_axis.m_maximum_value)) return false;
0049 if(!a_buffer.read(a_axis.m_fixed)) return false;
0050 if(!a_buffer.read(a_axis.m_bin_width)) return false;
0051 int edgen;
0052 if(!a_buffer.read(edgen)) return false;
0053 for(int count=0;count<edgen;count++) {
0054 double value;
0055 if(!a_buffer.read(value)) return false;
0056 a_axis.m_edges.push_back(value);
0057 }
0058 return true;
0059 }
0060
0061 inline bool Axis_read_v7(buffer& a_buffer,axis_t& a_axis) {
0062 if(!a_buffer.read(a_axis.m_offset)) return false;
0063 if(!a_buffer.read(a_axis.m_number_of_bins)) return false;
0064 if(!a_buffer.read(a_axis.m_minimum_value)) return false;
0065 if(!a_buffer.read(a_axis.m_maximum_value)) return false;
0066 if(!a_buffer.read(a_axis.m_fixed)) return false;
0067 if(!a_buffer.read(a_axis.m_bin_width)) return false;
0068 int edgen;
0069 if(!a_buffer.read(edgen)) return false;
0070 for(int count=0;count<edgen;count++) {
0071 double value;
0072 if(!a_buffer.read(value)) return false;
0073 a_axis.m_edges.push_back(value);
0074 }
0075 return true;
0076 }
0077
0078 inline unsigned int new_bin_number(const std::vector< axis_t >& aAxes) {
0079 unsigned int number = 1;
0080 for(unsigned int iaxis=0;iaxis<aAxes.size();iaxis++)
0081 number *= (aAxes[iaxis].bins()+2);
0082 return number;
0083 }
0084
0085 template <class T>
0086 inline void add_outflow(const std::vector< axis_t >& aAxes,std::vector<T>& aVector) {
0087 // aAxes[].m_offset contains the offset without outflow.
0088 std::size_t dim = aAxes.size();
0089 // new size and offsets :
0090 std::vector<int> aoff(dim);
0091
0092 int newn = 1;
0093 {for(unsigned iaxis=0;iaxis<dim;iaxis++) newn *= (aAxes[iaxis].bins()+2);}
0094
0095 aoff[0] = 1;
0096 {for(unsigned iaxis=1;iaxis<dim;iaxis++) {
0097 aoff[iaxis] = aoff[iaxis-1] * (aAxes[iaxis-1].bins()+2);
0098 }}
0099 // copy :
0100 std::vector<T> tmp = aVector;
0101 int oldn = (int)tmp.size();
0102 aVector.resize(newn,0);
0103 // Copy :
0104 std::vector<int> is(dim);
0105 int offset;
0106 for(int index=0;index<oldn;index++) {
0107 // Get new offset of index :
0108 offset = index;
0109 {for(int iaxis=(int)dim-1;iaxis>=0;iaxis--) {
0110 is[iaxis] = offset/aAxes[iaxis].m_offset;
0111 offset -= is[iaxis] * aAxes[iaxis].m_offset;
0112 }}
0113 // new offset :
0114 offset = 0;
0115 {for(std::size_t iaxis=0;iaxis<dim;iaxis++) offset += is[iaxis] * aoff[iaxis];}
0116 aVector[offset] = tmp[index];
0117 }
0118 }
0119
0120 inline void add_outflow(std::vector< axis_t >& aAxes) {
0121 // Restore new offsets :
0122 aAxes[0].m_offset = 1;
0123 for(unsigned int iaxis=1;iaxis<aAxes.size();iaxis++)
0124 aAxes[iaxis].m_offset = aAxes[iaxis-1].m_offset * (aAxes[iaxis-1].bins()+2);
0125 }
0126
0127 inline bool read_v0(buffer& a_buffer,pd_data_t& a_data) {
0128 int idummy;
0129 double ddummy;
0130 std::string sdummy;
0131 if(!a_buffer.read(sdummy)) return false;
0132 if(!a_buffer.read(a_data.m_title)) return false;
0133
0134 {int dim;
0135 if(!a_buffer.read(dim)) return false;
0136 a_data.m_dimension = dim;}
0137
0138 {int nbin;
0139 if(!a_buffer.read(nbin)) return false;
0140 a_data.m_bin_number = nbin;}
0141
0142 if(!a_buffer.read(idummy)) return false; //fEntries
0143 if(!a_buffer.read(idummy)) return false; //fOutFlow
0144 if(!a_buffer.read(ddummy)) return false; //fSw
0145
0146 std::vector<int> vec;
0147 if(!a_buffer.read_array<int>(vec)) return false;
0148 convert<int,unsigned int>(vec,a_data.m_bin_entries);
0149
0150 if(a_data.m_bin_entries.size()!=a_data.m_bin_number) return false;
0151 if(!a_buffer.read_array<double>(a_data.m_bin_Sw)) return false;
0152 if(a_data.m_bin_Sw.size()!=a_data.m_bin_number) return false;
0153 if(!a_buffer.read_array<double>(a_data.m_bin_Sw2)) return false;
0154 if(a_data.m_bin_Sw2.size()!=a_data.m_bin_number) return false;
0155 if(a_data.m_dimension>0) {
0156 a_data.m_axes.resize(a_data.m_dimension);
0157 for(unsigned int iaxis=0;iaxis<a_data.m_dimension;iaxis++) {
0158 if(!Axis_read_v0_v3(a_buffer,a_data.m_axes[iaxis])) return false;
0159 }
0160 }
0161 axis_t axisOfValues;
0162 if(!Axis_read_v0_v3(a_buffer,axisOfValues)) return false;
0163 {int dummy;
0164 if(!a_buffer.read(dummy)) return false;} //m_mode
0165
0166 // Add outflow :
0167 a_data.m_bin_number = new_bin_number(a_data.m_axes);
0168 add_outflow<unsigned int>(a_data.m_axes,a_data.m_bin_entries);
0169 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw);
0170 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw2);
0171 add_outflow(a_data.m_axes);
0172
0173 // Not here in v0 :
0174 std::vector<double> empty;
0175 empty.resize(a_data.m_dimension,0);
0176 a_data.m_bin_Sxw.resize(a_data.m_bin_number,empty);
0177 a_data.m_bin_Sx2w.resize(a_data.m_bin_number,empty);
0178 a_data.m_is_profile = false;
0179 a_data.m_bin_Svw.clear();
0180 a_data.m_bin_Sv2w.clear();
0181
0182 return true;
0183 }
0184
0185 inline bool read_v1(buffer& a_buffer,pd_data_t& a_data) {
0186 int idummy;
0187 double ddummy;
0188 if(!a_buffer.read(a_data.m_title)) return false;
0189
0190 {int dim;
0191 if(!a_buffer.read(dim)) return false;
0192 a_data.m_dimension = dim;}
0193
0194 {int nbin;
0195 if(!a_buffer.read(nbin)) return false;
0196 a_data.m_bin_number = nbin;}
0197
0198 if(!a_buffer.read(idummy)) return false; //fEntries
0199 if(!a_buffer.read(idummy)) return false; //fOutFlow
0200 if(!a_buffer.read(ddummy)) return false; //fSw
0201
0202 std::vector<int> vec;
0203 if(!a_buffer.read_array<int>(vec)) return false;
0204 convert<int,unsigned int>(vec,a_data.m_bin_entries);
0205
0206 if(a_data.m_bin_entries.size()!=a_data.m_bin_number) return false;
0207 if(!a_buffer.read_array<double>(a_data.m_bin_Sw)) return false;
0208 if(a_data.m_bin_Sw.size()!=a_data.m_bin_number) return false;
0209 if(!a_buffer.read_array<double>(a_data.m_bin_Sw2)) return false;
0210 if(a_data.m_bin_Sw2.size()!=a_data.m_bin_number) return false;
0211 if(a_data.m_dimension>0) {
0212 a_data.m_axes.resize(a_data.m_dimension);
0213 for(unsigned int iaxis=0;iaxis<a_data.m_dimension;iaxis++) {
0214 if(!Axis_read_v0_v3(a_buffer,a_data.m_axes[iaxis])) return false;
0215 }
0216 }
0217 axis_t axisOfValues;
0218 if(!Axis_read_v0_v3(a_buffer,axisOfValues)) return false;
0219 {int dummy;
0220 if(!a_buffer.read(dummy)) return false;} //m_mode
0221
0222 // Add outflow :
0223 a_data.m_bin_number = new_bin_number(a_data.m_axes);
0224 add_outflow<unsigned int>(a_data.m_axes,a_data.m_bin_entries);
0225 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw);
0226 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw2);
0227 add_outflow(a_data.m_axes);
0228
0229 // Not here in v1 :
0230 std::vector<double> empty;
0231 empty.resize(a_data.m_dimension,0);
0232 a_data.m_bin_Sxw.resize(a_data.m_bin_number,empty);
0233 a_data.m_bin_Sx2w.resize(a_data.m_bin_number,empty);
0234 a_data.m_is_profile = false;
0235 a_data.m_bin_Svw.clear();
0236 a_data.m_bin_Sv2w.clear();
0237
0238 return true;
0239 }
0240
0241 inline bool read_v2(buffer& a_buffer,pd_data_t& a_data) {
0242 int idummy;
0243 double ddummy;
0244 std::string sdummy;
0245 if(!a_buffer.read(a_data.m_title)) return false;
0246 if(!a_buffer.read(sdummy)) return false;
0247
0248 {int dim;
0249 if(!a_buffer.read(dim)) return false;
0250 a_data.m_dimension = dim;}
0251
0252 {int nbin;
0253 if(!a_buffer.read(nbin)) return false;
0254 a_data.m_bin_number = nbin;}
0255
0256 if(!a_buffer.read(idummy)) return false; //fEntries
0257 if(!a_buffer.read(idummy)) return false; //fOutFlow
0258 if(!a_buffer.read(ddummy)) return false; //fSw
0259
0260 std::vector<int> vec;
0261 if(!a_buffer.read_array<int>(vec)) return false;
0262 convert<int,unsigned int>(vec,a_data.m_bin_entries);
0263
0264 if(a_data.m_bin_entries.size()!=a_data.m_bin_number) return false;
0265 if(!a_buffer.read_array<double>(a_data.m_bin_Sw)) return false;
0266 if(a_data.m_bin_Sw.size()!=a_data.m_bin_number) return false;
0267 if(!a_buffer.read_array<double>(a_data.m_bin_Sw2)) return false;
0268 if(a_data.m_bin_Sw2.size()!=a_data.m_bin_number) return false;
0269 if(a_data.m_dimension>0) {
0270 a_data.m_axes.resize(a_data.m_dimension);
0271 for(unsigned int iaxis=0;iaxis<a_data.m_dimension;iaxis++) {
0272 if(!Axis_read_v0_v3(a_buffer,a_data.m_axes[iaxis])) return false;
0273 }
0274 }
0275 axis_t axisOfValues;
0276 if(!Axis_read_v0_v3(a_buffer,axisOfValues)) return false;
0277 {int dummy;
0278 if(!a_buffer.read(dummy)) return false;} //m_mode
0279
0280 // Add outflow :
0281 a_data.m_bin_number = new_bin_number(a_data.m_axes);
0282 add_outflow<unsigned int>(a_data.m_axes,a_data.m_bin_entries);
0283 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw);
0284 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw2);
0285 add_outflow(a_data.m_axes);
0286
0287 // Not here in v2 :
0288 std::vector<double> empty;
0289 empty.resize(a_data.m_dimension,0);
0290 a_data.m_bin_Sxw.resize(a_data.m_bin_number,empty);
0291 a_data.m_bin_Sx2w.resize(a_data.m_bin_number,empty);
0292 a_data.m_is_profile = false;
0293 a_data.m_bin_Svw.clear();
0294 a_data.m_bin_Sv2w.clear();
0295
0296 return true;
0297 }
0298
0299 inline bool read_v3(buffer& a_buffer,pd_data_t& a_data) {
0300 int idummy;
0301 double ddummy;
0302
0303 int l;
0304 if(!a_buffer.read(l)) return false;
0305 char* str = new char[l+1];
0306 for (int i = 0; i < l; i++) {
0307 if(!a_buffer.read(str[i])) { delete [] str;return false;}
0308 }
0309 str[l] = '\0';
0310 a_data.m_title = str;
0311 delete [] str;
0312
0313 {int dim;
0314 if(!a_buffer.read(dim)) return false;
0315 a_data.m_dimension = dim;}
0316
0317 {int nbin;
0318 if(!a_buffer.read(nbin)) return false;
0319 a_data.m_bin_number = nbin;}
0320
0321 if(!a_buffer.read(idummy)) return false; //fEntries
0322 if(!a_buffer.read(idummy)) return false; //fOutFlow
0323 if(!a_buffer.read(ddummy)) return false; //fSw
0324
0325 std::vector<int> vec;
0326 if(!a_buffer.read_array<int>(vec)) return false;
0327 convert<int,unsigned int>(vec,a_data.m_bin_entries);
0328
0329 if(a_data.m_bin_entries.size()!=a_data.m_bin_number) return false;
0330 if(!a_buffer.read_array<double>(a_data.m_bin_Sw)) return false;
0331 if(a_data.m_bin_Sw.size()!=a_data.m_bin_number) return false;
0332 if(!a_buffer.read_array<double>(a_data.m_bin_Sw2)) return false;
0333 if(a_data.m_bin_Sw2.size()!=a_data.m_bin_number) return false;
0334 if(a_data.m_dimension>0) {
0335 a_data.m_axes.resize(a_data.m_dimension);
0336 for(unsigned int iaxis=0;iaxis<a_data.m_dimension;iaxis++) {
0337 if(!Axis_read_v0_v3(a_buffer,a_data.m_axes[iaxis])) return false;
0338 }
0339 }
0340 axis_t axisOfValues;
0341 if(!Axis_read_v0_v3(a_buffer,axisOfValues)) return false;
0342 {int dummy;
0343 if(!a_buffer.read(dummy)) return false;} //m_mode
0344
0345 // Add outflow :
0346 a_data.m_bin_number = new_bin_number(a_data.m_axes);
0347 add_outflow<unsigned int>(a_data.m_axes,a_data.m_bin_entries);
0348 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw);
0349 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw2);
0350 add_outflow(a_data.m_axes);
0351
0352 // Not here in v3 :
0353 std::vector<double> empty;
0354 empty.resize(a_data.m_dimension,0);
0355 a_data.m_bin_Sxw.resize(a_data.m_bin_number,empty);
0356 a_data.m_bin_Sx2w.resize(a_data.m_bin_number,empty);
0357 a_data.m_is_profile = false;
0358 a_data.m_bin_Svw.clear();
0359 a_data.m_bin_Sv2w.clear();
0360
0361 return true;
0362 }
0363
0364 inline bool read_v4(buffer& a_buffer,pd_data_t& a_data) {
0365 int idummy;
0366 double ddummy;
0367
0368 int l;
0369 if(!a_buffer.read(l)) return false;
0370 char* str = new char[l+1];
0371 for (int i = 0; i < l; i++) {
0372 if(!a_buffer.read(str[i])) { delete [] str;return false;}
0373 }
0374 str[l] = '\0';
0375 a_data.m_title = str;
0376 delete [] str;
0377
0378 {int dim;
0379 if(!a_buffer.read(dim)) return false;
0380 a_data.m_dimension = dim;}
0381
0382 {int nbin;
0383 if(!a_buffer.read(nbin)) return false;
0384 a_data.m_bin_number = nbin;}
0385
0386 if(!a_buffer.read(idummy)) return false; //fEntries
0387 if(!a_buffer.read(idummy)) return false; //fOutFlow
0388 if(!a_buffer.read(ddummy)) return false; //fSw
0389
0390 std::vector<int> vec;
0391 if(!a_buffer.read_array<int>(vec)) return false;
0392 convert<int,unsigned int>(vec,a_data.m_bin_entries);
0393
0394 if(a_data.m_bin_entries.size()!=a_data.m_bin_number) return false;
0395 if(!a_buffer.read_array<double>(a_data.m_bin_Sw)) return false;
0396 if(a_data.m_bin_Sw.size()!=a_data.m_bin_number) return false;
0397 if(!a_buffer.read_array<double>(a_data.m_bin_Sw2)) return false;
0398 if(a_data.m_bin_Sw2.size()!=a_data.m_bin_number) return false;
0399 if(a_data.m_dimension>0) {
0400 a_data.m_axes.resize(a_data.m_dimension);
0401 for(unsigned int iaxis=0;iaxis<a_data.m_dimension;iaxis++) {
0402 if(!Axis_read_v4_v6(a_buffer,a_data.m_axes[iaxis])) return false;
0403 }
0404 }
0405 {int dummy;
0406 if(!a_buffer.read(dummy)) return false;} //m_mode
0407
0408 // Add outflow :
0409 a_data.m_bin_number = new_bin_number(a_data.m_axes);
0410 add_outflow<unsigned int>(a_data.m_axes,a_data.m_bin_entries);
0411 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw);
0412 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw2);
0413 add_outflow(a_data.m_axes);
0414
0415 // Not here in v4 :
0416 std::vector<double> empty;
0417 empty.resize(a_data.m_dimension,0);
0418 a_data.m_bin_Sxw.resize(a_data.m_bin_number,empty);
0419 a_data.m_bin_Sx2w.resize(a_data.m_bin_number,empty);
0420 a_data.m_is_profile = false;
0421 a_data.m_bin_Svw.clear();
0422 a_data.m_bin_Sv2w.clear();
0423
0424 return true;
0425 }
0426
0427 inline bool read_v5(buffer& a_buffer,pd_data_t& a_data) {
0428 int idummy;
0429 double ddummy;
0430 if(!a_buffer.read(a_data.m_title)) return false;
0431
0432 {int dim;
0433 if(!a_buffer.read(dim)) return false;
0434 a_data.m_dimension = dim;}
0435
0436 {int nbin;
0437 if(!a_buffer.read(nbin)) return false;
0438 a_data.m_bin_number = nbin;}
0439
0440 if(!a_buffer.read(idummy)) return false; //fEntries
0441 if(!a_buffer.read(idummy)) return false; //fOutFlow
0442 if(!a_buffer.read(ddummy)) return false; //fSw
0443
0444 std::vector<int> vec;
0445 if(!a_buffer.read_array<int>(vec)) return false;
0446 convert<int,unsigned int>(vec,a_data.m_bin_entries);
0447
0448 if(a_data.m_bin_entries.size()!=a_data.m_bin_number) return false;
0449 if(!a_buffer.read_array<double>(a_data.m_bin_Sw)) return false;
0450 if(a_data.m_bin_Sw.size()!=a_data.m_bin_number) return false;
0451 if(!a_buffer.read_array<double>(a_data.m_bin_Sw2)) return false;
0452 if(a_data.m_bin_Sw2.size()!=a_data.m_bin_number) return false;
0453 if(a_data.m_dimension>0) {
0454 a_data.m_axes.resize(a_data.m_dimension);
0455 for(unsigned int iaxis=0;iaxis<a_data.m_dimension;iaxis++) {
0456 if(!Axis_read_v4_v6(a_buffer,a_data.m_axes[iaxis])) return false;
0457 }
0458 }
0459 {int dummy;
0460 if(!a_buffer.read(dummy)) return false;} //m_mode
0461
0462 // Add outflow :
0463 a_data.m_bin_number = new_bin_number(a_data.m_axes);
0464 add_outflow<unsigned int>(a_data.m_axes,a_data.m_bin_entries);
0465 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw);
0466 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw2);
0467 add_outflow(a_data.m_axes);
0468
0469 // Not here in v5 :
0470 std::vector<double> empty;
0471 empty.resize(a_data.m_dimension,0);
0472 a_data.m_bin_Sxw.resize(a_data.m_bin_number,empty);
0473 a_data.m_bin_Sx2w.resize(a_data.m_bin_number,empty);
0474 a_data.m_is_profile = false;
0475 a_data.m_bin_Svw.clear();
0476 a_data.m_bin_Sv2w.clear();
0477
0478 return true;
0479 }
0480
0481 inline bool read_v6(buffer& a_buffer,pd_data_t& a_data) {
0482 int idummy;
0483 double ddummy;
0484 if(!a_buffer.read(a_data.m_title)) return false;
0485
0486 {int dim;
0487 if(!a_buffer.read(dim)) return false;
0488 a_data.m_dimension = dim;}
0489
0490 {int nbin;
0491 if(!a_buffer.read(nbin)) return false;
0492 a_data.m_bin_number = nbin;}
0493
0494 if(!a_buffer.read(idummy)) return false; //fEntries
0495 if(!a_buffer.read(idummy)) return false; //fOutFlow
0496 if(!a_buffer.read(ddummy)) return false; //fSw
0497
0498 std::vector<int> vec;
0499 if(!a_buffer.read_array<int>(vec)) return false;
0500 convert<int,unsigned int>(vec,a_data.m_bin_entries);
0501
0502 if(a_data.m_bin_entries.size()!=a_data.m_bin_number) return false;
0503 if(!a_buffer.read_array<double>(a_data.m_bin_Sw)) return false;
0504 if(a_data.m_bin_Sw.size()!=a_data.m_bin_number) return false;
0505 if(!a_buffer.read_array<double>(a_data.m_bin_Sw2)) return false;
0506 if(a_data.m_bin_Sw2.size()!=a_data.m_bin_number) return false;
0507 if(a_data.m_dimension>0) {
0508 a_data.m_axes.resize(a_data.m_dimension);
0509 for(unsigned int iaxis=0;iaxis<a_data.m_dimension;iaxis++) {
0510 if(!Axis_read_v4_v6(a_buffer,a_data.m_axes[iaxis])) return false;
0511 }
0512 }
0513 {int dummy;
0514 if(!a_buffer.read(dummy)) return false;} //m_mode
0515
0516 // Profile :
0517 if(!a_buffer.read(a_data.m_is_profile)) return false;
0518 if(a_data.m_is_profile) {
0519 if(!a_buffer.read_array<double>(a_data.m_bin_Svw)) return false;
0520 if(a_data.m_bin_Svw.size()!=a_data.m_bin_number) return false;
0521 if(!a_buffer.read(a_data.m_cut_v)) return false;
0522 if(!a_buffer.read(a_data.m_min_v)) return false;
0523 if(!a_buffer.read(a_data.m_max_v)) return false;
0524 }
0525
0526 // Add outflow :
0527 a_data.m_bin_number = new_bin_number(a_data.m_axes);
0528 add_outflow<unsigned int>(a_data.m_axes,a_data.m_bin_entries);
0529 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw);
0530 add_outflow<double>(a_data.m_axes,a_data.m_bin_Sw2);
0531 add_outflow<double>(a_data.m_axes,a_data.m_bin_Svw);
0532 add_outflow(a_data.m_axes);
0533
0534 // Not here in v6 :
0535 std::vector<double> empty;
0536 empty.resize(a_data.m_dimension,0);
0537 a_data.m_bin_Sxw.resize(a_data.m_bin_number,empty); //Forget to write in v6 !
0538 a_data.m_bin_Sx2w.resize(a_data.m_bin_number,empty);
0539 if(a_data.m_is_profile) {
0540 a_data.m_bin_Sv2w.resize(a_data.m_bin_number,0);
0541 }
0542
0543 return true;
0544 }
0545
0546 inline bool read_v7(buffer& a_buffer,pd_data_t& a_data) {
0547 if(!a_buffer.read(a_data.m_title)) return false;
0548
0549 {int dim;
0550 if(!a_buffer.read(dim)) return false;
0551 a_data.m_dimension = dim;}
0552
0553 {int nbin;
0554 if(!a_buffer.read(nbin)) return false;
0555 a_data.m_bin_number = nbin;}
0556
0557 std::vector<int> vec;
0558 if(!a_buffer.read_array<int>(vec)) return false;
0559 convert<int,unsigned int>(vec,a_data.m_bin_entries);
0560
0561 if(a_data.m_bin_entries.size()!=a_data.m_bin_number) return false;
0562 if(!a_buffer.read_array<double>(a_data.m_bin_Sw)) return false;
0563 if(a_data.m_bin_Sw.size()!=a_data.m_bin_number) return false;
0564 if(!a_buffer.read_array<double>(a_data.m_bin_Sw2)) return false;
0565 if(a_data.m_bin_Sw2.size()!=a_data.m_bin_number) return false;
0566 if(!a_buffer.read_array2<double>(a_data.m_bin_Sxw)) return false;
0567 if(a_data.m_bin_Sxw.size()!=a_data.m_bin_number) return false;
0568 if(!a_buffer.read_array2<double>(a_data.m_bin_Sx2w)) return false;
0569 if(a_data.m_bin_Sx2w.size()!=a_data.m_bin_number) return false;
0570 if(a_data.m_dimension>0) {
0571 a_data.m_axes.resize(a_data.m_dimension);
0572 for(unsigned int iaxis=0;iaxis<a_data.m_dimension;iaxis++) {
0573 if(!Axis_read_v7(a_buffer,a_data.m_axes[iaxis])) return false;
0574 }
0575 }
0576 {int dummy;
0577 if(!a_buffer.read(dummy)) return false;} //m_mode
0578 // Profile :
0579 if(!a_buffer.read(a_data.m_is_profile)) return false;
0580 if(a_data.m_is_profile) {
0581 if(!a_buffer.read_array<double>(a_data.m_bin_Svw)) return false;
0582 if(a_data.m_bin_Svw.size()!=a_data.m_bin_number) return false;
0583 if(!a_buffer.read_array<double>(a_data.m_bin_Sv2w)) return false;
0584 if(a_data.m_bin_Sv2w.size()!=a_data.m_bin_number) return false;
0585 if(!a_buffer.read(a_data.m_cut_v)) return false;
0586 if(!a_buffer.read(a_data.m_min_v)) return false;
0587 if(!a_buffer.read(a_data.m_max_v)) return false;
0588 }
0589
0590 return true;
0591 }
0592
0593 inline bool read_annotations(buffer& a_buffer,annotations_t& a_annotations) {
0594 a_annotations.clear(); //reset() does not remove sticky items.
0595 int number;
0596 if(!a_buffer.read(number)) return false;
0597 for(int index=0;index<number;index++) {
0598 std::string key;
0599 if(!a_buffer.read(key)) return false;
0600 std::string value;
0601 if(!a_buffer.read(value)) return false;
0602 bool sticky;
0603 if(!a_buffer.read(sticky)) return false;
0604 a_annotations[key] = value;
0605 }
0606 return true;
0607 }
0608
0609 inline bool read_THistogram(buffer& a_buffer,pd_data_t& a_data,annotations_t& a_annotations) {
0610
0611 short v;
0612 if(!a_buffer.read_version(v)) return false;
0613
0614 {std::string name,title;
0615 if(!Named_stream(a_buffer,name,title)) return false;}
0616
0617 if(v==0) {
0618 if(!read_v0(a_buffer,a_data)) return false;
0619 } else if(v==1) {
0620 if(!read_v1(a_buffer,a_data)) return false;
0621 } else if(v==2) {
0622 if(!read_v2(a_buffer,a_data)) return false;
0623 } else if(v==3) {
0624 if(!read_v3(a_buffer,a_data)) return false;
0625 } else if(v==4) {
0626 if(!read_v4(a_buffer,a_data)) return false;
0627 } else if(v==5) {
0628 if(!read_v5(a_buffer,a_data)) return false;
0629 } else if(v==6) {
0630 if(!read_v6(a_buffer,a_data)) return false;
0631 } else if(v==7) {
0632 if(!read_v7(a_buffer,a_data)) return false;
0633 } else if(v==8) {
0634 if(!read_annotations(a_buffer,a_annotations)) return false;
0635 if(!read_v7(a_buffer,a_data)) return false;
0636 } else {
0637 return false;
0638 }
0639
0640 a_data.update_fast_getters();
0641
0642 return true;
0643 }
0644
0645 inline const std::string& THistogram_cls(){
0646 static const std::string s_v("THistogram");
0647 return s_v;
0648 }
0649
0650 }}
0651
0652 #include "key"
0653
0654 namespace tools {
0655 namespace rroot {
0656
0657 inline bool read_key_THistogram(ifile& a_file,key& a_key,pd_data_t& a_data,annotations_t& a_annotations,bool a_warn = true) {
0658 std::ostream& out = a_key.out();
0659 if(a_key.object_class()!=THistogram_cls()) {
0660 if(a_warn) out << "tools::rroot::read_key_THisogram : key not a THistogram." << std::endl;
0661 return 0;
0662 }
0663 unsigned int sz;
0664 char* buf = a_key.get_object_buffer(a_file,sz); //we don't have ownership of buf.
0665 if(!buf) {
0666 out << "tools::rroot::read_key_THisogram : can't get data buffer of " << a_key.object_name() << "." << std::endl;
0667 return 0;
0668 }
0669 buffer b(out,a_file.byte_swap(),sz,buf,a_key.key_length(),false);
0670 return read_THistogram(b,a_data,a_annotations);
0671 }
0672
0673 }}
0674
0675 #include "../histo/h1d"
0676 #include "../histo/h2d"
0677 #include "../histo/p1d"
0678 #include "../histo/p2d"
0679
0680 namespace tools {
0681 namespace rroot {
0682
0683 inline histo::h1d* THistogram_to_h1d(const pd_data_t& a_data) {
0684 unsigned int dim = a_data.m_dimension;
0685 bool is_profile = a_data.m_is_profile;
0686 if(dim!=1) return 0;
0687 if(is_profile) return 0;
0688 histo::h1d* histo = new histo::h1d("",10,0,1);
0689 histo->copy_from_data(a_data);
0690 return histo;
0691 }
0692
0693 inline histo::h2d* THistogram_to_h2d(const pd_data_t& a_data) {
0694 unsigned int dim = a_data.m_dimension;
0695 bool is_profile = a_data.m_is_profile;
0696 if(dim!=2) return 0;
0697 if(is_profile) return 0;
0698 histo::h2d* histo = new histo::h2d("",10,0,1,10,0,1);
0699 histo->copy_from_data(a_data);
0700 return histo;
0701 }
0702
0703 inline histo::p1d* THistogram_to_p1d(const pd_data_t& a_data) {
0704 unsigned int dim = a_data.m_dimension;
0705 bool is_profile = a_data.m_is_profile;
0706 if(dim!=1) return 0;
0707 if(!is_profile) return 0;
0708 histo::p1d* histo = new histo::p1d("",10,0,1);
0709 histo->copy_from_data(a_data);
0710 return histo;
0711 }
0712
0713 inline histo::p2d* THistogram_to_p2d(const pd_data_t& a_data) {
0714 unsigned int dim = a_data.m_dimension;
0715 bool is_profile = a_data.m_is_profile;
0716 if(dim!=2) return 0;
0717 if(!is_profile) return 0;
0718 histo::p2d* histo = new histo::p2d("",10,0,1,10,0,1);
0719 histo->copy_from_data(a_data);
0720 return histo;
0721 }
0722
0723 }}
0724
0725 #endif
