Logo ROOT  
Reference Guide
TProfile3D.cxx
Go to the documentation of this file.
1// @(#)root/hist:$Id$
2// Author: Rene Brun 17/05/2006
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include "TProfile3D.h"
13#include "TProfile2D.h"
14#include "THashList.h"
15#include "TMath.h"
16#include "THLimitsFinder.h"
17#include "Riostream.h"
18#include "TVirtualPad.h"
19#include "TError.h"
20#include "TClass.h"
21
22#include "TProfileHelper.h"
23
25
27
28/** \class TProfile3D
29 \ingroup Hist
30 Profile3D histograms are used to display the mean
31 value of T and its RMS for each cell in X,Y,Z.
32 Profile3D histograms are in many cases an
33 The inter-relation of three measured quantities X, Y, Z and T can always
34 be visualized by a four-dimensional histogram or scatter-plot;
35 its representation on the line-printer is not particularly
36 satisfactory, except for sparse data. If T is an unknown (but single-valued)
37 approximate function of X,Y,Z this function is displayed by a profile3D histogram with
38 much better precision than by a scatter-plot.
39
40 The following formulae show the cumulated contents (capital letters) and the values
41 displayed by the printing or plotting routines (small letters) of the elements for cell I, J.
42
43 2
44 H(I,J,K) = sum T E(I,J,K) = sum T
45 l(I,J,K) = sum l L(I,J,K) = sum l
46 h(I,J,K) = H(I,J,K)/L(I,J,K) s(I,J,K) = sqrt(E(I,J,K)/L(I,J,K)- h(I,J,K)**2)
47 e(I,J,K) = s(I,J,K)/sqrt(L(I,J,K))
48
49 In the special case where s(I,J,K) is zero (eg, case of 1 entry only in one cell)
50 e(I,J,K) is computed from the average of the s(I,J,K) for all cells,
51 if the static function TProfile3D::Approximate has been called.
52 This simple/crude approximation was suggested in order to keep the cell
53 during a fit operation. But note that this approximation is not the default behaviour.
54
55 Example of a profile3D histogram
56~~~~{.cpp}
57{
58 auto c1 = new TCanvas("c1","Profile histogram example",200,10,700,500);
59 auto hprof3d = new TProfile3D("hprof3d","Profile of pt versus px, py and pz",40,-4,4,40,-4,4,40,0,20);
60 Double_t px, py, pz, pt;
61 TRandom3 r(0);
62 for ( Int_t i=0; i<25000; i++) {
63 r.Rannor(px,py);
64 pz = px*px + py*py;
65 pt = r.Landau(0,1);
66 hprof3d->Fill(px,py,pz,pt,1);
67 }
68 hprof3d->Draw();
69}
70~~~~
71 NOTE: A TProfile3D is drawn as it was a simple TH3
72*/
73
74////////////////////////////////////////////////////////////////////////////////
75/// Default constructor for Profile3D histograms.
76
78{
79 fTsumwt = fTsumwt2 = 0;
81 BuildOptions(0,0,"");
82}
83
84////////////////////////////////////////////////////////////////////////////////
85/// Default destructor for Profile3D histograms.
86
88{
89}
90
91////////////////////////////////////////////////////////////////////////////////
92/// Normal Constructor for Profile histograms.
93///
94/// The first eleven parameters are similar to TH3D::TH3D.
95/// All values of t are accepted at filling time.
96/// To fill a profile3D histogram, one must use TProfile3D::Fill function.
97///
98/// Note that when filling the profile histogram the function Fill
99/// checks if the variable t is between fTmin and fTmax.
100/// If a minimum or maximum value is set for the T scale before filling,
101/// then all values below tmin or above tmax will be discarded.
102/// Setting the minimum or maximum value for the T scale before filling
103/// has the same effect as calling the special TProfile3D constructor below
104/// where tmin and tmax are specified.
105///
106/// H(I,J,K) is printed as the cell contents. The errors computed are s(I,J,K) if CHOPT='S'
107/// (spread option), or e(I,J,K) if CHOPT=' ' (error on mean).
108///
109/// See TProfile3D::BuildOptions for explanation of parameters
110///
111/// see other constructors below with all possible combinations of
112/// fix and variable bin size like in TH3D.
113
114TProfile3D::TProfile3D(const char *name,const char *title,Int_t nx,Double_t xlow,Double_t xup,Int_t ny,Double_t ylow,Double_t yup,Int_t nz, Double_t zlow,Double_t zup,Option_t *option)
115 : TH3D(name,title,nx,xlow,xup,ny,ylow,yup,nz,zlow,zup)
116{
117 BuildOptions(0,0,option);
118 if (xlow >= xup || ylow >= yup || zlow >= zup) SetBuffer(fgBufferSize);
119}
120
121////////////////////////////////////////////////////////////////////////////////
122/// Create a 3-D Profile with variable bins in X , Y and Z.
123
124TProfile3D::TProfile3D(const char *name,const char *title,Int_t nx,const Double_t *xbins,Int_t ny,const Double_t *ybins,Int_t nz,const Double_t *zbins,Option_t *option)
125 : TH3D(name,title,nx,xbins,ny,ybins,nz,zbins)
126{
127 BuildOptions(0,0,option);
128}
129
130////////////////////////////////////////////////////////////////////////////////
131/// Set Profile3D histogram structure and options.
132///
133/// - tmin: minimum value allowed for t
134/// - tmax: maximum value allowed for t
135/// if (tmin = tmax = 0) there are no limits on the allowed t values (tmin = -inf, tmax = +inf)
136///
137/// - option: this is the option for the computation of the t error of the profile ( TProfile3D::GetBinError )
138/// possible values for the options are documented in TProfile3D::SetErrorOption
139///
140/// see also TProfile::BuildOptions for a detailed description
141
143{
144 SetErrorOption(option);
145
146 // create extra profile data structure (bin entries/ y^2 and sum of weight square)
148
149 fTmin = tmin;
150 fTmax = tmax;
152 fTsumwt = fTsumwt2 = 0;
153}
154
155////////////////////////////////////////////////////////////////////////////////
156/// Copy constructor.
157
159{
160 ((TProfile3D&)profile).Copy(*this);
161}
162
164{
165 ((TProfile3D &)profile).Copy(*this);
166 return *this;
167}
168
169////////////////////////////////////////////////////////////////////////////////
170/// Performs the operation: `this = this + c1*f1` .
171
173{
174 Error("Add","Function not implemented for TProfile3D");
175 return kFALSE;
176}
177
178////////////////////////////////////////////////////////////////////////////////
179/// Performs the operation: `this = this + c1*h1` .
180
182{
183 if (!h1) {
184 Error("Add","Attempt to add a non-existing profile");
185 return kFALSE;
186 }
188 Error("Add","Attempt to add a non-profile2D object");
189 return kFALSE;
190 }
191
192 return TProfileHelper::Add(this, this, h1, 1, c1);
193}
194
195////////////////////////////////////////////////////////////////////////////////
196/// Replace contents of this profile3D by the addition of h1 and h2.
197///
198/// `this = c1*h1 + c2*h2`
199
201{
202 if (!h1 || !h2) {
203 Error("Add","Attempt to add a non-existing profile");
204 return kFALSE;
205 }
207 Error("Add","Attempt to add a non-profile3D object");
208 return kFALSE;
209 }
210 if (!h2->InheritsFrom(TProfile3D::Class())) {
211 Error("Add","Attempt to add a non-profile3D object");
212 return kFALSE;
213 }
214
215 return TProfileHelper::Add(this, h1, h2, c1, c2);
216}
217
218
219////////////////////////////////////////////////////////////////////////////////
220/// Set the fgApproximate flag.
221///
222/// When the flag is true, the function GetBinError
223/// will approximate the bin error with the average profile error on all bins
224/// in the following situation only
225///
226/// - the number of bins in the profile3D is less than 10404 (eg 100x100x100)
227/// - the bin number of entries is small ( <5)
228/// - the estimated bin error is extremely small compared to the bin content
229/// (see TProfile3D::GetBinError)
230
232{
233 fgApproximate = approx;
234}
235
236
237////////////////////////////////////////////////////////////////////////////////
238/// Fill histogram with all entries in the buffer.
239///
240/// - action = -1 histogram is reset and refilled from the buffer (called by THistPainter::Paint)
241/// - action = 0 histogram is filled from the buffer
242/// - action = 1 histogram is filled and buffer is deleted
243/// The buffer is automatically deleted when the number of entries
244/// in the buffer is greater than the number of entries in the histogram
245
247{
248 // do we need to compute the bin size?
249 if (!fBuffer) return 0;
250 Int_t nbentries = (Int_t)fBuffer[0];
251 if (!nbentries) return 0;
252 Double_t *buffer = fBuffer;
253 if (nbentries < 0) {
254 if (action == 0) return 0;
255 nbentries = -nbentries;
256 fBuffer=0;
257 Reset("ICES"); // reset without deleting the functions
258 fBuffer = buffer;
259 }
261 //find min, max of entries in buffer
262 Double_t xmin = fBuffer[2];
264 Double_t ymin = fBuffer[3];
266 Double_t zmin = fBuffer[4];
267 Double_t zmax = zmin;
268 for (Int_t i=1;i<nbentries;i++) {
269 Double_t x = fBuffer[5*i+2];
270 if (x < xmin) xmin = x;
271 if (x > xmax) xmax = x;
272 Double_t y = fBuffer[5*i+3];
273 if (y < ymin) ymin = y;
274 if (y > ymax) ymax = y;
275 Double_t z = fBuffer[5*i+4];
276 if (z < zmin) zmin = z;
277 if (z > zmax) zmax = z;
278 }
281 } else {
282 fBuffer = 0;
283 Int_t keep = fBufferSize; fBufferSize = 0;
288 if (zmin < fZaxis.GetXmin()) ExtendAxis(zmin,&fZaxis);
289 if (zmax >= fZaxis.GetXmax()) ExtendAxis(zmax,&fZaxis);
290 fBuffer = buffer;
291 fBufferSize = keep;
292 }
293 }
294
295 fBuffer = 0;
296 for (Int_t i=0;i<nbentries;i++) {
297 Fill(buffer[5*i+2],buffer[5*i+3],buffer[5*i+4],buffer[5*i+5],buffer[5*i+1]);
298 }
299 fBuffer = buffer;
300
301 if (action > 0) { delete [] fBuffer; fBuffer = 0; fBufferSize = 0;}
302 else {
303 if (nbentries == (Int_t)fEntries) fBuffer[0] = -nbentries;
304 else fBuffer[0] = 0;
305 }
306 return nbentries;
307}
308
309////////////////////////////////////////////////////////////////////////////////
310/// Accumulate arguments in buffer.
311///
312/// When buffer is full, empty the buffer
313///
314/// - fBuffer[0] = number of entries in buffer
315/// - fBuffer[1] = w of first entry
316/// - fBuffer[2] = x of first entry
317/// - fBuffer[3] = y of first entry
318/// - fBuffer[4] = z of first entry
319/// - fBuffer[5] = t of first entry
320
322{
323 if (!fBuffer) return -3;
324 Int_t nbentries = (Int_t)fBuffer[0];
325 if (nbentries < 0) {
326 nbentries = -nbentries;
327 fBuffer[0] = nbentries;
328 if (fEntries > 0) {
329 Double_t *buffer = fBuffer; fBuffer=0;
330 Reset("ICES"); // reset without deleting the functions
331 fBuffer = buffer;
332 }
333 }
334 if (5*nbentries+5 >= fBufferSize) {
335 BufferEmpty(1);
336 return Fill(x,y,z,t,w);
337 }
338 fBuffer[5*nbentries+1] = w;
339 fBuffer[5*nbentries+2] = x;
340 fBuffer[5*nbentries+3] = y;
341 fBuffer[5*nbentries+4] = z;
342 fBuffer[5*nbentries+5] = t;
343 fBuffer[0] += 1;
344 return -2;
345}
346
347////////////////////////////////////////////////////////////////////////////////
348/// Copy a Profile3D histogram to a new profile2D histogram.
349
350void TProfile3D::Copy(TObject &obj) const
351{
352 try {
353 TProfile3D & pobj = dynamic_cast<TProfile3D&>(obj);
354
355 TH3D::Copy(pobj);
358 for (int bin=0;bin<fNcells;bin++) {
359 pobj.fArray[bin] = fArray[bin];
360 pobj.fSumw2.fArray[bin] = fSumw2.fArray[bin];
361 }
362 pobj.fTmin = fTmin;
363 pobj.fTmax = fTmax;
364 pobj.fScaling = fScaling;
365 pobj.fErrorMode = fErrorMode;
366 pobj.fTsumwt = fTsumwt;
367 pobj.fTsumwt2 = fTsumwt2;
368
369 } catch(...) {
370 Fatal("Copy","Cannot copy a TProfile3D in a %s",obj.IsA()->GetName());
371 }
372}
373
374////////////////////////////////////////////////////////////////////////////////
375/// Performs the operation: `this = this/(c1*f1)` .
376///
377/// This function is not implemented
378
380{
381 Error("Divide","Function not implemented for TProfile3D");
382 return kFALSE;
383}
384
385////////////////////////////////////////////////////////////////////////////////
386/// Divide this profile2D by h1.
387///
388/// `this = this/h1`
389///
390/// This function return kFALSE if the divide operation failed
391
393{
394 if (!h1) {
395 Error("Divide","Attempt to divide a non-existing profile2D");
396 return kFALSE;
397 }
399 Error("Divide","Attempt to divide a non-profile3D object");
400 return kFALSE;
401 }
402 TProfile3D *p1 = (TProfile3D*)h1;
403
404 // delete buffer if it is there since it will become invalid
405 if (fBuffer) BufferEmpty(1);
406
407// Check profile compatibility
408 Int_t nx = GetNbinsX();
409 if (nx != p1->GetNbinsX()) {
410 Error("Divide","Attempt to divide profiles with different number of bins");
411 return kFALSE;
412 }
413 Int_t ny = GetNbinsY();
414 if (ny != p1->GetNbinsY()) {
415 Error("Divide","Attempt to divide profiles with different number of bins");
416 return kFALSE;
417 }
418 Int_t nz = GetNbinsZ();
419 if (nz != p1->GetNbinsZ()) {
420 Error("Divide","Attempt to divide profiles with different number of bins");
421 return kFALSE;
422 }
423
424// Reset statistics
426
427// Loop on bins (including underflows/overflows)
428 Int_t bin,binx,biny,binz;
429 Double_t *cu1 = p1->GetW();
430 Double_t *er1 = p1->GetW2();
431 Double_t *en1 = p1->GetB();
432 Double_t c0,c1,w,u,x,y,z;
433 for (binx =0;binx<=nx+1;binx++) {
434 for (biny =0;biny<=ny+1;biny++) {
435 for (binz =0;binz<=nz+1;binz++) {
436 bin = GetBin(binx,biny,binz);
437 c0 = fArray[bin];
438 c1 = cu1[bin];
439 if (c1) w = c0/c1;
440 else w = 0;
441 fArray[bin] = w;
442 u = TMath::Abs(w);
443 x = fXaxis.GetBinCenter(binx);
444 y = fYaxis.GetBinCenter(biny);
445 z = fZaxis.GetBinCenter(binz);
446 fEntries++;
447 fTsumw += u;
448 fTsumw2 += u*u;
449 fTsumwx += u*x;
450 fTsumwx2 += u*x*x;
451 fTsumwy += u*y;
452 fTsumwy2 += u*y*y;
453 fTsumwxy += u*x*y;
454 fTsumwz += u;
455 fTsumwz2 += u*z;
456 fTsumwxz += u*x*z;
457 fTsumwyz += u*y*z;
458 fTsumwt += u;
459 fTsumwt2 += u*u;
460 Double_t e0 = fSumw2.fArray[bin];
461 Double_t e1 = er1[bin];
462 Double_t c12= c1*c1;
463 if (!c1) fSumw2.fArray[bin] = 0;
464 else fSumw2.fArray[bin] = (e0*c1*c1 + e1*c0*c0)/(c12*c12);
465 if (!en1[bin]) fBinEntries.fArray[bin] = 0;
466 else fBinEntries.fArray[bin] /= en1[bin];
467 }
468 }
469 }
470 // maintaining the correct sum of weights square is not supported when dividing
471 // bin error resulting from division of profile needs to be checked
472 if (fBinSumw2.fN) {
473 Warning("Divide","Cannot preserve during the division of profiles the sum of bin weight square");
474 fBinSumw2 = TArrayD();
475 }
476 return kTRUE;
477}
478
479////////////////////////////////////////////////////////////////////////////////
480/// Replace contents of this profile2D by the division of h1 by h2.
481///
482/// `this = c1*h1/(c2*h2)`
483///
484/// This function return kFALSE if the divide operation failed
485
487{
488 TString opt = option;
489 opt.ToLower();
490 Bool_t binomial = kFALSE;
491 if (opt.Contains("b")) binomial = kTRUE;
492 if (!h1 || !h2) {
493 Error("Divide","Attempt to divide a non-existing profile2D");
494 return kFALSE;
495 }
497 Error("Divide","Attempt to divide a non-profile2D object");
498 return kFALSE;
499 }
500 TProfile3D *p1 = (TProfile3D*)h1;
501 if (!h2->InheritsFrom(TProfile3D::Class())) {
502 Error("Divide","Attempt to divide a non-profile2D object");
503 return kFALSE;
504 }
505 TProfile3D *p2 = (TProfile3D*)h2;
506
507// Check histogram compatibility
508 Int_t nx = GetNbinsX();
509 if (nx != p1->GetNbinsX() || nx != p2->GetNbinsX()) {
510 Error("Divide","Attempt to divide profiles with different number of bins");
511 return kFALSE;
512 }
513 Int_t ny = GetNbinsY();
514 if (ny != p1->GetNbinsY() || ny != p2->GetNbinsY()) {
515 Error("Divide","Attempt to divide profiles with different number of bins");
516 return kFALSE;
517 }
518 Int_t nz = GetNbinsZ();
519 if (nz != p1->GetNbinsZ() || nz != p2->GetNbinsZ()) {
520 Error("Divide","Attempt to divide profiles with different number of bins");
521 return kFALSE;
522 }
523 if (!c2) {
524 Error("Divide","Coefficient of dividing profile cannot be zero");
525 return kFALSE;
526 }
527
528// Reset statistics
530
531// Loop on bins (including underflows/overflows)
532 Int_t bin,binx,biny,binz;
533 Double_t *cu1 = p1->GetW();
534 Double_t *cu2 = p2->GetW();
535 Double_t *er1 = p1->GetW2();
536 Double_t *er2 = p2->GetW2();
537 Double_t *en1 = p1->GetB();
538 Double_t *en2 = p2->GetB();
539 Double_t b1,b2,w,u,x,y,z,ac1,ac2;
540 ac1 = TMath::Abs(c1);
541 ac2 = TMath::Abs(c2);
542 for (binx =0;binx<=nx+1;binx++) {
543 for (biny =0;biny<=ny+1;biny++) {
544 for (binz =0;binz<=nz+1;binz++) {
545 bin = GetBin(binx,biny,binz);
546 b1 = cu1[bin];
547 b2 = cu2[bin];
548 if (b2) w = c1*b1/(c2*b2);
549 else w = 0;
550 fArray[bin] = w;
551 u = TMath::Abs(w);
552 x = fXaxis.GetBinCenter(binx);
553 y = fYaxis.GetBinCenter(biny);
554 z = fZaxis.GetBinCenter(biny);
555 fEntries++;
556 fTsumw += u;
557 fTsumw2 += u*u;
558 fTsumwx += u*x;
559 fTsumwx2 += u*x*x;
560 fTsumwy += u*y;
561 fTsumwy2 += u*y*y;
562 fTsumwxy += u*x*y;
563 fTsumwz += u*z;
564 fTsumwz2 += u*z*z;
565 fTsumwxz += u*x*z;
566 fTsumwyz += u*y*z;
567 fTsumwt += u;
568 fTsumwt2 += u*u;
569 Double_t e1 = er1[bin];
570 Double_t e2 = er2[bin];
571 //Double_t b22= b2*b2*d2;
572 Double_t b22= b2*b2*TMath::Abs(c2);
573 if (!b2) fSumw2.fArray[bin] = 0;
574 else {
575 if (binomial) {
576 fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/(c2*b2));
577 } else {
578 fSumw2.fArray[bin] = ac1*ac2*(e1*b2*b2 + e2*b1*b1)/(b22*b22);
579 }
580 }
581 if (!en2[bin]) fBinEntries.fArray[bin] = 0;
582 else fBinEntries.fArray[bin] = en1[bin]/en2[bin];
583 }
584 }
585 }
586 return kTRUE;
587}
588
589////////////////////////////////////////////////////////////////////////////////
590/// Fill a Profile3D histogram (no weights).
591
593{
594 if (fBuffer) return BufferFill(x,y,z,t,1);
595
596 Int_t bin,binx,biny,binz;
597
598 if (fTmin != fTmax) {
599 if (t <fTmin || t> fTmax || TMath::IsNaN(t) ) return -1;
600 }
601
602 fEntries++;
603 binx =fXaxis.FindBin(x);
604 biny =fYaxis.FindBin(y);
605 binz =fZaxis.FindBin(z);
606 if (binx <0 || biny <0 || binz<0) return -1;
607 bin = GetBin(binx,biny,binz);
608 AddBinContent(bin, t);
609 fSumw2.fArray[bin] += (Double_t)t*t;
610 fBinEntries.fArray[bin] += 1;
611 if (fBinSumw2.fN) fBinSumw2.fArray[bin] += 1;
612 if (binx == 0 || binx > fXaxis.GetNbins()) {
613 if (!GetStatOverflowsBehaviour()) return -1;
614 }
615 if (biny == 0 || biny > fYaxis.GetNbins()) {
616 if (!GetStatOverflowsBehaviour()) return -1;
617 }
618 if (binz == 0 || binz > fZaxis.GetNbins()) {
619 if (!GetStatOverflowsBehaviour()) return -1;
620 }
621//printf("x=%g, y=%g, z=%g, t=%g, binx=%d, biny=%d, binz=%d, bin=%d\n",x,y,z,t,binx,biny,binz,bin);
622 ++fTsumw;
623 ++fTsumw2;
624 fTsumwx += x;
625 fTsumwx2 += x*x;
626 fTsumwy += y;
627 fTsumwy2 += y*y;
628 fTsumwxy += x*y;
629 fTsumwz += z;
630 fTsumwz2 += z*z;
631 fTsumwxz += x*z;
632 fTsumwyz += y*z;
633 fTsumwt += t;
634 fTsumwt2 += t*t;
635 return bin;
636}
637
638////////////////////////////////////////////////////////////////////////////////
639/// Fill a Profile3D histogram with weights.
640
642{
643 if (fBuffer) return BufferFill(x,y,z,t,w);
644
645 Int_t bin,binx,biny,binz;
646
647 if (fTmin != fTmax) {
648 if (t <fTmin || t> fTmax || TMath::IsNaN(t) ) return -1;
649 }
650
651 Double_t u= w; // (w > 0 ? w : -w);
652 fEntries++;
653 binx =fXaxis.FindBin(x);
654 biny =fYaxis.FindBin(y);
655 binz =fZaxis.FindBin(z);
656 if (binx <0 || biny <0 || binz<0) return -1;
657 bin = GetBin(binx,biny,binz);
658 AddBinContent(bin, u*t);
659 fSumw2.fArray[bin] += u*t*t;
660 if (!fBinSumw2.fN && u != 1.0 && !TestBit(TH1::kIsNotW)) Sumw2(); // must be called before accumulating the entries
661 if (fBinSumw2.fN) fBinSumw2.fArray[bin] += u*u;
662 fBinEntries.fArray[bin] += u;
663 if (binx == 0 || binx > fXaxis.GetNbins()) {
664 if (!GetStatOverflowsBehaviour()) return -1;
665 }
666 if (biny == 0 || biny > fYaxis.GetNbins()) {
667 if (!GetStatOverflowsBehaviour()) return -1;
668 }
669 if (binz == 0 || binz > fZaxis.GetNbins()) {
670 if (!GetStatOverflowsBehaviour()) return -1;
671 }
672 fTsumw += u;
673 fTsumw2 += u*u;
674 fTsumwx += u*x;
675 fTsumwx2 += u*x*x;
676 fTsumwy += u*y;
677 fTsumwy2 += u*y*y;
678 fTsumwxy += u*x*y;
679 fTsumwz += u*z;
680 fTsumwz2 += u*z*z;
681 fTsumwxz += u*x*z;
682 fTsumwyz += u*y*z;
683 fTsumwt += u*t;
684 fTsumwt2 += u*t*t;
685 return bin;
686}
687
688////////////////////////////////////////////////////////////////////////////////
689/// Return bin content of a Profile3D histogram.
690
692{
693 if (fBuffer) ((TProfile3D*)this)->BufferEmpty();
694
695 if (bin < 0 || bin >= fNcells) return 0;
696 if (fBinEntries.fArray[bin] == 0) return 0;
697 if (!fArray) return 0;
698 return fArray[bin]/fBinEntries.fArray[bin];
699}
700
701////////////////////////////////////////////////////////////////////////////////
702/// Return bin entries of a Profile3D histogram.
703
705{
706 if (fBuffer) ((TProfile3D*)this)->BufferEmpty();
707
708 if (bin < 0 || bin >= fNcells) return 0;
709 return fBinEntries.fArray[bin];
710}
711
712////////////////////////////////////////////////////////////////////////////////
713/// Return bin effective entries for a weighted filled Profile histogram.
714///
715/// In case of an unweighted profile, it is equivalent to the number of entries per bin
716/// The effective entries is defined as the square of the sum of the weights divided by the
717/// sum of the weights square.
718/// TProfile::Sumw2() must be called before filling the profile with weights.
719/// Only by calling this method the sum of the square of the weights per bin is stored.
720
722{
724}
725
726////////////////////////////////////////////////////////////////////////////////
727/// Return bin error of a Profile3D histogram.
728///
729/// ### Computing errors: A moving field
730///
731/// The computation of errors for a TProfile3D has evolved with the versions
732/// of ROOT. The difficulty is in computing errors for bins with low statistics.
733///
734/// - prior to version 3.10, we had no special treatment of low statistic bins.
735/// As a result, these bins had huge errors. The reason is that the
736/// expression eprim2 is very close to 0 (rounding problems) or 0.
737/// - The algorithm is modified/protected for the case
738/// when a TProfile3D is projected (ProjectionX). The previous algorithm
739/// generated a N^2 problem when projecting a TProfile3D with a large number of
740/// bins (eg 100000).
741/// - in version 3.10/02, a new static function TProfile::Approximate
742/// is introduced to enable or disable (default) the approximation.
743/// (see also comments in TProfile::GetBinError)
744
746{
747 return TProfileHelper::GetBinError((TProfile3D*)this, bin);
748}
749
750////////////////////////////////////////////////////////////////////////////////
751/// Return option to compute profile2D errors.
752
754{
755 if (fErrorMode == kERRORSPREAD) return "s";
756 if (fErrorMode == kERRORSPREADI) return "i";
757 if (fErrorMode == kERRORSPREADG) return "g";
758 return "";
759}
760
761////////////////////////////////////////////////////////////////////////////////
762/// fill the array stats from the contents of this profile.
763///
764/// The array stats must be correctly dimensionned in the calling program.
765///
766/// - stats[0] = sumw
767/// - stats[1] = sumw2
768/// - stats[2] = sumwx
769/// - stats[3] = sumwx2
770/// - stats[4] = sumwy
771/// - stats[5] = sumwy2
772/// - stats[6] = sumwxy
773/// - stats[7] = sumwz
774/// - stats[8] = sumwz2
775/// - stats[9] = sumwxz
776/// - stats[10]= sumwyz
777/// - stats[11]= sumwt
778/// - stats[12]= sumwt2
779///
780/// If no axis-subrange is specified (via TAxis::SetRange), the array stats
781/// is simply a copy of the statistics quantities computed at filling time.
782/// If a sub-range is specified, the function recomputes these quantities
783/// from the bin contents in the current axis range.
784
786{
787 if (fBuffer) ((TProfile3D*)this)->BufferEmpty();
788
789 // Loop on bins
791 Int_t bin, binx, biny,binz;
792 Double_t w, w2;
793 Double_t x,y,z;
794 for (bin=0;bin<kNstat;bin++) stats[bin] = 0;
795 if (!fBinEntries.fArray) return;
796 for (binz=fZaxis.GetFirst();binz<=fZaxis.GetLast();binz++) {
797 z = fZaxis.GetBinCenter(binz);
798 for (biny=fYaxis.GetFirst();biny<=fYaxis.GetLast();biny++) {
799 y = fYaxis.GetBinCenter(biny);
800 for (binx=fXaxis.GetFirst();binx<=fXaxis.GetLast();binx++) {
801 bin = GetBin(binx,biny,binz);
802 w = fBinEntries.fArray[bin];
803 w2 = (fBinSumw2.fN ? fBinSumw2.fArray[bin] : w );
804 x = fXaxis.GetBinCenter(binx);
805 stats[0] += w;
806 stats[1] += w2;
807 stats[2] += w*x;
808 stats[3] += w*x*x;
809 stats[4] += w*y;
810 stats[5] += w*y*y;
811 stats[6] += w*x*y;
812 stats[7] += w*z;
813 stats[8] += w*z*z;
814 stats[9] += w*x*z;
815 stats[10] += w*y*z;
816 stats[11] += fArray[bin];
817 stats[12] += fSumw2.fArray[bin];
818 }
819 }
820 }
821 } else {
822 stats[0] = fTsumw;
823 stats[1] = fTsumw2;
824 stats[2] = fTsumwx;
825 stats[3] = fTsumwx2;
826 stats[4] = fTsumwy;
827 stats[5] = fTsumwy2;
828 stats[6] = fTsumwxy;
829 stats[7] = fTsumwz;
830 stats[8] = fTsumwz2;
831 stats[9] = fTsumwxz;
832 stats[10] = fTsumwyz;
833 stats[11] = fTsumwt;
834 stats[12] = fTsumwt2;
835 }
836}
837
838////////////////////////////////////////////////////////////////////////////////
839/// Merge all histograms in the collection in this histogram.
840///
841/// This function computes the min/max for the axes,
842/// compute a new number of bins, if necessary,
843/// add bin contents, errors and statistics.
844/// If overflows are present and limits are different the function will fail.
845/// The function returns the total number of entries in the result histogram
846/// if the merge is successful, -1 otherwise.
847///
848/// IMPORTANT remark. The 2 axis x and y may have different number
849/// of bins and different limits, BUT the largest bin width must be
850/// a multiple of the smallest bin width and the upper limit must also
851/// be a multiple of the bin width.
852
854{
855 return TProfileHelper::Merge(this, li);
856}
857
858////////////////////////////////////////////////////////////////////////////////
859/// Performs the operation: `this = this*c1*f1` .
860
862{
863 Error("Multiply","Function not implemented for TProfile3D");
864 return kFALSE;
865}
866
867////////////////////////////////////////////////////////////////////////////////
868/// Multiply this profile2D by h1.
869///
870/// `this = this*h1`
871
873{
874 Error("Multiply","Multiplication of profile2D histograms not implemented");
875 return kFALSE;
876}
877
878////////////////////////////////////////////////////////////////////////////////
879/// Replace contents of this profile2D by multiplication of h1 by h2.
880///
881/// `this = (c1*h1)*(c2*h2)`
882
884{
885 Error("Multiply","Multiplication of profile2D histograms not implemented");
886 return kFALSE;
887}
888
889////////////////////////////////////////////////////////////////////////////////
890/// Project this profile3D into a 3-D histogram along X,Y,Z.
891///
892/// The projection is always of the type TH3D.
893///
894/// - if option "E" is specified, the errors are computed. (default)
895/// - if option "B" is specified, the content of bin of the returned histogram
896/// will be equal to the GetBinEntries(bin) of the profile,
897/// - if option "C=E" the bin contents of the projection are set to the
898/// bin errors of the profile
899/// - if option "E" is specified the errors of the projected histogram are computed and set
900/// to be equal to the errors of the profile.
901/// Option "E" is defined as the default one in the header file.
902/// - if option "" is specified the histogram errors are simply the sqrt of its content
903/// - if option "B" is specified, the content of bin of the returned histogram
904/// will be equal to the GetBinEntries(bin) of the profile,
905/// - if option "C=E" the bin contents of the projection are set to the
906/// bin errors of the profile
907/// - if option "W" is specified the bin content of the projected histogram is set to the
908/// product of the bin content of the profile and the entries.
909/// With this option the returned histogram will be equivalent to the one obtained by
910/// filling directly a TH2D using the 3-rd value as a weight.
911/// This option makes sense only for profile filled with all weights =1.
912/// When the profile is weighted (filled with weights different than 1) the
913/// bin error of the projected histogram (obtained using this option "W") cannot be
914/// correctly computed from the information stored in the profile. In that case the
915/// obtained histogram contains as bin error square the weighted sum of the square of the
916/// profiled observable (TProfile2D::fSumw2[bin] )
917///
918/// Note that the axis range is not considered when doing the projection
919
920TH3D *TProfile3D::ProjectionXYZ(const char *name, Option_t *option) const
921{
922
923 TString opt = option;
924 opt.ToLower();
925 Int_t nx = fXaxis.GetNbins();
926 Int_t ny = fYaxis.GetNbins();
927 Int_t nz = fZaxis.GetNbins();
928 const TArrayD *xbins = fXaxis.GetXbins();
929 const TArrayD *ybins = fYaxis.GetXbins();
930 const TArrayD *zbins = fZaxis.GetXbins();
931
932 // Create the projection histogram
933 TString pname = name;
934 if (pname == "_px") {
935 pname = GetName(); pname.Append("_pxyz");
936 }
937 TH3D *h1 = 0 ;
938 if (xbins->fN == 0 && ybins->fN == 0 && zbins->fN == 0)
940 else if ( xbins->fN != 0 && ybins->fN != 0 && zbins->fN != 0)
941 h1 = new TH3D(pname,GetTitle(),nx,xbins->GetArray(),ny,ybins->GetArray(), nz,zbins->GetArray() );
942 else {
943 Error("ProjectionXYZ","Histogram has an axis with variable bins and an axis with fixed bins. This case is not supported - return a null pointer");
944 return 0;
945 }
946
947
948 Bool_t computeErrors = kFALSE;
949 Bool_t cequalErrors = kFALSE;
950 Bool_t binEntries = kFALSE;
951 Bool_t binWeight = kFALSE;
952
953 if (opt.Contains("b")) binEntries = kTRUE;
954 if (opt.Contains("e")) computeErrors = kTRUE;
955 if (opt.Contains("w")) binWeight = kTRUE;
956 if (opt.Contains("c=e")) {cequalErrors = kTRUE; computeErrors=kFALSE;}
957 if (computeErrors || binWeight || (binEntries && fBinSumw2.fN) ) h1->Sumw2();
958
959 // Fill the projected histogram
960 Int_t bin,binx,biny,binz;
961 Double_t cont;
962 for (binx =0;binx<=nx+1;binx++) {
963 for (biny =0;biny<=ny+1;biny++) {
964 for (binz =0;binz<=nz+1;binz++) {
965 bin = GetBin(binx,biny,binz);
966
967 if (binEntries) cont = GetBinEntries(bin);
968 else if (cequalErrors) cont = GetBinError(bin);
969 else if (binWeight) cont = GetBinContent(bin) * GetBinEntries(bin);
970 else cont = GetBinContent(bin); // default case
971
972 h1->SetBinContent(bin ,cont);
973
974 // if option E projected histogram errors are same as profile
975 if (computeErrors ) h1->SetBinError(bin , GetBinError(bin) );
976 // in case of option W bin error is deduced from bin sum of z**2 values of profile
977 // this is correct only if the profile is unweighted
978 if (binWeight) h1->GetSumw2()->fArray[bin] = fSumw2.fArray[bin];
979 // in case of bin entries and profile is weighted, we need to set also the bin error
980 if (binEntries && fBinSumw2.fN ) {
981 R__ASSERT( h1->GetSumw2() );
982 h1->GetSumw2()->fArray[bin] = fBinSumw2.fArray[bin];
983 }
984 }
985 }
986 }
988 return h1;
989}
990////////////////////////////////////////////////////////////////////////////////
991/// Project a 3-D profile into a 2D-profile histogram depending on the option parameter.
992///
993/// option may contain a combination of the characters x,y,z:
994///
995/// - option = "xy" return the x versus y projection into a TProfile2D histogram
996/// - option = "yx" return the y versus x projection into a TProfile2D histogram
997/// - option = "xz" return the x versus z projection into a TProfile2D histogram
998/// - option = "zx" return the z versus x projection into a TProfile2D histogram
999/// - option = "yz" return the y versus z projection into a TProfile2D histogram
1000/// - option = "zy" return the z versus y projection into a TProfile2D histogram
1001///
1002/// NB: the notation "a vs b" means "a" vertical and "b" horizontal along X
1003///
1004/// The resulting profile contains the combination of all the considered bins along X
1005/// By default, all bins are included considering also underflow/overflows
1006///
1007/// The option can also be used to specify the projected profile error type.
1008/// Values which can be used are 's', 'i', or 'g'. See TProfile::BuildOptions for details
1009///
1010/// To select a bin range along an axis, use TAxis::SetRange, eg
1011/// `h3.GetYaxis()->SetRange(23,56);`
1012
1014{
1015 // can call TH3 method which will call the virtual method :DoProjectProfile2D re-implemented below
1016 // but need to add underflow/overflow
1017 TString opt(option);
1018 opt.Append(" UF OF");
1019 return TH3::Project3DProfile(opt);
1020}
1021
1022////////////////////////////////////////////////////////////////////////////////
1023/// Internal method to project to a 2D Profile.
1024///
1025/// Called from TH3::Project3DProfile but re-implemented in case of the TPRofile3D
1026/// since what is done is different.
1027
1028TProfile2D *TProfile3D::DoProjectProfile2D(const char* name, const char * title, const TAxis* projX, const TAxis* projY,
1029 bool originalRange, bool useUF, bool useOF) const
1030{
1031 // Get the ranges where we will work.
1032 Int_t ixmin = projX->GetFirst();
1033 Int_t ixmax = projX->GetLast();
1034 Int_t iymin = projY->GetFirst();
1035 Int_t iymax = projY->GetLast();
1036 if (ixmin == 0 && ixmax == 0) { ixmin = 1; ixmax = projX->GetNbins(); }
1037 if (iymin == 0 && iymax == 0) { iymin = 1; iymax = projY->GetNbins(); }
1038 Int_t nx = ixmax-ixmin+1;
1039 Int_t ny = iymax-iymin+1;
1040
1041 // Create the projected profiles
1042 TProfile2D *p2 = 0;
1043 // Create always a new TProfile2D (not as in the case of TH3 projection)
1044
1045 const TArrayD *xbins = projX->GetXbins();
1046 const TArrayD *ybins = projY->GetXbins();
1047 // assume all axis have variable bins or have fixed bins
1048 if ( originalRange ) {
1049 if (xbins->fN == 0 && ybins->fN == 0) {
1050 p2 = new TProfile2D(name,title,projY->GetNbins(),projY->GetXmin(),projY->GetXmax()
1051 ,projX->GetNbins(),projX->GetXmin(),projX->GetXmax());
1052 } else {
1053 p2 = new TProfile2D(name,title,projY->GetNbins(),&ybins->fArray[iymin-1],projX->GetNbins(),&xbins->fArray[ixmin-1]);
1054 }
1055 } else {
1056 if (xbins->fN == 0 && ybins->fN == 0) {
1057 p2 = new TProfile2D(name,title,ny,projY->GetBinLowEdge(iymin),projY->GetBinUpEdge(iymax)
1058 ,nx,projX->GetBinLowEdge(ixmin),projX->GetBinUpEdge(ixmax));
1059 } else {
1060 p2 = new TProfile2D(name,title,ny,&ybins->fArray[iymin-1],nx,&xbins->fArray[ixmin-1]);
1061 }
1062 }
1063
1064 // weights
1065 bool useWeights = (fBinSumw2.fN != 0);
1066 if (useWeights) p2->Sumw2();
1067
1068 // make projection in a 3D first
1069 TH3D * h3dW = ProjectionXYZ("h3temp-W","W");
1070 TH3D * h3dN = ProjectionXYZ("h3temp-N","B");
1071
1072 h3dW->SetDirectory(0); h3dN->SetDirectory(0);
1073
1074 // Since no axis range is considered when doing the projection TProfile3D->TH3D
1075 // the resulting histogram will have the same axis as the parent one
1076 // we need afterwards to set the range in the 3D histogram to considered it later
1077 // when doing the projection in a Profile2D
1081 }
1085 }
1089 }
1090
1091 // note that h3dW is always a weighted histogram - so we need to compute error in the projection
1092 TAxis * projX_hW = h3dW->GetXaxis();
1093 TAxis * projX_hN = h3dN->GetXaxis();
1094 if (projX == GetYaxis() ) { projX_hW = h3dW->GetYaxis(); projX_hN = h3dN->GetYaxis(); }
1095 if (projX == GetZaxis() ) { projX_hW = h3dW->GetZaxis(); projX_hN = h3dN->GetZaxis(); }
1096 TAxis * projY_hW = h3dW->GetYaxis();
1097 TAxis * projY_hN = h3dN->GetYaxis();
1098 if (projY == GetXaxis() ) { projY_hW = h3dW->GetXaxis(); projY_hN = h3dN->GetXaxis(); }
1099 if (projY == GetZaxis() ) { projY_hW = h3dW->GetZaxis(); projY_hN = h3dN->GetZaxis(); }
1100
1101 TH2D * h2W = TH3::DoProject2D(*h3dW,"htemp-W","",projX_hW, projY_hW, true, originalRange, useUF, useOF);
1102 TH2D * h2N = TH3::DoProject2D(*h3dN,"htemp-N","",projX_hN, projY_hN, useWeights, originalRange, useUF, useOF);
1103 h2W->SetDirectory(0); h2N->SetDirectory(0);
1104
1105
1106 // fill the bin content
1107 R__ASSERT( h2W->fN == p2->fN );
1108 R__ASSERT( h2N->fN == p2->fN );
1109 R__ASSERT( h2W->GetSumw2()->fN != 0); // h2W should always be a weighted histogram since h3dW is weighted
1110 for (int i = 0; i < p2->fN ; ++i) {
1111 //std::cout << " proj bin " << i << " " << h2W->fArray[i] << " " << h2N->fArray[i] << std::endl;
1112 p2->fArray[i] = h2W->fArray[i]; // array of profile is sum of all values
1113 p2->GetSumw2()->fArray[i] = h2W->GetSumw2()->fArray[i]; // array of content square of profile is weight square of the W projected histogram
1114 p2->SetBinEntries(i, h2N->fArray[i] );
1115 if (useWeights) p2->GetBinSumw2()->fArray[i] = h2N->GetSumw2()->fArray[i]; // sum of weight squares are stored to compute errors in h1N histogram
1116 }
1117 // delete the created histograms
1118 delete h3dW;
1119 delete h3dN;
1120 delete h2W;
1121 delete h2N;
1122
1123 // Also we need to set the entries since they have not been correctly calculated during the projection
1124 // we can only set them to the effective entries
1125 p2->SetEntries( p2->GetEffectiveEntries() );
1126
1127 return p2;
1128
1129}
1130
1131////////////////////////////////////////////////////////////////////////////////
1132/// Replace current statistics with the values in array stats.
1133
1135{
1136 TH3::PutStats(stats);
1137 fTsumwt = stats[11];
1138 fTsumwt2 = stats[12];
1139}
1140
1141////////////////////////////////////////////////////////////////////////////////
1142/// Reset contents of a Profile3D histogram.
1143
1145{
1146 TH3D::Reset(option);
1147 fBinSumw2.Reset();
1149 TString opt = option;
1150 opt.ToUpper();
1151 if (opt.Contains("ICE") && !opt.Contains("S")) return;
1152 fTsumwt = fTsumwt2 = 0;
1153}
1154
1155////////////////////////////////////////////////////////////////////////////////
1156/// Profile histogram is resized along axis such that x is in the axis range.
1157/// The new axis limits are recomputed by doubling iteratively
1158/// the current axis range until the specified value x is within the limits.
1159/// The algorithm makes a copy of the histogram, then loops on all bins
1160/// of the old histogram to fill the rebinned histogram.
1161/// Takes into account errors (Sumw2) if any.
1162/// The axis must be rebinnable before invoking this function.
1163/// Ex: `h->GetXaxis()->SetCanExtend(kTRUE)`
1164
1166{
1167 TProfile3D* hold = TProfileHelper::ExtendAxis(this, x, axis);
1168 if ( hold ) {
1169 fTsumwt = hold->fTsumwt;
1170 fTsumwt2 = hold->fTsumwt2;
1171 delete hold;
1172 }
1173}
1174
1175////////////////////////////////////////////////////////////////////////////////
1176/// Save primitive as a C++ statement(s) on output stream out.
1177///
1178/// Note the following restrictions in the code generated:
1179/// - variable bin size not implemented
1180/// - SetErrorOption not implemented
1181
1182void TProfile3D::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
1183{
1184 char quote = '"';
1185 out <<" "<<std::endl;
1186 out <<" "<<ClassName()<<" *";
1187
1188 out << GetName() << " = new " << ClassName() << "(" << quote
1189 << GetName() << quote << "," << quote<< GetTitle() << quote
1190 << "," << GetXaxis()->GetNbins();
1191 out << "," << GetXaxis()->GetXmin()
1192 << "," << GetXaxis()->GetXmax();
1193 out << "," << GetYaxis()->GetNbins();
1194 out << "," << GetYaxis()->GetXmin()
1195 << "," << GetYaxis()->GetXmax();
1196 out << "," << GetZaxis()->GetNbins();
1197 out << "," << GetZaxis()->GetXmin()
1198 << "," << GetZaxis()->GetXmax();
1199 out << "," << fTmin
1200 << "," << fTmax;
1201 out << ");" << std::endl;
1202
1203
1204 // save bin entries
1205 Int_t bin;
1206 for (bin=0;bin<fNcells;bin++) {
1207 Double_t bi = GetBinEntries(bin);
1208 if (bi) {
1209 out<<" "<<GetName()<<"->SetBinEntries("<<bin<<","<<bi<<");"<<std::endl;
1210 }
1211 }
1212 //save bin contents
1213 for (bin=0;bin<fNcells;bin++) {
1214 Double_t bc = fArray[bin];
1215 if (bc) {
1216 out<<" "<<GetName()<<"->SetBinContent("<<bin<<","<<bc<<");"<<std::endl;
1217 }
1218 }
1219 // save bin errors
1220 if (fSumw2.fN) {
1221 for (bin=0;bin<fNcells;bin++) {
1222 Double_t be = TMath::Sqrt(fSumw2.fArray[bin]);
1223 if (be) {
1224 out<<" "<<GetName()<<"->SetBinError("<<bin<<","<<be<<");"<<std::endl;
1225 }
1226 }
1227 }
1228
1229 TH1::SavePrimitiveHelp(out, GetName(), option);
1230}
1231
1232////////////////////////////////////////////////////////////////////////////////
1233/// Multiply this profile2D by a constant c1.
1234///
1235/// `this = c1*this`
1236///
1237/// This function uses the services of TProfile3D::Add
1238
1240{
1241 TProfileHelper::Scale(this, c1, option);
1242}
1243
1244////////////////////////////////////////////////////////////////////////////////
1245///Set the number of entries in bin.
1246
1248{
1249 TProfileHelper::SetBinEntries(this, bin, w);
1250}
1251
1252////////////////////////////////////////////////////////////////////////////////
1253/// Redefine x, y and z axis parameters.
1254
1256{
1257 TH1::SetBins(nx, xmin, xmax, ny, ymin, ymax, nz, zmin, zmax);
1260}
1261
1262////////////////////////////////////////////////////////////////////////////////
1263/// Redefine x, y and z axis parameters with variable bin sizes
1264
1265void TProfile3D::SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins, Int_t nz, const Double_t *zBins)
1266{
1267 TH1::SetBins(nx,xBins,ny,yBins,nz,zBins);
1270}
1271
1272////////////////////////////////////////////////////////////////////////////////
1273/// Set total number of bins including under/overflow.
1274///
1275/// Reallocate bin contents array
1276
1278{
1281}
1282
1283////////////////////////////////////////////////////////////////////////////////
1284/// Set the buffer size in units of 8 bytes (double).
1285
1287{
1288 if (fBuffer) {
1289 BufferEmpty();
1290 delete [] fBuffer;
1291 fBuffer = 0;
1292 }
1293 if (buffersize <= 0) {
1294 fBufferSize = 0;
1295 return;
1296 }
1297 if (buffersize < 100) buffersize = 100;
1298 fBufferSize = 1 + 5*buffersize;
1300 memset(fBuffer,0,sizeof(Double_t)*fBufferSize);
1301}
1302
1303////////////////////////////////////////////////////////////////////////////////
1304/// Set option to compute profile3D errors.
1305///
1306/// The computation of the bin errors is based on the parameter option:
1307/// - ' ' (Default) The bin errors are the standard error on the mean of the bin profiled values (T),
1308/// i.e. the standard error of the bin contents.
1309/// Note that if TProfile3D::Approximate() is called, an approximation is used when
1310/// the spread in T is 0 and the number of bin entries is > 0
1311/// - 's' The bin errors are the standard deviations of the T bin values
1312/// Note that if TProfile3D::Approximate() is called, an approximation is used when
1313/// the spread in T is 0 and the number of bin entries is > 0
1314/// - 'i' Errors are as in default case (standard errors of the bin contents)
1315/// The only difference is for the case when the spread in T is zero.
1316/// In this case for N > 0 the error is 1./SQRT(12.*N)
1317/// - 'g' Errors are 1./SQRT(W) for W not equal to 0 and 0 for W = 0.
1318/// W is the sum in the bin of the weights of the profile.
1319/// This option is for combining measurements t +/- dt,
1320/// and the profile is filled with values t and weights w = 1/dt**2
1321///
1322/// See TProfile::BuildOptions for explanation of all options
1323
1325{
1326 TProfileHelper::SetErrorOption(this, option);
1327}
1328
1329////////////////////////////////////////////////////////////////////////////////
1330/// Create/Delete structure to store sum of squares of weights per bin
1331/// This is needed to compute the correct statistical quantities
1332/// of a profile filled with weights
1333///
1334/// This function is automatically called when the histogram is created
1335/// if the static function TH1::SetDefaultSumw2 has been called before.
1336/// If flag = false the structure is deleted
1337
1339{
1340 TProfileHelper::Sumw2(this, flag);
1341}
void Class()
Definition: Class.C:29
int Int_t
Definition: RtypesCore.h:43
const Bool_t kFALSE
Definition: RtypesCore.h:90
bool Bool_t
Definition: RtypesCore.h:61
double Double_t
Definition: RtypesCore.h:57
long long Long64_t
Definition: RtypesCore.h:71
const Bool_t kTRUE
Definition: RtypesCore.h:89
const char Option_t
Definition: RtypesCore.h:64
#define ClassImp(name)
Definition: Rtypes.h:361
#define R__ASSERT(e)
Definition: TError.h:96
char name[80]
Definition: TGX11.cxx:109
float xmin
Definition: THbookFile.cxx:93
float ymin
Definition: THbookFile.cxx:93
float xmax
Definition: THbookFile.cxx:93
float ymax
Definition: THbookFile.cxx:93
@ kERRORSPREAD
Definition: TProfile.h:28
@ kERRORSPREADG
Definition: TProfile.h:28
@ kERRORSPREADI
Definition: TProfile.h:28
Array of doubles (64 bits per element).
Definition: TArrayD.h:27
Double_t * fArray
Definition: TArrayD.h:30
void Copy(TArrayD &array) const
Definition: TArrayD.h:42
void Set(Int_t n)
Set size of this array to n doubles.
Definition: TArrayD.cxx:106
TArrayD()
Default TArrayD ctor.
Definition: TArrayD.cxx:26
const Double_t * GetArray() const
Definition: TArrayD.h:43
void Reset()
Definition: TArrayD.h:47
Int_t fN
Definition: TArray.h:38
Class to manage histogram axis.
Definition: TAxis.h:30
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition: TAxis.cxx:475
const TArrayD * GetXbins() const
Definition: TAxis.h:130
Double_t GetXmax() const
Definition: TAxis.h:134
@ kAxisRange
Definition: TAxis.h:61
virtual Int_t FindBin(Double_t x)
Find bin number corresponding to abscissa x.
Definition: TAxis.cxx:290
virtual Double_t GetBinLowEdge(Int_t bin) const
Return low edge of bin.
Definition: TAxis.cxx:515
Int_t GetLast() const
Return last bin on the axis i.e.
Definition: TAxis.cxx:466
Double_t GetXmin() const
Definition: TAxis.h:133
Int_t GetNbins() const
Definition: TAxis.h:121
virtual void SetRange(Int_t first=0, Int_t last=0)
Set the viewing range for the axis from bin first to last.
Definition: TAxis.cxx:914
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition: TAxis.cxx:525
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition: TAxis.cxx:455
Collection abstract base class.
Definition: TCollection.h:63
1-Dim function class
Definition: TF1.h:210
The TH1 histogram class.
Definition: TH1.h:56
virtual void SetDirectory(TDirectory *dir)
By default when an histogram is created, it is added to the list of histogram objects in the current ...
Definition: TH1.cxx:8393
Double_t * fBuffer
[fBufferSize] entry buffer
Definition: TH1.h:105
virtual Double_t GetEffectiveEntries() const
Number of effective entries of the histogram.
Definition: TH1.cxx:4327
TAxis * GetZaxis()
Definition: TH1.h:318
Int_t fNcells
number of bins(1D), cells (2D) +U/Overflows
Definition: TH1.h:86
Double_t fTsumw
Total Sum of weights.
Definition: TH1.h:93
Double_t fTsumw2
Total Sum of squares of weights.
Definition: TH1.h:94
Double_t fTsumwx2
Total Sum of weight*X*X.
Definition: TH1.h:96
virtual Int_t GetNbinsY() const
Definition: TH1.h:293
virtual Int_t GetNbinsZ() const
Definition: TH1.h:294
@ kIsNotW
Histogram is forced to be not weighted even when the histogram is filled with weighted different than...
Definition: TH1.h:167
virtual Bool_t CanExtendAllAxes() const
Returns true if all axes are extendable.
Definition: TH1.cxx:6278
TAxis * GetXaxis()
Get the behaviour adopted by the object about the statoverflows. See EStatOverflows for more informat...
Definition: TH1.h:316
virtual Int_t GetNbinsX() const
Definition: TH1.h:292
Int_t fBufferSize
fBuffer size
Definition: TH1.h:104
virtual void SetBinError(Int_t bin, Double_t error)
Set the bin Error Note that this resets the bin eror option to be of Normal Type and for the non-empt...
Definition: TH1.cxx:8662
static Int_t fgBufferSize
!default buffer size for automatic histograms
Definition: TH1.h:112
TAxis * GetYaxis()
Definition: TH1.h:317
virtual void SavePrimitiveHelp(std::ostream &out, const char *hname, Option_t *option="")
Helper function for the SavePrimitive functions from TH1 or classes derived from TH1,...
Definition: TH1.cxx:6931
virtual void SetBinContent(Int_t bin, Double_t content)
Set bin content see convention for numbering bins in TH1::GetBin In case the bin number is greater th...
Definition: TH1.cxx:8678
@ kNstat
Definition: TH1.h:179
Double_t fEntries
Number of entries.
Definition: TH1.h:92
TAxis fZaxis
Z axis descriptor.
Definition: TH1.h:89
virtual TArrayD * GetSumw2()
Definition: TH1.h:308
TAxis fXaxis
X axis descriptor.
Definition: TH1.h:87
TArrayD fSumw2
Array of sum of squares of weights.
Definition: TH1.h:101
Bool_t GetStatOverflowsBehaviour() const
Definition: TH1.h:148
TAxis fYaxis
Y axis descriptor.
Definition: TH1.h:88
virtual void SetBins(Int_t nx, Double_t xmin, Double_t xmax)
Redefine x axis parameters.
Definition: TH1.cxx:8223
virtual void Sumw2(Bool_t flag=kTRUE)
Create structure to store sum of squares of weights.
Definition: TH1.cxx:8476
virtual void SetEntries(Double_t n)
Definition: TH1.h:381
Double_t fTsumwx
Total Sum of weight*X.
Definition: TH1.h:95
2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:292
3-D histogram with a double per channel (see TH1 documentation)}
Definition: TH3.h:304
virtual void SetBinsLength(Int_t n=-1)
Set total number of bins including under/overflow Reallocate bin contents array.
Definition: TH3.cxx:4289
TH3D()
Constructor.
Definition: TH3.cxx:4200
virtual void AddBinContent(Int_t bin)
Increment bin content by 1.
Definition: TH3.h:318
virtual void Copy(TObject &hnew) const
Copy this 3-D histogram structure to newth3.
Definition: TH3.cxx:4268
Double_t fTsumwy
Definition: TH3.h:34
Double_t fTsumwy2
Definition: TH3.h:35
virtual TH2D * DoProject2D(const char *name, const char *title, const TAxis *projX, const TAxis *projY, bool computeErrors, bool originalRange, bool useUF, bool useOF) const
internal method performing the projection to a 2D histogram called from TH3::Project3D
Definition: TH3.cxx:1924
Double_t fTsumwxz
Definition: TH3.h:39
virtual Int_t GetBin(Int_t binx, Int_t biny, Int_t binz) const
See comments in TH1::GetBin.
Definition: TH3.cxx:949
virtual TProfile2D * Project3DProfile(Option_t *option="xy") const
Project a 3-d histogram into a 2-d profile histograms depending on the option parameter option may co...
Definition: TH3.cxx:2590
Double_t fTsumwz2
Definition: TH3.h:38
Double_t fTsumwxy
Definition: TH3.h:36
virtual void PutStats(Double_t *stats)
Replace current statistics with the values in array stats.
Definition: TH3.cxx:2673
Double_t fTsumwz
Definition: TH3.h:37
Double_t fTsumwyz
Definition: TH3.h:40
static THLimitsFinder * GetLimitsFinder()
Return pointer to the current finder.
virtual Int_t FindGoodLimits(TH1 *h, Double_t xmin, Double_t xmax)
Compute the best axis limits for the X axis.
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
Mother of all ROOT objects.
Definition: TObject.h:37
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:357
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:128
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:877
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:443
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:891
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:919
Profile2D histograms are used to display the mean value of Z and its RMS for each cell in X,...
Definition: TProfile2D.h:27
virtual void SetBinEntries(Int_t bin, Double_t w)
Set the number of entries in bin.
virtual void Sumw2(Bool_t flag=kTRUE)
Create/Delete structure to store sum of squares of weights per bin.
virtual TArrayD * GetBinSumw2()
Definition: TProfile2D.h:115
Profile3D histograms are used to display the mean value of T and its RMS for each cell in X,...
Definition: TProfile3D.h:27
TProfile3D & operator=(const TProfile3D &profile)
Definition: TProfile3D.cxx:163
virtual TProfile2D * DoProjectProfile2D(const char *name, const char *title, const TAxis *projX, const TAxis *projY, bool originalRange, bool useUF, bool useOF) const
Internal method to project to a 2D Profile.
Double_t * GetW()
Definition: TProfile3D.h:74
virtual void Sumw2(Bool_t flag=kTRUE)
Create/Delete structure to store sum of squares of weights per bin This is needed to compute the corr...
virtual void ExtendAxis(Double_t x, TAxis *axis)
Profile histogram is resized along axis such that x is in the axis range.
static Bool_t fgApproximate
Definition: TProfile3D.h:41
virtual void SetBuffer(Int_t buffersize, Option_t *opt="")
Set the buffer size in units of 8 bytes (double).
virtual Int_t BufferEmpty(Int_t action=0)
Fill histogram with all entries in the buffer.
Definition: TProfile3D.cxx:246
virtual Long64_t Merge(TCollection *list)
Merge all histograms in the collection in this histogram.
Definition: TProfile3D.cxx:853
Option_t * GetErrorOption() const
Return option to compute profile2D errors.
Definition: TProfile3D.cxx:753
Bool_t fScaling
Definition: TProfile3D.h:37
void SetBins(const Int_t *nbins, const Double_t *range)
Definition: TProfile3D.h:49
virtual Double_t GetBinError(Int_t bin) const
Return bin error of a Profile3D histogram.
Definition: TProfile3D.cxx:745
Double_t fTsumwt2
Definition: TProfile3D.h:39
virtual Double_t GetBinEffectiveEntries(Int_t bin)
Return bin effective entries for a weighted filled Profile histogram.
Definition: TProfile3D.cxx:721
virtual Bool_t Add(TF1 *h1, Double_t c1=1, Option_t *option="")
Performs the operation: this = this + c1*f1 .
Definition: TProfile3D.cxx:172
virtual void GetStats(Double_t *stats) const
fill the array stats from the contents of this profile.
Definition: TProfile3D.cxx:785
TProfile3D()
Default constructor for Profile3D histograms.
Definition: TProfile3D.cxx:77
TArrayD fBinEntries
Definition: TProfile3D.h:33
virtual Double_t GetBinContent(Int_t bin) const
Return bin content of a Profile3D histogram.
Definition: TProfile3D.cxx:691
virtual void Scale(Double_t c1=1, Option_t *option="")
Multiply this profile2D by a constant c1.
virtual Bool_t Multiply(TF1 *h1, Double_t c1=1)
Performs the operation: this = this*c1*f1 .
Definition: TProfile3D.cxx:861
Double_t fTmin
Definition: TProfile3D.h:35
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save primitive as a C++ statement(s) on output stream out.
virtual TProfile2D * Project3DProfile(Option_t *option="xy") const
Project a 3-D profile into a 2D-profile histogram depending on the option parameter.
virtual void SetBinEntries(Int_t bin, Double_t w)
Set the number of entries in bin.
virtual void Copy(TObject &hnew) const
Copy a Profile3D histogram to a new profile2D histogram.
Definition: TProfile3D.cxx:350
void BuildOptions(Double_t tmin, Double_t tmax, Option_t *option)
Set Profile3D histogram structure and options.
Definition: TProfile3D.cxx:142
Int_t Fill(const Double_t *v)
Definition: TProfile3D.h:52
TArrayD fBinSumw2
Definition: TProfile3D.h:40
Double_t * GetB()
Definition: TProfile3D.h:72
virtual void PutStats(Double_t *stats)
Replace current statistics with the values in array stats.
virtual void SetErrorOption(Option_t *option="")
Set option to compute profile3D errors.
virtual Bool_t Divide(TF1 *h1, Double_t c1=1)
Performs the operation: this = this/(c1*f1) .
Definition: TProfile3D.cxx:379
virtual ~TProfile3D()
Default destructor for Profile3D histograms.
Definition: TProfile3D.cxx:87
virtual TH3D * ProjectionXYZ(const char *name="_pxyz", Option_t *option="e") const
Project this profile3D into a 3-D histogram along X,Y,Z.
Definition: TProfile3D.cxx:920
EErrorType fErrorMode
Definition: TProfile3D.h:34
virtual Int_t BufferFill(Double_t, Double_t)
accumulate arguments in buffer.
Definition: TProfile3D.h:43
virtual Double_t GetBinEntries(Int_t bin) const
Return bin entries of a Profile3D histogram.
Definition: TProfile3D.cxx:704
Double_t * GetW2()
Definition: TProfile3D.h:75
virtual void SetBinsLength(Int_t n=-1)
Set total number of bins including under/overflow.
Double_t fTsumwt
True when TProfile3D::Scale is called.
Definition: TProfile3D.h:38
static void Approximate(Bool_t approx=kTRUE)
Set the fgApproximate flag.
Definition: TProfile3D.cxx:231
Double_t fTmax
Definition: TProfile3D.h:36
static Double_t GetBinError(T *p, Int_t bin)
static T * ExtendAxis(T *p, Double_t x, TAxis *axis)
static void Sumw2(T *p, Bool_t flag)
static void SetBinEntries(T *p, Int_t bin, Double_t w)
static void Scale(T *p, Double_t c1, Option_t *option)
static void SetErrorOption(T *p, Option_t *opt)
static Long64_t Merge(T *p, TCollection *list)
static void BuildArray(T *p)
static Bool_t Add(T *p, const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2=1)
static Double_t GetBinEffectiveEntries(T *p, Int_t bin)
Basic string class.
Definition: TString.h:131
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1125
void ToUpper()
Change string to upper case.
Definition: TString.cxx:1138
TString & Append(const char *cs)
Definition: TString.h:559
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:619
return c1
Definition: legend1.C:41
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
TH1F * h1
Definition: legend1.C:5
return c2
Definition: legend2.C:14
Bool_t IsNaN(Double_t x)
Definition: TMath.h:882
Double_t Sqrt(Double_t x)
Definition: TMath.h:681
Short_t Abs(Short_t d)
Definition: TMathBase.h:120