Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 2 // See the file tools.license for terms. 3 4 #ifndef tools_xml_aidas 5 #define tools_xml_aidas 6 7 #include "../raxml_out" 8 9 #include "../sprintf" 10 #include "../histo/h1d" 11 #include "../histo/h2d" 12 #include "../histo/h3d" 13 #include "../histo/p1d" 14 #include "../histo/p2d" 15 #include "../histo/c1d" 16 #include "../histo/c2d" 17 #include "../histo/c3d" 18 #include "../histo/dps" 19 #include "../aida_ntuple" 20 #include "../S_STRING" 21 #include "../forit" 22 23 #include "tree" 24 25 #include <vector> 26 #include <map> 27 #include <utility> 28 29 namespace tools { 30 namespace xml { 31 32 class aidas { 33 public: 34 //tree,out,verbose,path. 35 typedef raxml_out (*reader)(tree&,std::ostre 36 typedef std::map<std::string,reader> readers 37 public: 38 aidas() 39 { 40 add_default_readers(); 41 } 42 virtual ~aidas(){ 43 m_objects.clear(); //it may delete histos, 44 } 45 protected: 46 aidas(const aidas&){} 47 aidas& operator=(const aidas&){return *this; 48 public: 49 std::vector<raxml_out>& objects() {return m_ 50 protected: 51 void clear_readers() {m_readers.clear();} 52 void add_reader(const std::string& a_class, 53 reader a_reader, 54 bool a_check = false) 55 if(a_check) {if(find_reader(a_class)) retu 56 m_readers[a_class] = a_reader; 57 } 58 59 reader find_reader(const std::string& a_clas 60 std::map<std::string,reader>::const_iterat 61 if(it!=m_readers.end()) return (*it).secon 62 return 0; 63 } 64 65 protected: 66 TOOLS_CLASS_STRING(aida) 67 68 TOOLS_CLASS_STRING(annotation) 69 TOOLS_CLASS_STRING(histogram1d) 70 TOOLS_CLASS_STRING(histogram2d) 71 TOOLS_CLASS_STRING(histogram3d) 72 TOOLS_CLASS_STRING(profile1d) 73 TOOLS_CLASS_STRING(profile2d) 74 TOOLS_CLASS_STRING(axis) 75 TOOLS_CLASS_STRING(statistics) 76 TOOLS_CLASS_STRING(statistic) 77 TOOLS_CLASS_STRING(data1d) 78 TOOLS_CLASS_STRING(data2d) 79 TOOLS_CLASS_STRING(data3d) 80 TOOLS_CLASS_STRING(tuple) 81 TOOLS_CLASS_STRING(columns) 82 TOOLS_CLASS_STRING(rows) 83 TOOLS_CLASS_STRING(row) 84 TOOLS_CLASS_STRING(entryITuple) 85 TOOLS_CLASS_STRING(entryTuple) 86 TOOLS_CLASS_STRING(cloud1d) 87 TOOLS_CLASS_STRING(cloud2d) 88 TOOLS_CLASS_STRING(cloud3d) 89 TOOLS_CLASS_STRING(entries1d) 90 TOOLS_CLASS_STRING(entries2d) 91 TOOLS_CLASS_STRING(entries3d) 92 TOOLS_CLASS_STRING(dataPointSet) 93 TOOLS_CLASS_STRING(dataPoint) 94 //TOOLS_CLASS_STRING(function) 95 //TOOLS_CLASS_STRING(arguments) 96 //TOOLS_CLASS_STRING(argument) 97 //TOOLS_CLASS_STRING(parameters) 98 99 TOOLS_CLASS_STRING(type) 100 TOOLS_CLASS_STRING(name) 101 TOOLS_CLASS_STRING(path) 102 TOOLS_CLASS_STRING(title) 103 TOOLS_CLASS_STRING(numberOfBins) 104 TOOLS_CLASS_STRING(min) 105 TOOLS_CLASS_STRING(max) 106 TOOLS_CLASS_STRING(direction) 107 TOOLS_CLASS_STRING(value) 108 TOOLS_CLASS_STRING(entries) 109 TOOLS_CLASS_STRING(mean) 110 TOOLS_CLASS_STRING(rms) 111 TOOLS_CLASS_STRING(height) 112 TOOLS_CLASS_STRING(error) 113 TOOLS_CLASS_STRING(weightedMean) 114 TOOLS_CLASS_STRING(weightedRms) 115 TOOLS_CLASS_STRING(weightedMeanX) 116 TOOLS_CLASS_STRING(weightedMeanY) 117 TOOLS_CLASS_STRING(weightedMeanZ) 118 TOOLS_CLASS_STRING(weightedRmsX) 119 TOOLS_CLASS_STRING(weightedRmsY) 120 TOOLS_CLASS_STRING(weightedRmsZ) 121 TOOLS_CLASS_STRING(booking) 122 TOOLS_CLASS_STRING(default) 123 TOOLS_CLASS_STRING(entry) 124 TOOLS_CLASS_STRING(binBorder) 125 TOOLS_CLASS_STRING(maxEntries) 126 TOOLS_CLASS_STRING(valueX) 127 TOOLS_CLASS_STRING(valueY) 128 TOOLS_CLASS_STRING(valueZ) 129 TOOLS_CLASS_STRING(weight) 130 TOOLS_CLASS_STRING(entry1d) 131 TOOLS_CLASS_STRING(entry2d) 132 TOOLS_CLASS_STRING(entry3d) 133 TOOLS_CLASS_STRING(dimension) 134 TOOLS_CLASS_STRING(errorPlus) 135 TOOLS_CLASS_STRING(errorMinus) 136 TOOLS_CLASS_STRING(measurement) 137 138 void set_default_tags(std::vector<std::strin 139 a_tags.clear(); 140 a_tags.push_back(s_aida()); 141 a_tags.push_back(s_annotation()); 142 a_tags.push_back(s_histogram1d()); 143 a_tags.push_back(s_histogram2d()); 144 a_tags.push_back(s_histogram3d()); 145 a_tags.push_back(s_profile1d()); 146 a_tags.push_back(s_profile2d()); 147 a_tags.push_back(s_axis()); 148 a_tags.push_back(s_statistics()); 149 a_tags.push_back(s_data1d()); 150 a_tags.push_back(s_data2d()); 151 a_tags.push_back(s_data3d()); 152 153 a_tags.push_back(s_tuple()); 154 a_tags.push_back(s_columns()); 155 a_tags.push_back(s_rows()); 156 a_tags.push_back(s_row()); 157 a_tags.push_back(s_entryITuple()); //aida. 158 a_tags.push_back(s_entryTuple()); //not i 159 160 a_tags.push_back(s_cloud1d()); 161 a_tags.push_back(s_cloud2d()); 162 a_tags.push_back(s_cloud3d()); 163 a_tags.push_back(s_entries1d()); 164 a_tags.push_back(s_entries2d()); 165 a_tags.push_back(s_entries3d()); 166 a_tags.push_back(s_dataPointSet()); 167 a_tags.push_back(s_dataPoint()); 168 //a_tags.push_back(s_function()); 169 //a_tags.push_back(s_arguments()); 170 //a_tags.push_back(s_argument()); 171 //a_tags.push_back(s_parameters()); 172 } 173 174 void add_default_readers(){ 175 add_reader(s_histogram1d(),read_h1d); 176 add_reader(s_histogram2d(),read_h2d); 177 add_reader(s_histogram3d(),read_h3d); 178 add_reader(s_profile1d(),read_p1d); 179 add_reader(s_profile2d(),read_p2d); 180 add_reader(s_cloud1d(),read_cloud1d); 181 add_reader(s_cloud2d(),read_cloud2d); 182 add_reader(s_cloud3d(),read_cloud3d); 183 add_reader(s_tuple(),read_ntu); 184 add_reader(s_dataPointSet(),read_dps); 185 //add_reader(s_function(),read_Function); 186 } 187 static raxml_out read_h1d(tree& a_tree,std:: 188 return read_histo(a_tree,a_out,a_verbose,1 189 } 190 static raxml_out read_h2d(tree& a_tree,std:: 191 return read_histo(a_tree,a_out,a_verbose,2 192 } 193 static raxml_out read_h3d(tree& a_tree,std:: 194 return read_histo(a_tree,a_out,a_verbose,3 195 } 196 static raxml_out read_p1d(tree& a_tree,std:: 197 return read_histo(a_tree,a_out,a_verbose,1 198 } 199 static raxml_out read_p2d(tree& a_tree,std:: 200 return read_histo(a_tree,a_out,a_verbose,2 201 } 202 203 static raxml_out read_cloud1d(tree& a_tree,s 204 return read_cloud(a_tree,a_out,a_verbose,1 205 } 206 static raxml_out read_cloud2d(tree& a_tree,s 207 return read_cloud(a_tree,a_out,a_verbose,2 208 } 209 static raxml_out read_cloud3d(tree& a_tree,s 210 return read_cloud(a_tree,a_out,a_verbose,3 211 } 212 213 static raxml_out read_dps(tree& a_tree,std:: 214 std::string sname; 215 a_tree.attribute_value(s_name(),sname); 216 217 if(a_verbose) { 218 a_out << "tools::xml::aidas::read_dps :" 219 << " with name " << sout(sname) 220 << "..." << std::endl; 221 } 222 223 std::string spath; 224 a_tree.attribute_value(s_path(),spath); 225 226 std::string stitle; 227 a_tree.attribute_value(s_title(),stitle); 228 229 // Booking parameters : 230 unsigned int dim = 0; 231 if(!a_tree.attribute_value(s_dimension(),d 232 233 // Create a BatchLab::DataPointSet : 234 histo::dps* dps = new histo::dps(stitle,di 235 236 // Data sub items : 237 {looper _for(a_tree); 238 while(tree* _tree = _for.next_tree()) { 239 if(!read_dps_data(*_tree,*dps)) { 240 delete dps; 241 return raxml_out(); 242 } 243 }} 244 245 base_handle* hdl = new handle<histo::dps>( 246 std::string sclass = histo::dps::s_class() 247 248 if(a_verbose) { 249 a_out << "tools::xml::aidas::read_dps :" 250 << " with name " << sout(sname) 251 << " and title " << sout(stitle) 252 << " done." << std::endl; 253 } 254 255 return raxml_out(hdl,sclass,spath,sname); 256 } 257 258 protected: 259 typedef histo::axis<double,unsigned int>::bn 260 public: //used in BatchLab::XML_DataReader. 261 static raxml_out read_histo(tree& a_tree, 262 std::ostream& a 263 unsigned int a_ 264 265 std::string sname; 266 a_tree.attribute_value(s_name(),sname); 267 268 if(a_verbose) { 269 a_out << "tools::xml::aidas::read_histo 270 << " with name " << sout(sname) 271 << "..." << std::endl; 272 } 273 274 std::string spath; 275 a_tree.attribute_value(s_path(),spath); 276 277 std::string stitle; 278 a_tree.attribute_value(s_title(),stitle); 279 280 // Booking parameters : 281 std::vector<bn_t> bins(a_dim); 282 std::vector<double> mns(a_dim); 283 std::vector<double> mxs(a_dim); 284 std::vector< std::vector<double> > edges(a 285 286 // Jump in subitems to find axes items : 287 int not_found = -1; 288 unsigned int found = 0; 289 bool isVariableBins = false; 290 291 {looper _for(a_tree); 292 while(tree* _tree = _for.next_tree()) { 293 294 int iaxis; 295 bn_t num; 296 double mn,mx; 297 std::vector<double> borders; 298 bool variableBins; 299 if(!read_axis(*_tree,a_dim,iaxis,num,mn, 300 if(iaxis!=not_found) { 301 if((iaxis<0)||(iaxis>=(int)a_dim)) ret 302 bins[iaxis] = num; 303 mns[iaxis] = mn; 304 mxs[iaxis] = mx; 305 edges[iaxis] = std::move(borders); 306 if(variableBins) isVariableBins = true 307 found++; 308 } 309 }} 310 311 if(found!=a_dim) return raxml_out(); 312 if(isVariableBins) { 313 // Axes consistency : 314 for(unsigned int iaxis=0;iaxis<a_dim;iax 315 if(edges[iaxis].size()<=2) return raxm 316 } 317 } 318 319 // Create a native histogram : 320 321 base_handle* hdl = 0; 322 std::string sclass; 323 if(a_is_prof) { 324 if(a_dim==1) { 325 histo::p1d* histo = 0; 326 if(isVariableBins) { 327 histo = new histo::p1d(stitle,edges[ 328 } else { 329 histo = new histo::p1d(stitle,bins[0 330 } 331 332 // Sub items : 333 pd_data hd = histo->get_histo_data(); 334 if(hd.m_bin_number<=0) {delete histo;r 335 336 {looper _for(a_tree); 337 while(tree* _tree = _for.next_tree()) 338 339 if(!read_bins(*_tree,hd,a_out,a_is_p 340 delete histo; 341 return raxml_out(); 342 } 343 344 }} 345 346 //give histo ownership to the handle. 347 hdl = new handle<histo::p1d>(histo); 348 sclass = histo::p1d::s_class(); 349 350 hd.update_fast_getters(); 351 histo->copy_from_data(hd); 352 353 } else if(a_dim==2) { 354 histo::p2d* histo = 0; 355 if(isVariableBins) { 356 histo = new histo::p2d(stitle,edges[ 357 } else { 358 histo = new histo::p2d(stitle,bins[0 359 } 360 361 pd_data hd = histo->get_histo_data(); 362 if(hd.m_bin_number<=0) {delete histo;r 363 364 {looper _for(a_tree); 365 while(tree* _tree = _for.next_tree()) 366 367 if(!read_bins(*_tree,hd,a_out,a_is_p 368 delete histo; 369 return raxml_out(); 370 } 371 372 }} 373 374 hdl = new handle<histo::p2d>(histo); 375 sclass = histo::p2d::s_class(); 376 377 hd.update_fast_getters(); 378 histo->copy_from_data(hd); 379 } 380 } else { 381 if(a_dim==1) { 382 histo::h1d* histo = 0; 383 if(isVariableBins) { 384 histo = new histo::h1d(stitle,edges[ 385 } else { 386 histo = new histo::h1d(stitle,bins[0 387 } 388 389 pd_data hd(histo->dac()); 390 if(hd.m_bin_number<=0) {delete histo;r 391 392 {looper _for(a_tree); 393 while(tree* _tree = _for.next_tree()) 394 395 if(!read_bins(*_tree,hd,a_out,a_is_p 396 delete histo; 397 return raxml_out(); 398 } 399 400 }} 401 402 hdl = new handle<histo::h1d>(histo); 403 sclass = histo::h1d::s_class(); 404 405 hd.update_fast_getters(); 406 histo->copy_from_data(hd); 407 408 } else if(a_dim==2) { 409 histo::h2d* histo = 0; 410 if(isVariableBins) { 411 histo = new histo::h2d(stitle,edges[ 412 } else { 413 histo = new histo::h2d(stitle,bins[0 414 } 415 416 pd_data hd(histo->dac()); 417 if(hd.m_bin_number<=0) {delete histo;r 418 419 {looper _for(a_tree); 420 while(tree* _tree = _for.next_tree()) 421 422 if(!read_bins(*_tree,hd,a_out,a_is_p 423 delete histo; 424 return raxml_out(); 425 } 426 427 }} 428 429 hdl = new handle<histo::h2d>(histo); 430 sclass = histo::h2d::s_class(); 431 432 hd.update_fast_getters(); 433 histo->copy_from_data(hd); 434 435 } else if(a_dim==3) { 436 histo::h3d* histo = 0; 437 if(isVariableBins) { 438 histo = new histo::h3d(stitle,edges[ 439 } else { 440 histo = new histo::h3d(stitle,bins[0 441 442 443 } 444 445 pd_data hd(histo->dac()); 446 if(hd.m_bin_number<=0) {delete histo;r 447 448 {looper _for(a_tree); 449 while(tree* _tree = _for.next_tree()) 450 451 if(!read_bins(*_tree,hd,a_out,a_is_p 452 delete histo; 453 return raxml_out(); 454 } 455 456 }} 457 458 hdl = new handle<histo::h3d>(histo); 459 sclass = histo::h3d::s_class(); 460 461 hd.update_fast_getters(); 462 histo->copy_from_data(hd); 463 464 } 465 } 466 467 if(!hdl) return raxml_out(); 468 469 if(a_verbose) { 470 a_out << "tools::xml::aidas::read_histo 471 << " with name " << sout(sname) 472 << " and title " << sout(stitle) 473 << " done." << std::endl; 474 } 475 476 return raxml_out(hdl,sclass,spath,sname); 477 } 478 479 static raxml_out read_cloud(tree& a_tree,std 480 481 std::string sname; 482 a_tree.attribute_value(s_name(),sname); 483 484 if(a_verbose) { 485 a_out << "tools::xml::aidas::read_cloud 486 << " name " << sout(sname) 487 << "..." << std::endl; 488 } 489 490 std::string spath; 491 a_tree.attribute_value(s_path(),spath); 492 493 std::string stitle; 494 a_tree.attribute_value(s_title(),stitle); 495 496 std::string svalue; 497 498 // Booking parameters : 499 int max_entries = -1; //UNLIMITED 500 if(a_tree.attribute_value(s_maxEntries(),s 501 int ival; 502 if(!to<int>(svalue,ival)) return raxml_o 503 max_entries = ival; 504 } 505 506 base_handle* hdl = 0; 507 std::string sclass; 508 509 if(a_dim==1) { 510 511 histo::c1d* cloud = new histo::c1d(stitl 512 513 // Data sub items : 514 {looper _for(a_tree); 515 while(tree* _tree = _for.next_tree()) { 516 if(!read_cloud_data(*_tree,*cloud,a_ve 517 delete cloud; 518 return raxml_out(); 519 } 520 }} 521 522 hdl = new handle<histo::c1d>(cloud); 523 sclass = histo::c1d::s_class(); 524 525 } else if(a_dim==2) { 526 527 histo::c2d* cloud = new histo::c2d(stitl 528 529 // Data sub items : 530 {looper _for(a_tree); 531 while(tree* _tree = _for.next_tree()) { 532 if(!read_cloud_data(*_tree,*cloud,a_ve 533 delete cloud; 534 return raxml_out(); 535 } 536 }} 537 538 hdl = new handle<histo::c2d>(cloud); 539 sclass = histo::c2d::s_class(); 540 541 } else if(a_dim==3) { 542 543 histo::c3d* cloud = new histo::c3d(stitl 544 545 // Data sub items : 546 {looper _for(a_tree); 547 while(tree* _tree = _for.next_tree()) { 548 if(!read_cloud_data(*_tree,*cloud,a_ve 549 delete cloud; 550 return raxml_out(); 551 } 552 }} 553 554 hdl = new handle<histo::c3d>(cloud); 555 sclass = histo::c3d::s_class(); 556 } 557 558 if(!hdl) return raxml_out(); 559 560 if(a_verbose) { 561 a_out << "tools::xml::aidas::read_cloud 562 << " with name " << sout(sname) 563 << " and title " << sout(stitle) 564 << " done." << std::endl; 565 } 566 567 return raxml_out(hdl,sclass,spath,sname); 568 } 569 570 protected: 571 typedef histo::profile_data<double,unsigned 572 //////////////////////////////////////////// 573 /// read histo ///////////////////////////// 574 //////////////////////////////////////////// 575 static bool read_axis( 576 tree& a_tree 577 ,unsigned int a_dim 578 ,int& aAxis 579 ,bn_t& aNumberOfBins 580 ,double& aMin 581 ,double& aMax 582 ,std::vector<double>& aEdges 583 ,bool& aVariableBins 584 ,std::ostream& //a_out 585 ){ 586 int not_found = -1; 587 aAxis = not_found; 588 aNumberOfBins = 0; 589 aMin = 0; 590 aMax = 0; 591 aEdges.clear(); 592 aVariableBins = false; 593 594 const std::string& tagName = a_tree.tag_na 595 596 std::string svalue; 597 598 if(tagName==s_axis()) { 599 600 {bn_t ival; 601 if(!a_tree.attribute_value(s_numberOfBin 602 if(!to<bn_t>(svalue,ival)) return false; 603 aNumberOfBins = ival;} 604 605 if(!a_tree.attribute_value(s_min(),svalu 606 if(!to<double>(svalue,aMin)) return fals 607 608 if(!a_tree.attribute_value(s_max(),svalu 609 if(!to<double>(svalue,aMax)) return fals 610 611 if(!a_tree.attribute_value(s_direction() 612 if(!axis_index(a_dim,svalue,aAxis)) retu 613 614 aEdges.push_back(aMin); 615 616 {looper _for(a_tree); 617 while(element* _elem = _for.next_element 618 if(_elem->name()==s_binBorder()) { 619 if(!_elem->attribute_value(s_value() 620 double value; 621 if(!to<double>(svalue,value)) return 622 aEdges.push_back(value); 623 aVariableBins = true; 624 } 625 }} 626 627 aEdges.push_back(aMax); 628 if(aVariableBins) { // Variable bins his 629 if(aEdges.size()!=aNumberOfBins+1) ret 630 } 631 632 } 633 634 return true; 635 } 636 static bool to_double(const std::string& a_s 637 if(!to<double>(a_s,a_v)) { 638 a_out << "tools::xml::aidas::read_bins : 639 << " problem converting a " << a_w 640 << " attribute to a double." 641 << " Value was " << sout(a_s) << " 642 << std::endl; 643 return false; 644 } 645 return true; 646 } 647 648 static bool read_bins(tree& a_tree,pd_data& 649 const std::string& tagName = a_tree.tag_na 650 651 std::string svalue; 652 653 if(tagName==s_annotation()) { //FIXME 654 655 return true; 656 657 } else if(tagName=="statistics") { 658 659 if(!a_tree.attribute_value(s_entries(),s 660 //unsigned int ival; 661 //if(!to<unsigned int>(svalue,ival)) ret 662 // aData.fEntries = ival; 663 664 unsigned int found = 0; 665 666 {looper _for(a_tree); 667 while(element* _elem = _for.next_element 668 669 if(_elem->name()==s_statistic()) { 670 double mean,rms; 671 if(!_elem->attribute_value(s_mean(), 672 if(!to<double>(svalue,mean)) return 673 674 if(!_elem->attribute_value(s_rms(),s 675 if(!to<double>(svalue,rms)) return f 676 677 if(!_elem->attribute_value(s_directi 678 int iaxis; 679 if(!axis_index(aData.m_dimension,sva 680 681 //aData.m_axes[iaxis].fSxw = mean; / 682 //aData.m_axes[iaxis].fSx2w = rms; / 683 684 found++; 685 } 686 }} 687 688 if(found!=aData.m_dimension) return fals 689 690 return true; 691 692 } else if(tagName==s_axis()) { 693 694 return true; 695 696 } 697 698 unsigned int dimension = 0; 699 if(tagName==s_data1d()) { 700 dimension = 1; 701 } else if(tagName==s_data2d()) { 702 dimension = 2; 703 } else if(tagName==s_data3d()) { 704 dimension = 3; 705 } 706 707 if(dimension) { 708 709 if(dimension!=aData.m_dimension) return 710 711 std::string sbin; 712 sprintf(sbin,32,"bin%dd",dimension); 713 714 {looper _for(a_tree); 715 while(element* _elem = _for.next_element 716 717 if(_elem->name()==sbin) { 718 719 std::vector<int> is(dimension); 720 721 unsigned int entries = 0; 722 double height = 0; 723 double error = 0; 724 double weightedMean = 0; 725 double weightedMeanX = 0; 726 double weightedMeanY = 0; 727 double weightedMeanZ = 0; 728 double weightedRms = 0; 729 double weightedRmsX = 0; 730 double weightedRmsY = 0; 731 double weightedRmsZ = 0; 732 double rms = 0; 733 734 // Required : 735 if(!_elem->attribute_value(s_entries 736 a_out << "tools::xml::aidas::read_ 737 << " a <bin1d> has no " << " 738 << " attribute." 739 << std::endl; 740 return false; 741 } 742 if(!to<unsigned int>(svalue,entries) 743 a_out << "tools::xml::aidas::read_ 744 << " problem converting a entrie 745 << " Value was " << sout(svalu 746 << std::endl; 747 return false; 748 } 749 750 // Optional : 751 bool height_given; 752 if(_elem->attribute_value(s_height() 753 if(!to_double(svalue,height,a_out, 754 height_given = true; 755 } else { // no "height". 756 // It is assumed that at fill time 757 // argument "w" had always been 1. 758 // w = 1 759 // sw = entries*1 = entries 760 height = double(entries); 761 height_given = false; 762 } 763 764 if(_elem->attribute_value(s_error(), 765 if(!to_double(svalue,error,a_out,s 766 } else { // no "error" 767 if(height_given) { 768 // then we are going to have : 769 // sw = height 770 // error = ? 771 // We can assume that at fill ti 772 // had been given to all entries 773 // sw = entries*w = height 774 // w = height/entries; 775 // sw2 = entries*(w*w) = (heig 776 // error = sqrt(sw2) = sqrt((h 777 if(entries) { 778 error = ::sqrt(::fabs( ((heigh 779 } 780 } else { 781 // It is assumed that at fill ti 782 // argument "w" had always been 783 // w = 1 784 // sw2 = entries*(w*w) = entri 785 // error = sqrt(sw2) = sqrt(en 786 error = ::sqrt(::fabs(double(ent 787 } 788 } 789 790 if(_elem->attribute_value(s_rms(),sv 791 if(!to_double(svalue,rms,a_out,s_r 792 } 793 794 if(dimension==1) { 795 if(_elem->attribute_value(s_weight 796 if(!to_double(svalue,weightedMea 797 } 798 if(_elem->attribute_value(s_weight 799 if(!to_double(svalue,weightedRms 800 } 801 } else if(dimension==2) { 802 if(_elem->attribute_value(s_weight 803 if(!to_double(svalue,weightedMea 804 } 805 if(_elem->attribute_value(s_weight 806 if(!to_double(svalue,weightedMea 807 } 808 if(_elem->attribute_value(s_weight 809 if(!to_double(svalue,weightedRms 810 } 811 if(_elem->attribute_value(s_weight 812 if(!to_double(svalue,weightedRms 813 } 814 } else if(dimension==3) { 815 if(_elem->attribute_value(s_weight 816 if(!to_double(svalue,weightedMea 817 } 818 if(_elem->attribute_value(s_weight 819 if(!to_double(svalue,weightedMea 820 } 821 if(_elem->attribute_value(s_weight 822 if(!to_double(svalue,weightedMea 823 } 824 if(_elem->attribute_value(s_weight 825 if(!to_double(svalue,weightedRms 826 } 827 if(_elem->attribute_value(s_weight 828 if(!to_double(svalue,weightedRms 829 } 830 if(_elem->attribute_value(s_weight 831 if(!to_double(svalue,weightedRms 832 } 833 } 834 835 {for(unsigned int index=0;index<dimen 836 std::string _s = "binNum"; 837 if(dimension!=1) { 838 if(index==0) _s += "X"; 839 else if(index==1) _s += "Y"; 840 else if(index==2) _s += "Z"; 841 } 842 if(!_elem->attribute_value(_s,sval 843 a_out << "tools::xml::aidas::rea 844 << " a <bin1d> has no " << _ 845 return false; 846 } 847 if(svalue=="UNDERFLOW") { 848 is[index] = histo::axis_UNDERFLO 849 } else if(svalue=="OVERFLOW") { 850 is[index] = histo::axis_OVERFLOW 851 } else { 852 int ival = 0; 853 if(!to<int>(svalue,ival)) { 854 a_out << "tools::xml::aidas::r 855 << " problem converting bi 856 << " Value was " << sout(s 857 << std::endl; 858 return false; 859 } 860 int ibin = ival; 861 if( (ibin<0) || (ibin>=(int)aDat 862 a_out << "tools::xml::aidas::r 863 << " a binNum is out of ra 864 << std::endl; 865 return false; 866 } 867 is[index] = ibin; 868 } 869 }} 870 871 // If we are here, then we have a va 872 bn_t offset; 873 histo::get_offset(aData.m_axes,is,of 874 aData.m_bin_entries[offset] = entrie 875 876 if(!a_is_prof) { 877 878 // From histo::base_histo, we have 879 // height = sw 880 // error = sqrt(sw) 881 // weightedMean = sxw/sw 882 // weightedRms = sqrt(fabs(sx2w/s 883 884 double sw = height; 885 aData.m_bin_Sw[offset] = sw; 886 aData.m_bin_Sw2[offset] = error * 887 if(dimension==1) { 888 aData.m_bin_Sxw[offset][0] = wei 889 aData.m_bin_Sx2w[offset][0] = 890 (weightedRms * weightedRms + w 891 } else if(dimension==2){ 892 // X 893 aData.m_bin_Sxw[offset][0] = wei 894 aData.m_bin_Sx2w[offset][0] = 895 (weightedRmsX*weightedRmsX + w 896 // Y : 897 aData.m_bin_Sxw[offset][1] = wei 898 aData.m_bin_Sx2w[offset][1] = 899 (weightedRmsY*weightedRmsY + w 900 } else if(dimension==3){ 901 // X 902 aData.m_bin_Sxw[offset][0] = wei 903 aData.m_bin_Sx2w[offset][0] = 904 (weightedRmsX*weightedRmsX + w 905 // Y : 906 aData.m_bin_Sxw[offset][1] = wei 907 aData.m_bin_Sx2w[offset][1] = 908 (weightedRmsY*weightedRmsY + w 909 // Z : 910 aData.m_bin_Sxw[offset][2] = wei 911 aData.m_bin_Sx2w[offset][2] = 912 (weightedRmsZ*weightedRmsZ + w 913 } 914 915 } else { // Profile : 916 917 // bin writing is : 918 // " height=" << sout(aObj.bin_hei 919 // " error=" << sout(aObj.bin_erro 920 // " weightedMean=" << sout(aObj.b 921 // " rms=" << sout(aObj.bin_rms_va 922 // " weightedRms=" << sout(bin_rms 923 924 // From inlib profile, we have : 925 // height = svw / sw 926 // error = sqrt(fabs(sv2w/sw - (s 927 // rms = sqrt(fabs(sv2w/sw - (svw 928 // weightedMean = sxw/sw 929 // weightedRms = sqrt(fabs(sx2w/s 930 931 // Then : 932 // sw = (rms/error)**2 933 // svw = sw * height 934 // sv2w = sw * (rms**2 + height** 935 // sxw = weightedMean * sw 936 // sx2w = (weightedRms*weightedRm 937 938 double sw = 0; 939 if(error==0) { 940 // sv2w/sw = (svw/sw)**2 941 // h = svw/sw 942 //FIXME : we lack an info to get 943 // We assume that at fill time w 944 // sw == n 945 sw = (double)entries; 946 } else { 947 double r_e = rms/error; 948 sw = r_e * r_e; 949 } 950 aData.m_bin_Sw[offset] = sw; 951 aData.m_bin_Sw2[offset] = 0; //FIX 952 if(dimension==1) { 953 aData.m_bin_Sxw[offset][0] = wei 954 aData.m_bin_Sx2w[offset][0] = 955 (weightedRms * weightedRms + w 956 } else if(dimension==2){ 957 aData.m_bin_Sxw[offset][0] = wei 958 aData.m_bin_Sxw[offset][1] = wei 959 aData.m_bin_Sx2w[offset][0] = 960 (weightedRmsX*weightedRmsX + w 961 aData.m_bin_Sx2w[offset][1] = 962 (weightedRmsY*weightedRmsY + w 963 } 964 aData.m_bin_Svw[offset] = sw * hei 965 aData.m_bin_Sv2w[offset] = sw * (r 966 967 } 968 } 969 }} 970 971 return true; 972 } 973 974 return false; 975 } 976 977 static bool axis_index(unsigned int a_dim,co 978 if(a_dim==1) { 979 if(a_axis=="x") {a_index = 0;return true 980 } else if(a_dim==2) { 981 if(a_axis=="x") {a_index = 0;return true 982 else if(a_axis=="y") {a_index = 1;return 983 } else if(a_dim==3) { 984 if(a_axis=="x") {a_index = 0;return true 985 else if(a_axis=="y") {a_index = 1;return 986 else if(a_axis=="z") {a_index = 2;return 987 } 988 return false; 989 } 990 991 //////////////////////////////////////////// 992 /// read ntuple //////////////////////////// 993 //////////////////////////////////////////// 994 class colbook { 995 public: 996 colbook(const std::string& a_type, 997 const std::string& a_name, 998 const std::string& a_s, 999 bool a_ntu) 1000 :m_type(a_type),m_name(a_name),m_def_or_b 1001 public: 1002 colbook(const colbook& a_from) 1003 :m_type(a_from.m_type) 1004 ,m_name(a_from.m_name) 1005 ,m_def_or_bkg(a_from.m_def_or_bkg) 1006 ,m_ntu(a_from.m_ntu) 1007 {} 1008 1009 colbook& operator=(const colbook& a_from) 1010 if(&a_from==this) return *this; 1011 m_type = a_from.m_type; 1012 m_name = a_from.m_name; 1013 m_def_or_bkg = a_from.m_def_or_bkg; 1014 m_ntu = a_from.m_ntu; 1015 return *this; 1016 } 1017 public: 1018 const std::string& type() const {return m 1019 const std::string& name() const {return m 1020 const std::string& def_or_bkg() const {re 1021 bool is_ntu() const {return m_ntu;} 1022 protected: 1023 std::string m_type; 1024 std::string m_name; 1025 std::string m_def_or_bkg; 1026 bool m_ntu; 1027 }; 1028 1029 static bool read_ntu_columns(tree& a_tree, 1030 bool& a_foun 1031 std::vector< 1032 std::ostream 1033 a_found = false; 1034 a_booking.clear(); 1035 1036 const std::string& tag_name = a_tree.tag_ 1037 1038 if(tag_name=="columns") { 1039 1040 {looper _for(a_tree); 1041 while(element* _elem = _for.next_elemen 1042 1043 if(_elem->name()=="column") { 1044 std::string stype; 1045 if(!_elem->attribute_value(s_type() 1046 a_out << "tools::xml::aidas::read 1047 << " atb type missing on <c 1048 << std::endl; 1049 return false; 1050 } 1051 std::string sname; 1052 if(!_elem->attribute_value(s_name() 1053 a_out << "tools::xml::aidas::read 1054 << " atb name missing on <c 1055 << std::endl; 1056 return false; 1057 } 1058 1059 std::string _s; 1060 if(_elem->attribute_value(s_booking 1061 a_booking.push_back(colbook(stype 1062 } else if(_elem->attribute_value(s_ 1063 a_booking.push_back(colbook(stype 1064 } else { 1065 a_booking.push_back(colbook(stype 1066 } 1067 } 1068 1069 }} 1070 1071 a_found = true; 1072 } 1073 return true; 1074 } 1075 1076 static bool read_ntu_rows(tree& a_tree, 1077 aida::base 1078 bool& a_fo 1079 std::ostre 1080 a_found = false; 1081 1082 const std::string& tag_name = a_tree.tag_ 1083 1084 if(tag_name==s_annotation()) { //FIXME 1085 1086 return true; 1087 1088 } else if(tag_name==s_columns()) { 1089 1090 return true; 1091 1092 } else if(tag_name==s_rows()) { 1093 1094 // Sub items : 1095 {looper _for(a_tree); 1096 while(tree* _tree = _for.next_tree()) { 1097 1098 if(!read_ntu_rows(*_tree,a_ntu,a_foun 1099 a_out << "tools::xml::aidas::read_n 1100 << " sub read_ntu_rows failed 1101 << std::endl; 1102 return false; 1103 } 1104 1105 }} 1106 1107 a_found = true; 1108 1109 return true; 1110 1111 } else if(tag_name==s_row()) { 1112 1113 const std::vector<aida::base_col*>& col 1114 1115 std::vector<unsigned int> intus; 1116 std::vector<unsigned int> inot_ntus; 1117 {unsigned int index = 0; 1118 tools_vforcit(aida::base_col*,cols,it) 1119 if(safe_cast<aida::base_col,aida::aid 1120 intus.push_back(index); 1121 } else { 1122 inot_ntus.push_back(index); 1123 } 1124 index++; 1125 }} 1126 1127 std::string svalue; 1128 1129 {unsigned int icol = 0; 1130 1131 {looper _for(a_tree); 1132 while(element* _elem = _for.next_elemen 1133 1134 if(_elem->name()==s_entry()) { 1135 if(!_elem->attribute_value(s_value( 1136 a_out << "tools::xml::aidas::read 1137 << " can't get \"value\" at 1138 return false; 1139 } 1140 if(icol>=inot_ntus.size()) { 1141 a_out << "tools::xml::aidas::read 1142 << " too much <entry>." << 1143 return false; 1144 } 1145 if(inot_ntus[icol]>=cols.size()) { 1146 a_out << "tools::xml::aidas::read 1147 << " too much <entry>." << 1148 return false; 1149 } 1150 1151 aida::base_col* bcol = cols[inot_nt 1152 1153 aida::aida_base_col* abcol = 1154 safe_cast<aida::base_col,aida::aida 1155 1156 if(!abcol->s_fill(svalue)) { 1157 a_out << "tools::xml::aidas::read 1158 << " can't get \"value\" at 1159 return false; 1160 } 1161 icol++; 1162 } 1163 1164 }}} 1165 1166 // Sub items (entryITuple) : 1167 {unsigned int icol = 0; 1168 1169 {looper _for(a_tree); 1170 while(tree* _tree = _for.next_tree()) { 1171 1172 const std::string& _tag_name = _tree- 1173 if( (_tag_name==s_entryITuple()) || 1174 (_tag_name==s_entryTuple()) ){ 1175 if(icol>=intus.size()) { 1176 a_out << "tools::xml::aidas::read 1177 << " too much <entry>." << 1178 return false; 1179 } 1180 if(intus[icol]>=cols.size()) { 1181 a_out << "tools::xml::aidas::read 1182 << " too much <entry>." << 1183 return false; 1184 } 1185 1186 aida::base_col* bcol = cols[intus[i 1187 aida::aida_col_ntu* col_ntu = safe_ 1188 if(!col_ntu) { 1189 a_out << "tools::xml::aidas::read 1190 << " can't cast to bcol_ntu 1191 << std::endl; 1192 return false; 1193 } 1194 aida::base_ntu* ntu = col_ntu->get_ 1195 if(!ntu) { 1196 a_out << "tools::xml::aidas::read 1197 << " get_to_fill() returned 1198 << std::endl; 1199 return false; 1200 } 1201 1202 {looper _for2(*_tree); 1203 while(tree* _tree2 = _for2.next_tre 1204 bool found; 1205 if(!read_ntu_rows(*_tree2,*ntu,fo 1206 }} 1207 1208 icol++; 1209 } 1210 1211 }}} 1212 1213 if(!a_ntu.add_row()) { 1214 a_out << "tools::xml::aidas::read_ntu 1215 << " can't add row to ntuple." 1216 << std::endl; 1217 return false; 1218 } 1219 1220 return true; 1221 1222 } 1223 1224 a_out << "tools::xml::aidas::read_ntu_row 1225 << " unknown item class " << sout(t 1226 1227 return false; 1228 } 1229 1230 static raxml_out read_ntu(tree& a_tree,std: 1231 std::string sname; 1232 a_tree.attribute_value(s_name(),sname); 1233 1234 if(a_verbose) { 1235 a_out << "tools::xml::aidas::read_ntu : 1236 << " with name " << sout(sname) 1237 << "..." << std::endl; 1238 } 1239 1240 std::string spath; 1241 a_tree.attribute_value(s_path(),spath); 1242 1243 std::string stitle; 1244 a_tree.attribute_value(s_title(),stitle); 1245 1246 //FIXME annotation 1247 1248 // Booking parameters : 1249 std::vector<colbook> booking; 1250 1251 // Jump in subitems to find columns items 1252 bool found = false; 1253 1254 {looper _for(a_tree); 1255 while(tree* _tree = _for.next_tree()) { 1256 if(!read_ntu_columns(*_tree,found,booki 1257 if(found) break; 1258 }} 1259 1260 if(!found) { 1261 a_out << "tools::xml::aidas::read_ntu : 1262 << " for ntuple name " << sout(sn 1263 << " unable to read columns..." < 1264 return raxml_out(); 1265 } 1266 1267 // Create a aida::ntuple : 1268 aida::ntuple* ntu = new aida::ntuple(a_ou 1269 {tools_vforcit(colbook,booking,it) { 1270 if(!aida::create_col(*ntu, 1271 (*it).type(), 1272 (*it).name(), 1273 (*it).def_or_b 1274 (*it).is_ntu() 1275 delete ntu; 1276 return raxml_out(); 1277 } 1278 }} 1279 1280 if(!ntu->columns().size()) { //??? we cou 1281 a_out << "tools::xml::aidas::read_ntu : 1282 << " for ntuple name " << sout(sn 1283 << " unable to create a aida::ntu 1284 delete ntu; 1285 return raxml_out(); 1286 } 1287 1288 // Get rows in sub items : 1289 found = false; 1290 1291 {looper _for(a_tree); 1292 while(tree* _tree = _for.next_tree()) { 1293 1294 if(!read_ntu_rows(*_tree,*ntu,found,a_o 1295 a_out << "tools::xml::aidas::read_ntu 1296 << " for ntuple name " << sout( 1297 << " unable to read rows." << s 1298 delete ntu; 1299 return raxml_out(); 1300 } 1301 if(found) break; 1302 1303 }} 1304 1305 if(a_verbose) { 1306 a_out << "tools::xml::aidas::read_ntu : 1307 << " name " << sout(sname) 1308 << " done." << std::endl; 1309 } 1310 1311 std::string sclass = aida::ntuple::s_clas 1312 return raxml_out(new handle<aida::ntuple> 1313 } 1314 1315 /////////////////////////////////////////// 1316 /// read cloud //////////////////////////// 1317 /////////////////////////////////////////// 1318 1319 static bool read_cloud_data(tree& a_tree, 1320 histo::c1d& aCl 1321 std::ostream& a 1322 const std::string& tagName = a_tree.tag_n 1323 1324 std::string svalue; 1325 1326 if(tagName==s_annotation()) { //FIXME 1327 1328 return true; 1329 1330 } else if(tagName==s_entries1d()) { 1331 1332 {looper _for(a_tree); 1333 while(element* _elem = _for.next_elemen 1334 if(_elem->name()==s_entry1d()) { 1335 double x; 1336 if(!_elem->attribute_value(s_valueX 1337 double w = 1; 1338 if(_elem->attribute_value(s_weight( 1339 if(!to<double>(svalue,w)) return 1340 } 1341 if(!aCloud.fill(x,w)) return false; 1342 } 1343 }} 1344 return true; 1345 1346 } else if(tagName==s_histogram1d()) { 1347 1348 raxml_out ro = read_h1d(a_tree,a_out,a_ 1349 if(ro.cls()==histo::h1d::s_class()) { 1350 histo::h1d* h = (histo::h1d*)ro.objec 1351 if(h) { 1352 aCloud.set_histogram(h); 1353 ro.disown(); 1354 } 1355 } 1356 return true; 1357 1358 } 1359 1360 return false; 1361 } 1362 1363 static bool read_cloud_data(tree& a_tree, 1364 histo::c2d& aCl 1365 bool a_verbose, 1366 std::ostream& a 1367 const std::string& tagName = a_tree.tag_n 1368 1369 std::string svalue; 1370 1371 if(tagName==s_annotation()) { //FIXME 1372 1373 return true; 1374 1375 } else if(tagName==s_entries2d()) { 1376 1377 {looper _for(a_tree); 1378 while(element* _elem = _for.next_elemen 1379 if(_elem->name()==s_entry2d()) { 1380 double x; 1381 if(!_elem->attribute_value(s_valueX 1382 double y; 1383 if(!_elem->attribute_value(s_valueY 1384 double w = 1; 1385 if(_elem->attribute_value(s_weight( 1386 if(!to<double>(svalue,w)) return 1387 } 1388 if(!aCloud.fill(x,y,w)) return fals 1389 } 1390 }} 1391 return true; 1392 1393 } else if(tagName==s_histogram2d()) { 1394 1395 raxml_out ro = read_h2d(a_tree,a_out,a_ 1396 if(ro.cls()==histo::h2d::s_class()) { 1397 histo::h2d* h = (histo::h2d*)ro.objec 1398 if(h) { 1399 aCloud.set_histogram(h); 1400 ro.disown(); 1401 } 1402 } 1403 return true; 1404 1405 } 1406 1407 return false; 1408 } 1409 1410 static bool read_cloud_data(tree& a_tree, 1411 histo::c3d& aCl 1412 bool a_verbose, 1413 std::ostream& a 1414 const std::string& tagName = a_tree.tag_n 1415 1416 std::string svalue; 1417 1418 if(tagName==s_annotation()) { //FIXME 1419 1420 return true; 1421 1422 } else if(tagName==s_entries3d()) { 1423 1424 {looper _for(a_tree); 1425 while(element* _elem = _for.next_elemen 1426 if(_elem->name()==s_entry3d()) { 1427 double x; 1428 if(!_elem->attribute_value(s_valueX 1429 double y; 1430 if(!_elem->attribute_value(s_valueY 1431 double z; 1432 if(!_elem->attribute_value(s_valueZ 1433 double w = 1; 1434 if(_elem->attribute_value(s_weight( 1435 if(!to<double>(svalue,w)) return 1436 } 1437 if(!aCloud.fill(x,y,z,w)) return fa 1438 } 1439 }} 1440 return true; 1441 1442 } else if(tagName==s_histogram3d()) { 1443 1444 raxml_out ro = read_h3d(a_tree,a_out,a_ 1445 if(ro.cls()==histo::h3d::s_class()) { 1446 histo::h3d* h = (histo::h3d*)ro.objec 1447 if(h) { 1448 aCloud.set_histogram(h); 1449 ro.disown(); 1450 } 1451 } 1452 return true; 1453 1454 } 1455 1456 return false; 1457 } 1458 1459 static bool read_dps_data(tree& a_tree,hist 1460 const std::string& tagName = a_tree.tag_n 1461 1462 std::string svalue; 1463 1464 if(tagName==s_annotation()) { //FIXME 1465 1466 return true; 1467 1468 } else if(tagName==s_dataPoint()) { 1469 1470 histo::data_point& point = a_dps.add_po 1471 1472 unsigned int coord = 0; 1473 1474 {looper _for(a_tree); 1475 while(element* _elem = _for.next_elemen 1476 if(_elem->name()==s_measurement()) { 1477 if(coord>=a_dps.dimension()) return 1478 double value; 1479 if(!_elem->attribute_value(s_value( 1480 double errorPlus = 0; 1481 if(_elem->attribute_value(s_errorPl 1482 if(!to<double>(svalue,errorPlus)) 1483 } 1484 double errorMinus = 0; 1485 if(_elem->attribute_value(s_errorMi 1486 if(!to<double>(svalue,errorMinus) 1487 } 1488 1489 histo::measurement& _m = point.coor 1490 _m.set_value(value); 1491 _m.set_error_plus(errorPlus); 1492 _m.set_error_minus(errorMinus); 1493 1494 coord++; 1495 } 1496 }} 1497 return true; 1498 1499 } 1500 1501 return false; 1502 } 1503 1504 1505 protected: 1506 readers m_readers; 1507 std::vector<raxml_out> m_objects; 1508 }; 1509 1510 }} 1511 1512 #endif