testUnfold6.C File Reference

Detailed Description

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 std::cout, std::vector, std::map, std::setw;
 
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->GetDirName(__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");
 
     delete [] binMap;
 
  }
}
 
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.