1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
//*********************************************************************
// Convert a THnSparse to a TTree using efficient iteration through the THnSparse
// and draw a THnSparse using TParallelCoord.
// The plot will contain one line for each filled bin,
// with the bin's coordinates on each axis, and the bin's content on
// the rightmost axis.
//
// Run as
// .L $ROOTSYS/tutorials/tree/drawsparse.C+
//
// Axel.Naumann@cern.ch (2007-09-14)
// ********************************************************************
#include "TParallelCoord.h"
#include "TParallelCoordVar.h"
#include "TROOT.h"
#include "TTree.h"
#include "TLeaf.h"
#include "THnSparse.h"
#include "TAxis.h"
#include "TCanvas.h"
#include "TRandom.h"
#include "TFile.h"
#include "TH3.h"
//______________________________________________________________________________
TTree* toTree(THnSparse* h)
{
// Creates a TTree and fills it with the coordinates of all
// filled bins. The tree will have one branch for each dimension,
// and one for the bin content.
Int_t dim = h->GetNdimensions();
TString name(h->GetName()); name += "_tree";
TString title(h->GetTitle()); title += " tree";
TTree* tree = new TTree(name, title);
Double_t* x = new Double_t[dim + 1];
memset(x, 0, sizeof(Double_t) * (dim + 1));
TString branchname;
for (Int_t d = 0; d < dim; ++d) {
if (branchname.Length())
branchname += ":";
TAxis* axis = h->GetAxis(d);
branchname += axis->GetName();
branchname += "/D";
}
tree->Branch("coord", x, branchname);
tree->Branch("bincontent", &x[dim], "bincontent/D");
Int_t *bins = new Int_t[dim];
for (Long64_t i = 0; i < h->GetNbins(); ++i) {
x[dim] = h->GetBinContent(i, bins);
for (Int_t d = 0; d < dim; ++d) {
x[d] = h->GetAxis(d)->GetBinCenter(bins[d]);
}
tree->Fill();
}
delete [] bins;
//delete [] x;
return tree;
}
//______________________________________________________________________________
void drawsparse_draw(THnSparse* h)
{
// Draw a THnSparse using TParallelCoord, creating a temporary TTree.
TTree* tree = toTree(h);
TString whatToDraw;
TIter iLeaf(tree->GetListOfLeaves());
const TLeaf* leaf = 0;
while ((leaf = (const TLeaf*)iLeaf())) {
if (whatToDraw.Length())
whatToDraw += ":";
whatToDraw += leaf->GetName();
}
tree->Draw(whatToDraw, "", "para");
TParallelCoord* parallelCoord = (TParallelCoord*)gPad->GetListOfPrimitives()->FindObject("ParaCoord");
TIter iVar(parallelCoord->GetVarList());
TParallelCoordVar* var = 0;
for (Int_t d = 0;(var = (TParallelCoordVar*) iVar()) && d < h->GetNdimensions(); ++d) {
TAxis* axis = h->GetAxis(d);
var->SetHistogramBinning(axis->GetNbins());
var->SetCurrentLimits(axis->GetXmin(), axis->GetXmax());
var->SetTitle(axis->GetTitle());
}
var->SetTitle("bin content");
}
//______________________________________________________________________________
void drawsparse()
{
// create a THnSparse and draw it.
#ifdef __CINT__
printf("For performance reasons we advise to run \".x drawsparse.C+\"\n");
#endif
const Int_t ndims = 8;
Int_t bins[ndims] = {10, 10, 5, 30, 10, 4, 18, 12};
Double_t xmin[ndims] = {-5., -10., -1000., -3., 0., 0., 0., 0.};
Double_t xmax[ndims] = {10., 70., 3000., 3., 5., 2., 2., 5.};
THnSparse* hs = new THnSparseD("hs", "Sparse Histogram", ndims, bins, xmin, xmax);
// fill it
Double_t x[ndims];
for (Long_t i = 0; i < 100000; ++i) {
for (Int_t d = 0; d < ndims; ++d) {
switch (d) {
case 0: x[d] = gRandom->Gaus()*2 + 3.; break;
case 1:
case 2:
case 3: x[d] = (x[d-1]*x[d-1] - 1.5)/1.5 + (0.5*gRandom->Rndm()); break;
default: x[d] = sin(gRandom->Gaus()*i/1000.) + 1.;
}
}
hs->Fill(x);
}
TFile* f = new TFile("drawsparse.root","RECREATE");
TCanvas* canv = new TCanvas("hDrawSparse", "Drawing a sparse hist");
canv->Divide(2);
// draw it
canv->cd(1);
drawsparse_draw(hs);
// project it
canv->cd(2);
TH3D* h3proj = hs->Projection(2, 3, 6);
h3proj->SetLineColor(kOrange);
h3proj->SetDirectory(0);
h3proj->Draw("lego1");
// save everything to a file
canv->Write();
hs->Write();
h3proj->Write();
delete f;
}
|
