Main Page
Related Pages
Namespaces
Classes
Files
File List
File Members
binners
Bins2DBase.cxx
Go to the documentation of this file.
1
13
#ifdef _MSC_VER
14
// Include max() and min() missing from MicroSoft Visual C++.
15
#include "msdevstudio/MSconfig.h"
16
#endif
17
18
#include "
Bins2DBase.h
"
19
20
#include "
BinnerAxis.h
"
21
22
#include "
datasrcs/NTuple.h
"
23
24
#include <numeric>
25
26
#include <cassert>
27
28
using
std::string;
29
using
std::vector;
30
31
32
using namespace
hippodraw;
33
34
Bins2DBase::Bins2DBase
(
const
char
* name )
35
:
BinsBase
( name ),
36
binner_axisX ( 0 ),
37
binner_axisY ( 0 )
38
{
39
}
40
41
Bins2DBase::Bins2DBase
(
const
Bins2DBase
& binner )
42
:
BinsBase
( binner ),
43
binner_axisX ( 0 ),
44
binner_axisY ( 0 ),
45
m_data ( binner.m_data )
46
{
47
if
( binner.
binner_axisX
!= 0 ) {
48
binner_axisX
= binner.
binner_axisX
->
clone
();
49
}
50
51
if
( binner.
binner_axisY
!= 0 ) {
52
binner_axisY
= binner.
binner_axisY
->
clone
();
53
}
54
55
m_values_dirty
=
true
;
56
}
57
58
Bins2DBase::~Bins2DBase
()
59
{
60
if
(
binner_axisX
)
delete
binner_axisX
;
61
if
(
binner_axisY
)
delete
binner_axisY
;
62
}
63
64
int
65
Bins2DBase::
66
getNumberOfAxes
()
const
67
{
68
return
2;
69
}
70
71
void
Bins2DBase::resize
()
72
{
73
int
nbx =
numberOfBins
(
Axes::X
);
74
int
nby =
numberOfBins
(
Axes::Y
);
75
76
if
( nbx == 0 ||
77
nby == 0 )
return
;
78
79
resize
( nbx, nby );
80
}
81
82
const
BinnerAxis
*
83
Bins2DBase::
84
getBinnerOn
(
hippodraw::Axes::Type
axis )
const
85
{
86
assert ( axis ==
Axes::X
||
87
axis ==
Axes::Y
);
88
89
if
( axis ==
Axes::X
)
return
binner_axisX
;
90
// else Y
91
return
binner_axisY
;
92
}
93
94
95
void
96
Bins2DBase::
97
setBinnerOn
(
BinnerAxis
* binner,
hippodraw::Axes::Type
axis )
98
{
99
assert ( axis ==
Axes::X
|| axis ==
Axes::Y
);
100
101
if
( axis ==
Axes::X
) {
102
if
(
binner_axisX
)
delete
binner_axisX
;
103
binner_axisX
= binner;
104
}
105
else
{
// else Y
106
if
(
binner_axisY
)
delete
binner_axisY
;
107
binner_axisY
= binner;
108
}
109
resize
();
110
111
m_values_dirty
=
true
;
112
}
113
114
double
115
Bins2DBase::
116
getLow
(
hippodraw::Axes::Type
axis )
const
117
{
118
if
( axis ==
Axes::X
)
return
binner_axisX
->
axisGetLow
();
119
if
( axis ==
Axes::Y
)
return
binner_axisY
->
axisGetLow
();
120
121
assert (
false
);
122
return
0.0;
123
}
124
125
void
126
Bins2DBase::
127
setNumberOfBins
(
hippodraw::Axes::Type
axis,
int
nb )
128
{
129
assert ( axis ==
Axes::X
|| axis ==
Axes::Y
);
130
131
if
( axis ==
Axes::X
) {
132
binner_axisX
->
axisSetNumberOfBins
( nb );
133
134
if
(
numberOfBins
(
Axes::Y
) > 0 ) {
135
setNumberOfBins
(
Axes::Y
,
numberOfBins
(
Axes::Y
) );
136
}
137
}
138
else
{
// Y
139
binner_axisY
->
axisSetNumberOfBins
( nb );
140
}
141
142
m_num_bins
=
numberOfBins
(
Axes::X
) *
numberOfBins
(
Axes::Y
);
143
}
144
145
int
Bins2DBase::numberOfBins
()
const
146
{
147
return
m_num_bins
;
148
}
149
150
int
151
Bins2DBase::
152
numberOfBins
(
hippodraw::Axes::Type
axis)
const
153
{
154
assert ( axis ==
Axes::X
|| axis ==
Axes::Y
);
155
156
if
( axis ==
Axes::X
&&
157
binner_axisX
!= 0 )
return
binner_axisX
->
axisNumberOfBins
();
158
// else Y
159
if
(
binner_axisY
!= 0 )
return
binner_axisY
->
axisNumberOfBins
();
160
161
return
0;
162
}
163
164
int
Bins2DBase::binNumberX
(
double
x )
const
165
{
166
return
binner_axisX
->
axisBinNumber
( x );
167
}
168
169
int
Bins2DBase::binNumberY
(
double
y )
const
170
{
171
return
binner_axisY
->
axisBinNumber
( y );
172
}
173
174
double
175
Bins2DBase::
176
binWidth
(
hippodraw::Axes::Type
axis )
const
177
{
178
assert ( axis ==
Axes::X
|| axis ==
Axes::Y
);
179
180
if
( axis ==
Axes::X
)
return
binner_axisX
->
getConstWid
();
181
// else Y
182
return
binner_axisY
->
getConstWid
();
183
}
184
185
double
Bins2DBase::binWidthX
(
int
i )
const
186
{
187
return
binner_axisX
->
axisBinWidth
( i );
188
}
189
190
double
Bins2DBase::binWidthY
(
int
i )
const
191
{
192
return
binner_axisY
->
axisBinWidth
( i );
193
}
194
195
bool
196
Bins2DBase::hasEqualWidths
()
const
197
{
198
return
binner_axisX
->
hasEqualWidths
() &&
binner_axisY
->
hasEqualWidths
();
199
}
200
201
double
202
Bins2DBase::scaleFactor
()
const
203
{
204
if
(
binner_axisX
->
hasEqualWidths
() ==
false
||
205
binner_axisY
->
hasEqualWidths
() == false ) {
206
return
1.0;
207
}
208
209
double
width_x =
binner_axisX
->
axisBinWidth
( 1 );
210
double
width_y =
binner_axisY
->
axisBinWidth
( 1 );
211
212
return
width_x * width_y;
213
}
214
215
const
Range
&
216
Bins2DBase::
217
setBinWidth
(
hippodraw::Axes::Type
axis,
double
width )
218
{
219
assert ( axis ==
Axes::X
|| axis ==
Axes::Y
);
220
assert ( width > 0.0 );
221
222
BinnerAxis
* binner = 0;
223
if
( axis ==
Axes::X
) binner =
binner_axisX
;
224
else
binner =
binner_axisY
;
225
226
const
Range
& range = binner->
setBinWidth
( width );
227
228
resize
();
229
m_values_dirty
=
true
;
230
231
return
range;
232
}
233
234
double
235
Bins2DBase::
236
calcBinWidth
(
Axes::Type
axis,
int
parm,
bool
dragging )
const
237
{
238
double
new_width = -1.0;
239
240
if
( axis ==
Axes::X
) {
241
new_width =
binner_axisX
->
calcBinWidth
( parm, dragging );
242
}
243
else
{
// "Y"
244
new_width =
binner_axisY
->
calcBinWidth
( parm, dragging );
245
}
246
247
return
new_width;
248
}
249
250
double
251
Bins2DBase::calcOffset
(
const
std::string & axis,
252
int
parm,
253
bool
dragging )
const
254
{
255
if
( axis ==
"X"
) {
256
return
binner_axisX
->
calcOffset
( parm, dragging );
257
}
258
//else "Y"
259
return
binner_axisY
->
calcOffset
( parm, dragging );
260
}
261
262
double
263
Bins2DBase::
264
getOffset
(
hippodraw::Axes::Type
axis )
const
265
{
266
assert ( axis ==
Axes::X
|| axis ==
Axes::Y
);
267
268
if
( axis ==
Axes::X
)
return
binner_axisX
->
getOffset
();
269
// else Y
270
return
binner_axisY
->
getOffset
();
271
}
272
273
void
274
Bins2DBase::
275
setOffset
(
hippodraw::Axes::Type
axis,
double
offset )
276
{
277
assert ( axis ==
Axes::X
|| axis ==
Axes::Y
);
278
279
BinnerAxis
* binner = 0;
280
if
( axis ==
Axes::X
) binner =
binner_axisX
;
281
else
binner =
binner_axisY
;
282
283
binner->
setOffset
( offset );
284
285
m_values_dirty
=
true
;
286
}
287
288
const
Range
&
289
Bins2DBase::
290
setRange
(
hippodraw::Axes::Type
axis,
const
Range
& range,
bool
hold_width )
291
{
292
assert ( axis ==
Axes::X
|| axis ==
Axes::Y
);
293
294
BinnerAxis
* binner = 0;
295
if
( axis ==
Axes::X
) {
296
binner =
binner_axisX
;
297
}
else
{
298
binner =
binner_axisY
;
299
}
300
const
Range
& new_range = binner->
setRange
( range, hold_width );
301
resize
();
302
303
return
new_range;
304
}
305
306
/* virtual */
307
const
Range
&
308
Bins2DBase::
309
getRange
(
hippodraw::Axes::Type
axis )
310
{
311
assert ( axis ==
Axes::X
|| axis ==
Axes::Y
);
312
313
BinnerAxis
* binner = 0;
314
if
( axis ==
Axes::X
) {
315
binner =
binner_axisX
;
316
}
else
{
317
binner =
binner_axisY
;
318
}
319
320
return
binner->
getRange
();
321
}
322
323
329
void
330
Bins2DBase::resize
(
int
nx,
int
ny )
331
{
332
// The following is necessary in order to prevent a memory leak
333
Bins2DBase::setNumberOfBins
(
Axes::Y
, 0 );
334
335
setNumberOfBins
(
Axes::X
, nx );
336
setNumberOfBins
(
Axes::Y
, ny );
337
338
m_values_dirty
=
true
;
339
}
340
341
int
Bins2DBase::getNumberOfEntries
()
const
342
{
343
double
sum = 0.0;
344
for
(
unsigned
int
i = 1; i <
m_data
.size () -1; i++ ) {
345
sum +=
std::accumulate
(
m_data
[i].begin()+1,
m_data
[i].end()-1, 0.0 );
346
}
347
348
return
static_cast <
int
> ( sum );
349
}
350
351
int
Bins2DBase::getUnderflow
()
const
352
{
353
return
-1;
354
}
355
356
int
Bins2DBase::getOverflow
()
const
357
{
358
return
-1;
359
}
360
361
362
NTuple
*
363
Bins2DBase::
364
prepareNTuple
(
unsigned
int
rows )
const
365
{
366
unsigned
int
columns = 6;
367
NTuple
* ntuple =
new
NTuple
( columns );
368
ntuple -> reserve ( rows );
369
370
// note: using setLabelAt instead of setLables(...) save 10KB of code
371
ntuple -> setLabelAt (
"X"
, 0 );
372
ntuple -> setLabelAt (
"Y"
, 0 );
373
ntuple -> setLabelAt (
"Value"
, 0 );
374
ntuple -> setLabelAt (
"Width"
, 0 );
375
ntuple -> setLabelAt (
"Height"
, 0 );
376
ntuple -> setLabelAt (
"Error"
, 0 );
377
378
return
ntuple;
379
}
Generated for HippoDraw Class Library by