| 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