Detailed Description

Test program for the class TUnfoldBinning.

read a simple binning scheme and create/test bin maps

0.0113070011139
92.899515152
Processing /mnt/build/workspace/root-makedoc-v614/rootspi/rdoc/src/v6-14-00-patches/tutorials/unfold/testUnfold6.C...
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->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";
      }
   }
}

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.