Logo ROOT  

Reference Guide
testUnfold6.C File Reference
Tutorials » TUnfold tutorials

Detailed Description

View in nbviewer Open in SWAN Test program for the class TUnfoldBinning.

read a simple binning scheme and create/test bin maps

Binning scheme:
=================================
TUnfoldBinning "binning" has 20 bins [1,21] nTH1x=20
TUnfoldBinning "branch1" has 12 bins [1,13] nTH1x=12
distribution: 12 bins
"x" nbin=4
"y" nbin=3
TUnfoldBinning "branch2" has 6 bins [13,19] nTH1x=6
distribution: 6 bins
"x" nbin=3
"y" nbin=2
TUnfoldBinning "branch3" has 2 bins [19,21] nTH1x=2
distribution: 2 bins
"x" nbin=2
CreateEmptyBinMap
=======================
global bin: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
mapped to: -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1
branch1->FillBinMap1D(...,"y[C]",...,2)
=======================
global bin: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
mapped to: -1 2 3 4 5 2 3 4 5 2 3 4 5 -1 -1 -1 -1 -1 -1 -1 -1 -1
dest |contributing bins
=====+======================================
2 |#1 (branch1:y[0,1]:x[0,1])
2 |#5 (branch1:y[1,2]:x[0,1])
2 |#9 (branch1:y[2,3]:x[0,1])
=====+======================================
3 |#2 (branch1:y[0,1]:x[1,2])
3 |#6 (branch1:y[1,2]:x[1,2])
3 |#10 (branch1:y[2,3]:x[1,2])
=====+======================================
4 |#3 (branch1:y[0,1]:x[2,3])
4 |#7 (branch1:y[1,2]:x[2,3])
4 |#11 (branch1:y[2,3]:x[2,3])
=====+======================================
5 |#4 (branch1:y[0,1]:x[3,4])
5 |#8 (branch1:y[1,2]:x[3,4])
5 |#12 (branch1:y[2,3]:x[3,4])
=====+======================================
branch2->FillBinMap1D(...,"x[C]",...,7)
=======================
global bin: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
mapped to: -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 7 7 7 8 8 8 -1 -1 -1
dest |contributing bins
=====+======================================
7 |#13 (branch2:y[0,1]:x[0,1])
7 |#14 (branch2:y[0,1]:x[1,2])
7 |#15 (branch2:y[0,1]:x[2,3])
=====+======================================
8 |#16 (branch2:y[1,2]:x[0,1])
8 |#17 (branch2:y[1,2]:x[1,2])
8 |#18 (branch2:y[1,2]:x[2,3])
=====+======================================
binning->FillBinMap1D(...,"y[C]",...,1)
=======================
global bin: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
mapped to: -1 1 2 3 4 1 2 3 4 1 2 3 4 5 6 7 5 6 7 8 9 -1
dest |contributing bins
=====+======================================
1 |#1 (branch1:y[0,1]:x[0,1])
1 |#5 (branch1:y[1,2]:x[0,1])
1 |#9 (branch1:y[2,3]:x[0,1])
=====+======================================
2 |#2 (branch1:y[0,1]:x[1,2])
2 |#6 (branch1:y[1,2]:x[1,2])
2 |#10 (branch1:y[2,3]:x[1,2])
=====+======================================
3 |#3 (branch1:y[0,1]:x[2,3])
3 |#7 (branch1:y[1,2]:x[2,3])
3 |#11 (branch1:y[2,3]:x[2,3])
=====+======================================
4 |#4 (branch1:y[0,1]:x[3,4])
4 |#8 (branch1:y[1,2]:x[3,4])
4 |#12 (branch1:y[2,3]:x[3,4])
=====+======================================
5 |#13 (branch2:y[0,1]:x[0,1])
5 |#16 (branch2:y[1,2]:x[0,1])
=====+======================================
6 |#14 (branch2:y[0,1]:x[1,2])
6 |#17 (branch2:y[1,2]:x[1,2])
=====+======================================
7 |#15 (branch2:y[0,1]:x[2,3])
7 |#18 (branch2:y[1,2]:x[2,3])
=====+======================================
8 |#19 (branch3:x[0,1])
=====+======================================
9 |#20 (branch3:x[1,2])
=====+======================================
#include <iostream>
#include <fstream>
#include <iomanip>
#include <map>
#include <TDOMParser.h>
#include <TXMLDocument.h>
#include "TUnfoldBinningXML.h"
using namespace std;
void PrintBinMap(TUnfoldBinning *binning,const char * where,
const Int_t *binMap);
void testUnfold6()
{
TDOMParser parser;
ofstream dtdFile("tunfoldbinning.dtd");
TUnfoldBinningXML::WriteDTD(dtdFile);
dtdFile.close();
TString dir = gSystem->UnixPathName(gSystem->DirName(__FILE__));
Int_t error=parser.ParseFile(dir+"/testUnfold6binning.xml");
if(error) cout<<"error="<<error<<" from TDOMParser\n";
TXMLDocument const *XMLdocument=parser.GetXMLDocument();
TUnfoldBinningXML *binning=
TUnfoldBinningXML::ImportXML(XMLdocument,"binning");
if(!binning) {
cout<<"error: can not read binning (document empty?)\n";
} else {
cout<<"Binning scheme:\n =================================\n";
binning->PrintStream(cout);
Int_t *binMap=binning->CreateEmptyBinMap();
PrintBinMap(binning,"CreateEmptyBinMap",binMap);
TUnfoldBinning const *branch1=binning->FindNode("branch1");
branch1->FillBinMap1D(binMap,"y[C]",2);
PrintBinMap(binning,"branch1->FillBinMap1D(...,\"y[C]\",...,2)",binMap);
delete binMap; binMap=binning->CreateEmptyBinMap();
TUnfoldBinning const *branch2=binning->FindNode("branch2");
branch2->FillBinMap1D(binMap,"x[C]",7);
PrintBinMap(binning,"branch2->FillBinMap1D(...,\"x[C]\",...,7)",binMap);
delete binMap; binMap=binning->CreateEmptyBinMap();
binning->FillBinMap1D(binMap,"y[C]",1);
PrintBinMap(binning,"binning->FillBinMap1D(...,\"y[C]\",...,1)",binMap);
binning->ExportXML("testUnfold6.out.xml");
}
}
void PrintBinMap(TUnfoldBinning *binning,const char * where,
const Int_t *binMap) {
cout<<"\n"<<where<<"\n=======================\n";
cout<<"global bin:";
for(int i=0;i<binning->GetEndBin()+1;i++) {
cout<<setw(3)<<i;
}
cout<<"\n";
cout<<"mapped to: ";
for(int i=0;i<binning->GetEndBin()+1;i++) {
cout<<setw(3)<<binMap[i];
}
cout<<"\n";
map<int,vector<int> > destBin;
for(int i=0;i<binning->GetEndBin()+1;i++) {
destBin[binMap[i]].push_back(i);
}
bool printed=false;
for(map<int,vector<int> >::const_iterator i=destBin.begin();i!=destBin.end();i++) {
if((*i).first>=0) {
if(!printed) {
cout<<"\ndest |contributing bins\n"
<<"=====+======================================\n";
printed=true;
}
for(size_t j=0;j<(*i).second.size();j++) {
cout<<setw(4)<<(*i).first<<" |";
cout<<setw(3)<<binning->GetBinName((*i).second[j])<<"\n";
}
cout<<"=====+======================================\n";
}
}
}
Int_t
int Int_t
Definition: RtypesCore.h:41
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:560
TDOMParser::GetXMLDocument
virtual TXMLDocument * GetXMLDocument() const
Returns the TXMLDocument.
Definition: TDOMParser.cxx:144
TDOMParser::ParseFile
virtual Int_t ParseFile(const char *filename)
Parse the XML file where filename is the XML file name.
Definition: TDOMParser.cxx:70
TString
Basic string class.
Definition: TString.h:131
TSystem::DirName
virtual const char * DirName(const char *pathname)
Return the directory name in pathname.
Definition: TSystem.cxx:1014
TSystem::UnixPathName
virtual const char * UnixPathName(const char *unixpathname)
Convert from a Unix pathname to a local pathname.
Definition: TSystem.cxx:1054
TUnfoldBinningXML
XML interfate to binning schemes, for use with the unfolding algorithm TUnfoldDensity.
Definition: TUnfoldBinningXML.h:55
TUnfoldBinningXML::ExportXML
static Int_t ExportXML(const TUnfoldBinning &binning, std::ostream &out, Bool_t writeHeader, Bool_t writeFooter, Int_t indent=0)
Export a binning scheme to a stream in XML format.
Definition: TUnfoldBinningXML.cxx:485
TUnfoldBinningXML::ImportXML
static TUnfoldBinningXML * ImportXML(const TXMLDocument *document, const char *name)
Import a binning scheme from an XML file.
Definition: TUnfoldBinningXML.cxx:191
TUnfoldBinningXML::WriteDTD
static void WriteDTD(const char *fileName="tunfoldbinning.dtd")
Write dtd file.
Definition: TUnfoldBinningXML.cxx:172
TUnfoldBinning
Binning schemes for use with the unfolding algorithm TUnfoldDensity.
Definition: TUnfoldBinning.h:53
TUnfoldBinning::PrintStream
void PrintStream(std::ostream &out, Int_t indent=0, int debug=0) const
Print some information about this binning tree.
Definition: TUnfoldBinning.cxx:436
TUnfoldBinning::FillBinMap1D
Int_t FillBinMap1D(Int_t *binMap, const char *axisSteering, Int_t firstBinX) const
Map all global bins referenced by this node to the one-dimensional histogram destHist,...
Definition: TUnfoldBinning.cxx:1083
TUnfoldBinning::GetBinName
TString GetBinName(Int_t iBin) const
Get the name of a bin.
Definition: TUnfoldBinning.cxx:1677
TUnfoldBinning::GetEndBin
Int_t GetEndBin(void) const
last+1 bin of this node (includes children)
Definition: TUnfoldBinning.h:141
TUnfoldBinning::CreateEmptyBinMap
Int_t * CreateEmptyBinMap(void) const
Create an empty bin map, useful together with the getter methods of class TUnfold and TUnfoldSys.
Definition: TUnfoldBinning.cxx:1041
TUnfoldBinning::FindNode
TUnfoldBinning const * FindNode(char const *name) const
Traverse the tree and return the first node which matches the given name.
Definition: TUnfoldBinning.cxx:542
TXMLDocument
TXMLDocument contains a pointer to an xmlDoc structure, after the parser returns a tree built during ...
Definition: TXMLDocument.h:24

Version 17.6, in parallel to changes in TUnfold

History:

  • Version 17.5, in parallel to changes in TUnfold
  • Version 17.4, in parallel to changes in TUnfold
  • Version 17.3, test bin map functionality in TUnfoldBinning

This file is part of TUnfold.

TUnfold is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

TUnfold is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with TUnfold. If not, see http://www.gnu.org/licenses/.

Author
Stefan Schmitt DESY, 14.10.2008

Definition in file testUnfold6.C.