Logo ROOT  
Reference Guide
TGraph2D.cxx
Go to the documentation of this file.
1// @(#)root/hist:$Id: TGraph2D.cxx,v 1.00
2// Author: Olivier Couet
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 "TROOT.h"
13#include "TBuffer.h"
14#include "TMath.h"
15#include "TH2.h"
16#include "TF2.h"
17#include "TList.h"
18#include "TGraph2D.h"
19#include "TGraphDelaunay.h"
20#include "TGraphDelaunay2D.h"
21#include "TVirtualPad.h"
22#include "TVirtualFitter.h"
23#include "TVirtualHistPainter.h"
24#include "TPluginManager.h"
25#include "TSystem.h"
26#include "strtok.h"
27#include "snprintf.h"
28
29#include <cstdlib>
30#include <cassert>
31#include <iostream>
32#include <fstream>
33
34#include "HFitInterface.h"
35#include "Fit/DataRange.h"
37
39
40
41/** \class TGraph2D
42 \ingroup Graphs
43Graphics object made of three arrays X, Y and Z with the same number of points each.
44
45- [Creating a TGraph2D](\ref G2D00)
46- [Drawing options](\ref G2D01)
47- [Examples](\ref G2D02)
48 - [SURF1 Example](\ref G2D021)
49 - [Fitting Example](\ref G2D022)
50 - [PCOL Example](\ref G2D023)
51- [Definition of the Delaunay triangulation (After B. Delaunay)](\ref G2D03)
52
53
54\anchor G2D00
55## Creating a TGraph2D
56
57This class has different constructors:
58- With an array's dimension and three arrays x, y, and z:
59~~~ {.cpp}
60 auto g = new TGraph2D(n, x, y, z);
61~~~
62 x, y, z arrays can be doubles, floats, or ints.
63- With an array's dimension only:
64~~~ {.cpp}
65 auto g = new TGraph2D(n);
66~~~
67 The internal arrays are then filled with `SetPoint()`. The following line
68 fills the internal arrays at the position `i` with the values
69 `x`, `y`, `z`.
70~~~ {.cpp}
71 g->SetPoint(i, x, y, z);
72~~~
73- Without parameters:
74~~~ {.cpp}
75 auto g = new TGraph2D();
76~~~
77 again `SetPoint()` must be used to fill the internal arrays.
78- From a file:
79~~~ {.cpp}
80 auto g = new TGraph2D("graph.dat");
81~~~
82 Arrays are read from the ASCII file "graph.dat" according to a specifies
83 format. The default format is `%%lg %%lg %%lg`
84
85Note that in any of these three cases, `SetPoint()` can be used to change a data
86point or add a new one. If the data point index (`i`) is greater than the
87current size of the internal arrays, they are automatically extended.
88
89Like TGraph some TGraph2D constructors do not have the TGraph2D title and name as parameters.
90For these constructors TGraph2D has the default title and name "Graph2D". To change the
91default title and name `SetTitle` and `SetName` should be called on the TGraph2D after its
92creation.
93
94\anchor G2D01
95## Drawing options
96
97Specific drawing options can be used to paint a TGraph2D:
98
99| Option | Description |
100|----------|-------------------------------------------------------------------|
101| "TRI" | The Delaunay triangles are drawn using filled area. An hidden surface drawing technique is used. The surface is painted with the current fill area color. The edges of each triangles are painted with the current line color. |
102| "TRIW" | The Delaunay triangles are drawn as wire frame. |
103| "TRI1" | The Delaunay triangles are painted with color levels. The edges of each triangles are painted with the current line color. |
104| "TRI2" | The Delaunay triangles are painted with color levels. |
105| "P" | Draw a marker at each vertex. |
106| "P0" | Draw a circle at each vertex. Each circle background is white. |
107| "PCOL" | Draw a marker at each vertex. The color of each marker is defined according to its Z position. |
108| "LINE" | Draw a 3D polyline. |
109| "CONT5" | Draw a contour plot using Delaunay triangles.|
110
111A TGraph2D can be also drawn with any options valid to draw a 2D histogram
112(like `COL`, `SURF`, `LEGO`, `CONT` etc..).
113
114When a TGraph2D is drawn with one of the 2D histogram drawing option,
115an intermediate 2D histogram is filled using the Delaunay triangles
116to interpolate the data set. The 2D histogram has equidistant bins along the X
117and Y directions. The number of bins along each direction can be change using
118`SetNpx()` and `SetNpy()`. Each bin is filled with the Z
119value found via a linear interpolation on the plane defined by the triangle above
120the (X,Y) coordinates of the bin center.
121
122The existing (X,Y,Z) points can be randomly scattered.
123The Delaunay triangles are build in the (X,Y) plane. These 2D triangles are then
124used to define flat planes in (X,Y,Z) over which the interpolation is done to fill
125the 2D histogram. The 3D triangles int takes build a 3D surface in
126the form of tessellating triangles at various angles. The triangles found can be
127drawn in 3D with one of the TGraph2D specific drawing options.
128
129The histogram generated by the Delaunay interpolation can be accessed using the
130`GetHistogram()` method.
131
132The axis settings (title, ranges etc ...) can be changed accessing the axis via
133the GetXaxis GetYaxis and GetZaxis methods. They access the histogram axis created
134at drawing time only. Therefore they should called after the TGraph2D is drawn:
135
136~~~ {.cpp}
137 auto g = new TGraph2D();
138
139 [...]
140
141 g->Draw("tri1");
142 gPad->Update();
143 g->GetXaxis()->SetTitle("X axis title");
144~~~
145
146\anchor G2D02
147## Examples
148
149\anchor G2D021
150### SURF1 Example
151
152Begin_Macro(source)
153{
154 auto c = new TCanvas("c","Graph2D example",0,0,600,400);
155 Double_t x, y, z, P = 6.;
156 Int_t np = 200;
157 auto dt = new TGraph2D();
158 dt->SetTitle("Graph title; X axis title; Y axis title; Z axis title");
159 auto r = new TRandom();
160 for (Int_t N=0; N<np; N++) {
161 x = 2*P*(r->Rndm(N))-P;
162 y = 2*P*(r->Rndm(N))-P;
163 z = (sin(x)/x)*(sin(y)/y)+0.2;
164 dt->SetPoint(N,x,y,z);
165 }
166 gStyle->SetPalette(1);
167 dt->Draw("surf1");
168}
169End_Macro
170
171\anchor G2D022
172### Fitting Example
173
1742D graphs can be fitted as shown by the following example:
175
176Begin_Macro(source)
177../../../tutorials/fit/graph2dfit.C
178End_Macro
179
180\anchor G2D023
181### PCOL Example
182
183Example showing the PCOL option.
184
185Begin_Macro(source)
186{
187 auto c = new TCanvas("c","Graph2D example",0,0,600,400);
188 Double_t P = 5.;
189 Int_t npx = 20 ;
190 Int_t npy = 20 ;
191 Double_t x = -P;
192 Double_t y = -P;
193 Double_t z;
194 Int_t k = 0;
195 Double_t dx = (2*P)/npx;
196 Double_t dy = (2*P)/npy;
197 auto dt = new TGraph2D(npx*npy);
198 dt->SetNpy(41);
199 dt->SetNpx(40);
200 for (Int_t i=0; i<npx; i++) {
201 for (Int_t j=0; j<npy; j++) {
202 z = sin(sqrt(x*x+y*y))+1;
203 dt->SetPoint(k,x,y,z);
204 k++;
205 y = y+dy;
206 }
207 x = x+dx;
208 y = -P;
209 }
210 gStyle->SetPalette(1);
211 dt->SetMarkerStyle(20);
212 dt->Draw("pcol");
213}
214End_Macro
215
216\anchor G2D03
217## Definition of the Delaunay triangulation (After B. Delaunay)
218
219For a set S of points in the Euclidean plane, the unique triangulation DT(S)
220of S such that no point in S is inside the circumcircle of any triangle in
221DT(S). DT(S) is the dual of the Voronoi diagram of S.
222If n is the number of points in S, the Voronoi diagram of S is the partitioning
223of the plane containing S points into n convex polygons such that each polygon
224contains exactly one point and every point in a given polygon is closer to its
225central point than to any other. A Voronoi diagram is sometimes also known as
226a Dirichlet tessellation.
227
228\image html tgraph2d_delaunay.png
229
230[This applet](http://www.cs.cornell.edu/Info/People/chew/Delaunay.html)
231gives a nice practical view of Delaunay triangulation and Voronoi diagram.
232*/
233
234
235////////////////////////////////////////////////////////////////////////////////
236/// Graph2D default constructor
237
239 : TNamed("Graph2D", "Graph2D"), TAttLine(1, 1, 1), TAttFill(0, 1001),
240 TAttMarker(), fNpoints(0)
241{
242 fSize = 0;
243 fMargin = 0.;
244 fNpx = 40;
245 fNpy = 40;
246 fDirectory = 0;
247 fHistogram = 0;
248 fDelaunay = nullptr;
249 fMaximum = -1111;
250 fMinimum = -1111;
251 fX = 0;
252 fY = 0;
253 fZ = 0;
254 fZout = 0;
255 fMaxIter = 100000;
256 fPainter = 0;
257 fFunctions = new TList;
259}
260
261
262////////////////////////////////////////////////////////////////////////////////
263/// Graph2D constructor with three vectors of ints as input.
264
266 : TNamed("Graph2D", "Graph2D"), TAttLine(1, 1, 1), TAttFill(0, 1001),
267 TAttMarker(), fNpoints(n)
268{
269 Build(n);
270
271 // Copy the input vectors into local arrays
272 for (Int_t i = 0; i < fNpoints; ++i) {
273 fX[i] = (Double_t)x[i];
274 fY[i] = (Double_t)y[i];
275 fZ[i] = (Double_t)z[i];
276 }
277}
278
279
280////////////////////////////////////////////////////////////////////////////////
281/// Graph2D constructor with three vectors of floats as input.
282
284 : TNamed("Graph2D", "Graph2D"), TAttLine(1, 1, 1), TAttFill(0, 1001),
285 TAttMarker(), fNpoints(n)
286{
287 Build(n);
288
289 // Copy the input vectors into local arrays
290 for (Int_t i = 0; i < fNpoints; ++i) {
291 fX[i] = x[i];
292 fY[i] = y[i];
293 fZ[i] = z[i];
294 }
295}
296
297
298////////////////////////////////////////////////////////////////////////////////
299/// Graph2D constructor with three vectors of doubles as input.
300
302 : TNamed("Graph2D", "Graph2D"), TAttLine(1, 1, 1), TAttFill(0, 1001),
303 TAttMarker(), fNpoints(n)
304{
305 Build(n);
306
307 // Copy the input vectors into local arrays
308 for (Int_t i = 0; i < fNpoints; ++i) {
309 fX[i] = x[i];
310 fY[i] = y[i];
311 fZ[i] = z[i];
312 }
313}
314
315
316////////////////////////////////////////////////////////////////////////////////
317/// Graph2D constructor with a TH2 (h2) as input.
318/// Only the h2's bins within the X and Y axis ranges are used.
319/// Empty bins, recognized when both content and errors are zero, are excluded.
320
322 : TNamed("Graph2D", "Graph2D"), TAttLine(1, 1, 1), TAttFill(0, 1001),
323 TAttMarker(), fNpoints(0)
324{
325 Build(h2->GetNbinsX()*h2->GetNbinsY());
326
327 TString gname = "Graph2D_from_" + TString(h2->GetName());
328 SetName(gname);
329 // need to call later because sets title in ref histogram
330 SetTitle(h2->GetTitle());
331
332
333
334 TAxis *xaxis = h2->GetXaxis();
335 TAxis *yaxis = h2->GetYaxis();
336 Int_t xfirst = xaxis->GetFirst();
337 Int_t xlast = xaxis->GetLast();
338 Int_t yfirst = yaxis->GetFirst();
339 Int_t ylast = yaxis->GetLast();
340
341
342 Double_t x, y, z;
343 Int_t k = 0;
344
345 for (Int_t i = xfirst; i <= xlast; i++) {
346 for (Int_t j = yfirst; j <= ylast; j++) {
347 x = xaxis->GetBinCenter(i);
348 y = yaxis->GetBinCenter(j);
349 z = h2->GetBinContent(i, j);
350 Double_t ez = h2->GetBinError(i, j);
351 if (z != 0. || ez != 0) {
352 SetPoint(k, x, y, z);
353 k++;
354 }
355 }
356 }
357}
358
359
360////////////////////////////////////////////////////////////////////////////////
361/// Graph2D constructor with name, title and three vectors of doubles as input.
362/// name : name of 2D graph (avoid blanks)
363/// title : 2D graph title
364/// if title is of the form "stringt;stringx;stringy;stringz"
365/// the 2D graph title is set to stringt, the x axis title to stringx,
366/// the y axis title to stringy,etc
367
368TGraph2D::TGraph2D(const char *name, const char *title,
370 : TNamed(name, title), TAttLine(1, 1, 1), TAttFill(0, 1001),
371 TAttMarker(), fNpoints(n)
372{
373 Build(n);
374
375 // Copy the input vectors into local arrays
376 for (Int_t i = 0; i < fNpoints; ++i) {
377 fX[i] = x[i];
378 fY[i] = y[i];
379 fZ[i] = z[i];
380 }
381}
382
383
384////////////////////////////////////////////////////////////////////////////////
385/// Graph2D constructor. The arrays fX, fY and fZ should be filled via
386/// calls to SetPoint
387
389 : TNamed("Graph2D", "Graph2D"), TAttLine(1, 1, 1), TAttFill(0, 1001),
390 TAttMarker(), fNpoints(n)
391{
392 Build(n);
393 for (Int_t i = 0; i < fNpoints; i++) {
394 fX[i] = 0.;
395 fY[i] = 0.;
396 fZ[i] = 0.;
397 }
398}
399
400
401////////////////////////////////////////////////////////////////////////////////
402/// Graph2D constructor reading input from filename
403/// filename is assumed to contain at least three columns of numbers.
404/// For files separated by a specific delimiter different from ' ' and '\\t' (e.g. ';' in csv files)
405/// you can avoid using %*s to bypass this delimiter by explicitly specify the "option" argument,
406/// e.g. option=" \\t,;" for columns of figures separated by any of these characters (' ', '\\t', ',', ';')
407/// used once (e.g. "1;1") or in a combined way (" 1;,;; 1").
408/// Note in that case, the instantiation is about 2 times slower.
409
411 : TNamed("Graph2D", filename), TAttLine(1, 1, 1), TAttFill(0, 1001),
412 TAttMarker(), fNpoints(0)
413{
414 Double_t x, y, z;
415 TString fname = filename;
416 gSystem->ExpandPathName(fname);
417
418 std::ifstream infile(fname.Data());
419 if (!infile.good()) {
420 MakeZombie();
421 Error("TGraph2D", "Cannot open file: %s, TGraph2D is Zombie", filename);
422 return;
423 } else {
424 Build(100);
425 }
426 std::string line;
427 Int_t np = 0;
428
429 if (strcmp(option, "") == 0) { // No delimiters specified (standard constructor).
430
431 while (std::getline(infile, line, '\n')) {
432 if (3 != sscanf(line.c_str(), format, &x, &y, &z)) {
433 continue; // skip empty and ill-formed lines
434 }
435 SetPoint(np, x, y, z);
436 np++;
437 }
438
439 } else { // A delimiter has been specified in "option"
440
441 // Checking format and creating its boolean equivalent
442 TString format_ = TString(format) ;
443 format_.ReplaceAll(" ", "") ;
444 format_.ReplaceAll("\t", "") ;
445 format_.ReplaceAll("lg", "") ;
446 format_.ReplaceAll("s", "") ;
447 format_.ReplaceAll("%*", "0") ;
448 format_.ReplaceAll("%", "1") ;
449 if (!format_.IsDigit()) {
450 Error("TGraph2D", "Incorrect input format! Allowed format tags are {\"%%lg\",\"%%*lg\" or \"%%*s\"}");
451 return;
452 }
453 Int_t ntokens = format_.Length() ;
454 if (ntokens < 3) {
455 Error("TGraph2D", "Incorrect input format! Only %d tag(s) in format whereas 3 \"%%lg\" tags are expected!", ntokens);
456 return;
457 }
458 Int_t ntokensToBeSaved = 0 ;
459 Bool_t * isTokenToBeSaved = new Bool_t [ntokens] ;
460 for (Int_t idx = 0; idx < ntokens; idx++) {
461 isTokenToBeSaved[idx] = TString::Format("%c", format_[idx]).Atoi() ; //atoi(&format_[idx]) does not work for some reason...
462 if (isTokenToBeSaved[idx] == 1) {
463 ntokensToBeSaved++ ;
464 }
465 }
466 if (ntokens >= 3 && ntokensToBeSaved != 3) { //first condition not to repeat the previous error message
467 Error("TGraph2D", "Incorrect input format! There are %d \"%%lg\" tag(s) in format whereas 3 and only 3 are expected!", ntokensToBeSaved);
468 delete [] isTokenToBeSaved ;
469 return;
470 }
471
472 // Initializing loop variables
473 Bool_t isLineToBeSkipped = kFALSE ; //empty and ill-formed lines
474 char * token = NULL ;
475 TString token_str = "" ;
476 Int_t token_idx = 0 ;
477 Double_t * value = new Double_t [3] ; //x,y,z buffers
478 Int_t value_idx = 0 ;
479
480 // Looping
481 char *rest;
482 while (std::getline(infile, line, '\n')) {
483 if (line != "") {
484 if (line[line.size() - 1] == char(13)) { // removing DOS CR character
485 line.erase(line.end() - 1, line.end()) ;
486 }
487 token = R__STRTOK_R(const_cast<char*>(line.c_str()), option, &rest);
488 while (token != NULL && value_idx < 3) {
489 if (isTokenToBeSaved[token_idx]) {
490 token_str = TString(token) ;
491 token_str.ReplaceAll("\t", "") ;
492 if (!token_str.IsFloat()) {
493 isLineToBeSkipped = kTRUE ;
494 break ;
495 } else {
496 value[value_idx] = token_str.Atof() ;
497 value_idx++ ;
498 }
499 }
500 token = R__STRTOK_R(NULL, option, &rest); // next token
501 token_idx++ ;
502 }
503 if (!isLineToBeSkipped && value_idx == 3) {
504 x = value[0] ;
505 y = value[1] ;
506 z = value[2] ;
507 SetPoint(np, x, y, z) ;
508 np++ ;
509 }
510 }
511 isLineToBeSkipped = kFALSE ;
512 token = NULL ;
513 token_idx = 0 ;
514 value_idx = 0 ;
515 }
516
517 // Cleaning
518 delete [] isTokenToBeSaved ;
519 delete [] value ;
520 delete token ;
521 }
522 infile.close();
523}
524
525
526////////////////////////////////////////////////////////////////////////////////
527/// Graph2D copy constructor.
528/// copy everything apart from the list of contained functions
529
532 fX(0), fY(0), fZ(0),
533 fHistogram(0), fDirectory(0), fPainter(0)
534{
535 fFunctions = new TList(); // do not copy the functions
536
537 // use operator=
538 (*this) = g;
539
540 // append TGraph2D to gdirectory
543 if (fDirectory) {
544 // append without replacing existing objects
545 fDirectory->Append(this);
546 }
547 }
548
549
550}
551
552
553////////////////////////////////////////////////////////////////////////////////
554/// TGraph2D destructor.
555
557{
558 Clear();
559}
560
561
562////////////////////////////////////////////////////////////////////////////////
563/// Graph2D operator "="
564
566{
567 if (this == &g) return *this;
568
569 // delete before existing contained objects
570 if (fX) delete [] fX;
571 if (fY) delete [] fY;
572 if (fZ) delete [] fZ;
573 if (fHistogram && !fUserHisto) {
574 delete fHistogram;
575 fHistogram = nullptr;
576 fDelaunay = nullptr;
577 }
578 // copy everything except the function list
579 fNpoints = g.fNpoints;
580 fNpx = g.fNpx;
581 fNpy = g.fNpy;
582 fMaxIter = g.fMaxIter;
583 fSize = fNpoints; // force size to be the same of npoints
584 fX = (fSize > 0) ? new Double_t[fSize] : 0;
585 fY = (fSize > 0) ? new Double_t[fSize] : 0;
586 fZ = (fSize > 0) ? new Double_t[fSize] : 0;
587 fMinimum = g.fMinimum;
588 fMaximum = g.fMaximum;
589 fMargin = g.fMargin;
590 fZout = g.fZout;
591 fUserHisto = g.fUserHisto;
592 if (g.fHistogram)
593 fHistogram = (fUserHisto ) ? g.fHistogram : new TH2D(*g.fHistogram);
594
595
596
597 // copy the points
598 for (Int_t n = 0; n < fSize; n++) {
599 fX[n] = g.fX[n];
600 fY[n] = g.fY[n];
601 fZ[n] = g.fZ[n];
602 }
603
604 return *this;
605}
606
607////////////////////////////////////////////////////////////////////////////////
608/// Creates the 2D graph basic data structure
609
611{
612 if (n <= 0) {
613 Error("TGraph2D", "Invalid number of points (%d)", n);
614 return;
615 }
616
617 fSize = n;
618 fMargin = 0.;
619 fNpx = 40;
620 fNpy = 40;
621 fDirectory = 0;
622 fHistogram = 0;
623 fDelaunay = nullptr;
624 fMaximum = -1111;
625 fMinimum = -1111;
626 fX = new Double_t[fSize];
627 fY = new Double_t[fSize];
628 fZ = new Double_t[fSize];
629 fZout = 0;
630 fMaxIter = 100000;
631 fFunctions = new TList;
632 fPainter = 0;
634
637 if (fDirectory) {
638 fDirectory->Append(this, kTRUE);
639 }
640 }
641}
642
643
644////////////////////////////////////////////////////////////////////////////////
645/// Browse
646
648{
649 Draw("p0");
650 gPad->Update();
651}
652
653
654////////////////////////////////////////////////////////////////////////////////
655/// Free all memory allocated by this object.
656
657void TGraph2D::Clear(Option_t * /*option = "" */)
658{
659 if (fX) delete [] fX;
660 fX = 0;
661 if (fY) delete [] fY;
662 fY = 0;
663 if (fZ) delete [] fZ;
664 fZ = 0;
665 fSize = fNpoints = 0;
666 if (fHistogram && !fUserHisto) {
667 delete fHistogram;
668 fHistogram = nullptr;
669 fDelaunay = nullptr;
670 }
671 if (fFunctions) {
674 delete fFunctions;
675 fFunctions = 0;
676 }
677 if (fDirectory) {
678 fDirectory->Remove(this);
679 fDirectory = 0;
680 }
681}
682
683
684////////////////////////////////////////////////////////////////////////////////
685/// Perform the automatic addition of the graph to the given directory
686///
687/// Note this function is called in place when the semantic requires
688/// this object to be added to a directory (I.e. when being read from
689/// a TKey or being Cloned)
690
692{
693 Bool_t addStatus = TH1::AddDirectoryStatus();
694 if (addStatus) {
695 SetDirectory(dir);
696 if (dir) {
698 }
699 }
700}
701
702
703////////////////////////////////////////////////////////////////////////////////
704/// Computes distance from point px,py to a graph
705
707{
708 Int_t distance = 9999;
709 if (fHistogram) distance = fHistogram->DistancetoPrimitive(px, py);
710 return distance;
711}
712
713
714////////////////////////////////////////////////////////////////////////////////
715/// Specific drawing options can be used to paint a TGraph2D:
716///
717/// - "TRI" : The Delaunay triangles are drawn using filled area.
718/// An hidden surface drawing technique is used. The surface is
719/// painted with the current fill area color. The edges of each
720/// triangles are painted with the current line color.
721/// - "TRIW" : The Delaunay triangles are drawn as wire frame
722/// - "TRI1" : The Delaunay triangles are painted with color levels. The edges
723/// of each triangles are painted with the current line color.
724/// - "TRI2" : the Delaunay triangles are painted with color levels.
725/// - "P" : Draw a marker at each vertex
726/// - "P0" : Draw a circle at each vertex. Each circle background is white.
727/// - "PCOL" : Draw a marker at each vertex. The color of each marker is
728/// defined according to its Z position.
729/// - "CONT" : Draw contours
730/// - "LINE" : Draw a 3D polyline
731///
732/// A TGraph2D can be also drawn with ANY options valid to draw a 2D histogram.
733///
734/// When a TGraph2D is drawn with one of the 2D histogram drawing option,
735/// a intermediate 2D histogram is filled using the Delaunay triangles
736/// technique to interpolate the data set.
737
739{
740 TString opt = option;
741 opt.ToLower();
742 if (gPad) {
743 if (!gPad->IsEditable()) gROOT->MakeDefCanvas();
744 if (!opt.Contains("same")) {
745 //the following statement is necessary in case one attempts to draw
746 //a temporary histogram already in the current pad
747 if (TestBit(kCanDelete)) gPad->GetListOfPrimitives()->Remove(this);
748 gPad->Clear();
749 }
750 }
751 AppendPad(opt.Data());
752}
753
754
755////////////////////////////////////////////////////////////////////////////////
756/// Executes action corresponding to one event
757
759{
761}
762
763
764////////////////////////////////////////////////////////////////////////////////
765/// search object named name in the list of functions
766
768{
769 if (fFunctions) return fFunctions->FindObject(name);
770 return 0;
771}
772
773
774////////////////////////////////////////////////////////////////////////////////
775/// search object obj in the list of functions
776
778{
779 if (fFunctions) return fFunctions->FindObject(obj);
780 return 0;
781}
782
783
784////////////////////////////////////////////////////////////////////////////////
785/// Fits this graph with function with name fname
786/// Predefined functions such as gaus, expo and poln are automatically
787/// created by ROOT.
788/// fname can also be a formula, accepted by the linear fitter (linear parts divided
789/// by "++" sign), for example "x++sin(y)" for fitting "[0]*x+[1]*sin(y)"
790
792{
793
794 char *linear;
795 linear = (char*)strstr(fname, "++");
796
797 if (linear) {
798 TF2 f2(fname, fname);
799 return Fit(&f2, option, "");
800 }
801 TF2 * f2 = (TF2*)gROOT->GetFunction(fname);
802 if (!f2) {
803 Printf("Unknown function: %s", fname);
804 return -1;
805 }
806 return Fit(f2, option, "");
807
808}
809
810
811////////////////////////////////////////////////////////////////////////////////
812/// Fits this 2D graph with function f2
813///
814/// f2 is an already predefined function created by TF2.
815///
816/// See TGraph::Fit for the available fitting options and fitting notes
817///
819{
820 // internal graph2D fitting methods
821 Foption_t fitOption;
822 Option_t *goption = "";
824
825 // create range and minimizer options with default values
826 ROOT::Fit::DataRange range(2);
828 return ROOT::Fit::FitObject(this, f2 , fitOption , minOption, goption, range);
829}
830
831
832////////////////////////////////////////////////////////////////////////////////
833/// Display a GUI panel with all graph fit options.
834///
835/// See class TFitEditor for example
836
838{
839 if (!gPad)
840 gROOT->MakeDefCanvas();
841
842 if (!gPad) {
843 Error("FitPanel", "Unable to create a default canvas");
844 return;
845 }
846
847 // use plugin manager to create instance of TFitEditor
848 TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TFitEditor");
849 if (handler && handler->LoadPlugin() != -1) {
850 if (handler->ExecPlugin(2, gPad, this) == 0)
851 Error("FitPanel", "Unable to crate the FitPanel");
852 } else
853 Error("FitPanel", "Unable to find the FitPanel plug-in");
854
855}
856
857
858////////////////////////////////////////////////////////////////////////////////
859/// Get x axis of the graph.
860
862{
863 TH1 *h = ((TGraph2D*)this)->GetHistogram("empty");
864 if (!h) return 0;
865 return h->GetXaxis();
866}
867
868
869////////////////////////////////////////////////////////////////////////////////
870/// Get y axis of the graph.
871
873{
874 TH1 *h = ((TGraph2D*)this)->GetHistogram("empty");
875 if (!h) return 0;
876 return h->GetYaxis();
877}
878
879
880////////////////////////////////////////////////////////////////////////////////
881/// Get z axis of the graph.
882
884{
885 TH1 *h = ((TGraph2D*)this)->GetHistogram("empty");
886 if (!h) return 0;
887 return h->GetZaxis();
888}
889
890
891////////////////////////////////////////////////////////////////////////////////
892/// Returns the X and Y graphs building a contour. A contour level may
893/// consist in several parts not connected to each other. This function
894/// returns them in a graphs' list.
895
897{
898 if (fNpoints <= 0) {
899 Error("GetContourList", "Empty TGraph2D");
900 return 0;
901 }
902
903 if (!fHistogram) GetHistogram("empty");
904
906
907 return fPainter->GetContourList(contour);
908}
909
910
911////////////////////////////////////////////////////////////////////////////////
912/// This function is called by Graph2DFitChisquare.
913/// It always returns a negative value. Real implementation in TGraph2DErrors
914
916{
917 return -1;
918}
919
920
921////////////////////////////////////////////////////////////////////////////////
922/// This function is called by Graph2DFitChisquare.
923/// It always returns a negative value. Real implementation in TGraph2DErrors
924
926{
927 return -1;
928}
929
930
931////////////////////////////////////////////////////////////////////////////////
932/// This function is called by Graph2DFitChisquare.
933/// It always returns a negative value. Real implementation in TGraph2DErrors
934
936{
937 return -1;
938}
939
940
941////////////////////////////////////////////////////////////////////////////////
942/// Add a TGraphDelaunay in the list of the fHistogram's functions
943
945{
946
948
949 if (oldInterp) {
950 TGraphDelaunay *dt = new TGraphDelaunay(this);
951 dt->SetMaxIter(fMaxIter);
953 fDelaunay = dt;
955 if (!hl->FindObject("TGraphDelaunay")) hl->Add(fDelaunay);
956 } else {
957 TGraphDelaunay2D *dt = new TGraphDelaunay2D(this);
959 fDelaunay = dt;
961 if (!hl->FindObject("TGraphDelaunay2D")) hl->Add(fDelaunay);
962 }
963}
964
965////////////////////////////////////////////////////////////////////////////////
966/// By default returns a pointer to the Delaunay histogram. If fHistogram
967/// doesn't exist, books the 2D histogram fHistogram with a margin around
968/// the hull. Calls TGraphDelaunay::Interpolate at each bin centre to build up
969/// an interpolated 2D histogram.
970///
971/// If the "empty" option is selected, returns an empty histogram booked with
972/// the limits of fX, fY and fZ. This option is used when the data set is
973/// drawn with markers only. In that particular case there is no need to
974/// find the Delaunay triangles.
975///
976/// By default use the new interpolation routine based on Triangles
977/// If the option "old" the old interpolation is used
978
980{
981 // for an empty graph create histogram in [0,1][0,1]
982 if (fNpoints <= 0) {
983 if (!fHistogram) {
984 // do not add the histogram to gDirectory
985 TDirectory::TContext ctx(nullptr);
986 fHistogram = new TH2D(GetName(), GetTitle(), fNpx , 0., 1., fNpy, 0., 1.);
988 }
989 return fHistogram;
990 }
991
992 TString opt = option;
993 opt.ToLower();
994 Bool_t empty = opt.Contains("empty");
995 Bool_t oldInterp = opt.Contains("old");
996
997 if (fHistogram) {
998 if (!empty && fHistogram->GetEntries() == 0) {
999 if (!fUserHisto) {
1000 delete fHistogram;
1001 fHistogram = nullptr;
1002 fDelaunay = nullptr;
1003 }
1004 } else if (fHistogram->GetEntries() == 0)
1005 {; }
1006 // check case if interpolation type has changed
1007 else if ( (TestBit(kOldInterpolation) && !oldInterp) || ( !TestBit(kOldInterpolation) && oldInterp ) ) {
1008 delete fHistogram;
1009 fHistogram = nullptr;
1010 fDelaunay = nullptr;
1011 }
1012 // normal case return existing histogram
1013 else {
1014 return fHistogram;
1015 }
1016 }
1017
1018 Double_t hxmax, hymax, hxmin, hymin;
1019
1020 // Book fHistogram if needed. It is not added in the current directory
1021 if (!fUserHisto) {
1026 hxmin = xmin - fMargin * (xmax - xmin);
1027 hymin = ymin - fMargin * (ymax - ymin);
1028 hxmax = xmax + fMargin * (xmax - xmin);
1029 hymax = ymax + fMargin * (ymax - ymin);
1030 Double_t epsilon = 1e-9;
1031 if (TMath::AreEqualRel(hxmax,hxmin,epsilon)) {
1032 if (TMath::Abs(hxmin) < epsilon) {
1033 hxmin = -0.001;
1034 hxmax = 0.001;
1035 } else {
1036 hxmin = hxmin-TMath::Abs(hxmin)*(epsilon/2.);
1037 hxmax = hxmax+TMath::Abs(hxmax)*(epsilon/2.);
1038 }
1039 }
1040 if (TMath::AreEqualRel(hymax, hymin, epsilon)) {
1041 if (TMath::Abs(hymin) < epsilon) {
1042 hymin = -0.001;
1043 hymax = 0.001;
1044 } else {
1045 hymin = hymin-TMath::Abs(hymin)*(epsilon/2.);
1046 hymax = hymax+TMath::Abs(hymax)*(epsilon/2.);
1047 }
1048 }
1049 if (fHistogram) {
1050 fHistogram->GetXaxis()->SetLimits(hxmin, hxmax);
1051 fHistogram->GetYaxis()->SetLimits(hymin, hymax);
1052 } else {
1053 TDirectory::TContext ctx(nullptr); // to avoid adding fHistogram to gDirectory
1054 fHistogram = new TH2D(GetName(), GetTitle(),
1055 fNpx , hxmin, hxmax,
1056 fNpy, hymin, hymax);
1057 CreateInterpolator(oldInterp);
1058 }
1060 } else {
1061 hxmin = fHistogram->GetXaxis()->GetXmin();
1062 hymin = fHistogram->GetYaxis()->GetXmin();
1063 hxmax = fHistogram->GetXaxis()->GetXmax();
1064 hymax = fHistogram->GetYaxis()->GetXmax();
1065 }
1066
1067 // Option "empty" is selected. An empty histogram is returned.
1068 if (empty) {
1069 Double_t hzmax, hzmin;
1070 if (fMinimum != -1111) {
1071 hzmin = fMinimum;
1072 } else {
1073 hzmin = GetZminE();
1074 }
1075 if (fMaximum != -1111) {
1076 hzmax = fMaximum;
1077 } else {
1078 hzmax = GetZmaxE();
1079 }
1080 if (hzmin == hzmax) {
1081 Double_t hz = hzmin;
1082 if (hz==0) {
1083 hzmin = -0.01;
1084 hzmax = 0.01;
1085 } else {
1086 hzmin = hz - 0.01 * TMath::Abs(hz);
1087 hzmax = hz + 0.01 * TMath::Abs(hz);
1088 }
1089 }
1090 fHistogram->SetMinimum(hzmin);
1091 fHistogram->SetMaximum(hzmax);
1092 return fHistogram;
1093 }
1094
1095 Double_t dx = (hxmax - hxmin) / fNpx;
1096 Double_t dy = (hymax - hymin) / fNpy;
1097
1098 Double_t x, y, z;
1099
1100 for (Int_t ix = 1; ix <= fNpx; ix++) {
1101 x = hxmin + (ix - 0.5) * dx;
1102 for (Int_t iy = 1; iy <= fNpy; iy++) {
1103 y = hymin + (iy - 0.5) * dy;
1104 // do interpolation
1105 if (oldInterp)
1106 z = ((TGraphDelaunay*)fDelaunay)->ComputeZ(x, y);
1107 else
1108 z = ((TGraphDelaunay2D*)fDelaunay)->ComputeZ(x, y);
1109
1110 fHistogram->Fill(x, y, z);
1111 }
1112 }
1113
1114
1115 if (fMinimum != -1111) fHistogram->SetMinimum(fMinimum);
1116 if (fMaximum != -1111) fHistogram->SetMaximum(fMaximum);
1117
1118 return fHistogram;
1119}
1120
1121
1122////////////////////////////////////////////////////////////////////////////////
1123/// Returns the X maximum
1124
1126{
1127 Double_t v = fX[0];
1128 for (Int_t i = 1; i < fNpoints; i++) if (fX[i] > v) v = fX[i];
1129 return v;
1130}
1131
1132
1133////////////////////////////////////////////////////////////////////////////////
1134/// Returns the X minimum
1135
1137{
1138 Double_t v = fX[0];
1139 for (Int_t i = 1; i < fNpoints; i++) if (fX[i] < v) v = fX[i];
1140 return v;
1141}
1142
1143
1144////////////////////////////////////////////////////////////////////////////////
1145/// Returns the Y maximum
1146
1148{
1149 Double_t v = fY[0];
1150 for (Int_t i = 1; i < fNpoints; i++) if (fY[i] > v) v = fY[i];
1151 return v;
1152}
1153
1154
1155////////////////////////////////////////////////////////////////////////////////
1156/// Returns the Y minimum
1157
1159{
1160 Double_t v = fY[0];
1161 for (Int_t i = 1; i < fNpoints; i++) if (fY[i] < v) v = fY[i];
1162 return v;
1163}
1164
1165
1166////////////////////////////////////////////////////////////////////////////////
1167/// Returns the Z maximum
1168
1170{
1171 Double_t v = fZ[0];
1172 for (Int_t i = 1; i < fNpoints; i++) if (fZ[i] > v) v = fZ[i];
1173 return v;
1174}
1175
1176
1177////////////////////////////////////////////////////////////////////////////////
1178/// Returns the Z minimum
1179
1181{
1182 Double_t v = fZ[0];
1183 for (Int_t i = 1; i < fNpoints; i++) if (fZ[i] < v) v = fZ[i];
1184 return v;
1185}
1186
1187////////////////////////////////////////////////////////////////////////////////
1188/// Get x, y and z values for point number i.
1189/// The function returns -1 in case of an invalid request or the point number otherwise
1190
1192{
1193 if (i < 0 || i >= fNpoints) return -1;
1194 if (!fX || !fY || !fZ) return -1;
1195 x = fX[i];
1196 y = fY[i];
1197 z = fZ[i];
1198 return i;
1199}
1200
1201////////////////////////////////////////////////////////////////////////////////
1202/// Finds the z value at the position (x,y) thanks to
1203/// the Delaunay interpolation.
1204
1206{
1207 if (fNpoints <= 0) {
1208 Error("Interpolate", "Empty TGraph2D");
1209 return 0;
1210 }
1211
1212 if (!fHistogram) GetHistogram("empty");
1213 if (!fDelaunay) {
1215 if (!TestBit(kOldInterpolation) ) {
1216 fDelaunay = hl->FindObject("TGraphDelaunay2D");
1217 if (!fDelaunay) fDelaunay = hl->FindObject("TGraphDelaunay");
1218 }
1219 else {
1220 // if using old implementation
1221 fDelaunay = hl->FindObject("TGraphDelaunay");
1222 if (!fDelaunay) fDelaunay = hl->FindObject("TGraphDelaunay2D");
1223 }
1224 }
1225
1226 if (!fDelaunay) return TMath::QuietNaN();
1227
1229 return ((TGraphDelaunay2D*)fDelaunay)->ComputeZ(x, y);
1230 else if (fDelaunay->IsA() == TGraphDelaunay::Class() )
1231 return ((TGraphDelaunay*)fDelaunay)->ComputeZ(x, y);
1232
1233 // cannot be here
1234 assert(false);
1235 return TMath::QuietNaN();
1236}
1237
1238
1239////////////////////////////////////////////////////////////////////////////////
1240/// Paints this 2D graph with its current attributes
1241
1243{
1244 if (fNpoints <= 0) {
1245 Error("Paint", "Empty TGraph2D");
1246 return;
1247 }
1248
1249 TString opt = option;
1250 opt.ToLower();
1251 if (opt.Contains("p") && !opt.Contains("tri")) {
1252 if (!opt.Contains("pol") &&
1253 !opt.Contains("sph") &&
1254 !opt.Contains("psr")) opt.Append("tri0");
1255 }
1256
1257 if (opt.Contains("line") && !opt.Contains("tri")) opt.Append("tri0");
1258
1259 if (opt.Contains("err") && !opt.Contains("tri")) opt.Append("tri0");
1260
1261 if (opt.Contains("tri0")) {
1262 GetHistogram("empty");
1263 } else if (opt.Contains("old")) {
1264 GetHistogram("old");
1265 } else {
1266 GetHistogram();
1267 }
1268
1277 fHistogram->Paint(opt.Data());
1278}
1279
1280
1281////////////////////////////////////////////////////////////////////////////////
1282/// Print 2D graph values.
1283
1285{
1286 for (Int_t i = 0; i < fNpoints; i++) {
1287 printf("x[%d]=%g, y[%d]=%g, z[%d]=%g\n", i, fX[i], i, fY[i], i, fZ[i]);
1288 }
1289}
1290
1291
1292////////////////////////////////////////////////////////////////////////////////
1293/// Projects a 2-d graph into 1 or 2-d histograms depending on the option parameter.
1294/// option may contain a combination of the characters x,y,z:
1295///
1296/// - option = "x" return the x projection into a TH1D histogram
1297/// - option = "y" return the y projection into a TH1D histogram
1298/// - option = "xy" return the x versus y projection into a TH2D histogram
1299/// - option = "yx" return the y versus x projection into a TH2D histogram
1300
1302{
1303 if (fNpoints <= 0) {
1304 Error("Project", "Empty TGraph2D");
1305 return 0;
1306 }
1307
1308 TString opt = option;
1309 opt.ToLower();
1310
1311 Int_t pcase = 0;
1312 if (opt.Contains("x")) pcase = 1;
1313 if (opt.Contains("y")) pcase = 2;
1314 if (opt.Contains("xy")) pcase = 3;
1315 if (opt.Contains("yx")) pcase = 4;
1316
1317 // Create the projection histogram
1318 TH1D *h1 = 0;
1319 TH2D *h2 = 0;
1320 Int_t nch = strlen(GetName()) + opt.Length() + 2;
1321 char *name = new char[nch];
1322 snprintf(name, nch, "%s_%s", GetName(), option);
1323 nch = strlen(GetTitle()) + opt.Length() + 2;
1324 char *title = new char[nch];
1325 snprintf(title, nch, "%s_%s", GetTitle(), option);
1326
1327 Double_t hxmin = GetXmin();
1328 Double_t hxmax = GetXmax();
1329 Double_t hymin = GetYmin();
1330 Double_t hymax = GetYmax();
1331
1332 switch (pcase) {
1333 case 1:
1334 // "x"
1335 h1 = new TH1D(name, title, fNpx, hxmin, hxmax);
1336 break;
1337 case 2:
1338 // "y"
1339 h1 = new TH1D(name, title, fNpy, hymin, hymax);
1340 break;
1341 case 3:
1342 // "xy"
1343 h2 = new TH2D(name, title, fNpx, hxmin, hxmax, fNpy, hymin, hymax);
1344 break;
1345 case 4:
1346 // "yx"
1347 h2 = new TH2D(name, title, fNpy, hymin, hymax, fNpx, hxmin, hxmax);
1348 break;
1349 }
1350
1351 delete [] name;
1352 delete [] title;
1353 TH1 *h = h1;
1354 if (h2) h = h2;
1355 if (h == 0) return 0;
1356
1357 // Fill the projected histogram
1358 Double_t entries = 0;
1359 for (Int_t n = 0; n < fNpoints; n++) {
1360 switch (pcase) {
1361 case 1:
1362 // "x"
1363 h1->Fill(fX[n], fZ[n]);
1364 break;
1365 case 2:
1366 // "y"
1367 h1->Fill(fY[n], fZ[n]);
1368 break;
1369 case 3:
1370 // "xy"
1371 h2->Fill(fX[n], fY[n], fZ[n]);
1372 break;
1373 case 4:
1374 // "yx"
1375 h2->Fill(fY[n], fX[n], fZ[n]);
1376 break;
1377 }
1378 entries += fZ[n];
1379 }
1380 h->SetEntries(entries);
1381 return h;
1382}
1383
1384
1385////////////////////////////////////////////////////////////////////////////////
1386/// Deletes point number ipoint
1387
1389{
1390 if (ipoint < 0) return -1;
1391 if (ipoint >= fNpoints) return -1;
1392
1393 fNpoints--;
1394 Double_t *newX = new Double_t[fNpoints];
1395 Double_t *newY = new Double_t[fNpoints];
1396 Double_t *newZ = new Double_t[fNpoints];
1397 Int_t j = -1;
1398 for (Int_t i = 0; i < fNpoints + 1; i++) {
1399 if (i == ipoint) continue;
1400 j++;
1401 newX[j] = fX[i];
1402 newY[j] = fY[i];
1403 newZ[j] = fZ[i];
1404 }
1405 delete [] fX;
1406 delete [] fY;
1407 delete [] fZ;
1408 fX = newX;
1409 fY = newY;
1410 fZ = newZ;
1411 fSize = fNpoints;
1412 if (fHistogram) {
1413 delete fHistogram;
1414 fHistogram = nullptr;
1415 fDelaunay = nullptr;
1416 }
1417 return ipoint;
1418}
1419
1420
1421////////////////////////////////////////////////////////////////////////////////
1422/// Saves primitive as a C++ statement(s) on output stream out
1423
1424void TGraph2D::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
1425{
1426 char quote = '"';
1427 out << " " << std::endl;
1428 if (gROOT->ClassSaved(TGraph2D::Class())) {
1429 out << " ";
1430 } else {
1431 out << " TGraph2D *";
1432 }
1433
1434 out << "graph2d = new TGraph2D(" << fNpoints << ");" << std::endl;
1435 out << " graph2d->SetName(" << quote << GetName() << quote << ");" << std::endl;
1436 out << " graph2d->SetTitle(" << quote << GetTitle() << ";"
1437 << GetXaxis()->GetTitle() << ";"
1438 << GetYaxis()->GetTitle() << ";"
1439 << GetZaxis()->GetTitle() << quote << ");" << std::endl;
1440
1441 if (fDirectory == 0) {
1442 out << " graph2d->SetDirectory(0);" << std::endl;
1443 }
1444
1445 SaveFillAttributes(out, "graph2d", 0, 1001);
1446 SaveLineAttributes(out, "graph2d", 1, 1, 1);
1447 SaveMarkerAttributes(out, "graph2d", 1, 1, 1);
1448
1449 for (Int_t i = 0; i < fNpoints; i++) {
1450 out << " graph2d->SetPoint(" << i << "," << fX[i] << "," << fY[i] << "," << fZ[i] << ");" << std::endl;
1451 }
1452
1453 // save list of functions
1454 TIter next(fFunctions);
1455 TObject *obj;
1456 while ((obj = next())) {
1457 obj->SavePrimitive(out, "nodraw");
1458 out << " graph2d->GetListOfFunctions()->Add(" << obj->GetName() << ");" << std::endl;
1459 if (obj->InheritsFrom("TPaveStats")) {
1460 out << " ptstats->SetParent(graph2d->GetListOfFunctions());" << std::endl;
1461 } else if (obj->InheritsFrom("TF1")) {
1462 out << " " << obj->GetName() << "->SetParent(graph);\n";
1463 }
1464
1465 }
1466
1467 out << " graph2d->Draw(" << quote << option << quote << ");" << std::endl;
1468}
1469
1470////////////////////////////////////////////////////////////////////////////////
1471/// Multiply the values of a TGraph2D by a constant c1.
1472///
1473/// If option contains "x" the x values are scaled
1474/// If option contains "y" the y values are scaled
1475/// If option contains "z" the z values are scaled
1476/// If option contains "xyz" all three x, y and z values are scaled
1477
1479{
1480 TString opt = option; opt.ToLower();
1481 if (opt.Contains("x")) {
1482 for (Int_t i=0; i<GetN(); i++)
1483 GetX()[i] *= c1;
1484 }
1485 if (opt.Contains("y")) {
1486 for (Int_t i=0; i<GetN(); i++)
1487 GetY()[i] *= c1;
1488 }
1489 if (opt.Contains("z")) {
1490 for (Int_t i=0; i<GetN(); i++)
1491 GetZ()[i] *= c1;
1492 }
1493}
1494
1495////////////////////////////////////////////////////////////////////////////////
1496/// Set number of points in the 2D graph.
1497/// Existing coordinates are preserved.
1498/// New coordinates above fNpoints are preset to 0.
1499
1501{
1502 if (n < 0) n = 0;
1503 if (n == fNpoints) return;
1504 if (n > fNpoints) SetPoint(n, 0, 0, 0);
1505 fNpoints = n;
1506}
1507
1508
1509////////////////////////////////////////////////////////////////////////////////
1510/// By default when an 2D graph is created, it is added to the list
1511/// of 2D graph objects in the current directory in memory.
1512/// This method removes reference to this 2D graph from current directory and add
1513/// reference to new directory dir. dir can be 0 in which case the
1514/// 2D graph does not belong to any directory.
1515
1517{
1518 if (fDirectory == dir) return;
1519 if (fDirectory) fDirectory->Remove(this);
1520 fDirectory = dir;
1521 if (fDirectory) fDirectory->Append(this);
1522}
1523
1524
1525////////////////////////////////////////////////////////////////////////////////
1526/// Sets the histogram to be filled.
1527/// If the 2D graph needs to be save in a TFile the following set should be
1528/// followed to read it back:
1529/// 1. Create TGraph2D
1530/// 2. Call g->SetHistogram(h), and do whatever you need to do
1531/// 3. Save g and h to the TFile, exit
1532/// 4. Open the TFile, retrieve g and h
1533/// 5. Call h->SetDirectory(0)
1534/// 6. Call g->SetHistogram(h) again
1535/// 7. Carry on as normal
1536///
1537/// By default use the new interpolation routine based on Triangles
1538/// If the option "old" the old interpolation is used
1539
1541{
1542 TString opt = option;
1543 opt.ToLower();
1544 Bool_t oldInterp = opt.Contains("old");
1545
1546 fUserHisto = kTRUE;
1547 fHistogram = (TH2D*)h;
1548 fNpx = h->GetNbinsX();
1549 fNpy = h->GetNbinsY();
1550 CreateInterpolator(oldInterp);
1551}
1552
1553
1554////////////////////////////////////////////////////////////////////////////////
1555/// Sets the extra space (in %) around interpolated area for the 2D histogram
1556
1558{
1559 if (m < 0 || m > 1) {
1560 Warning("SetMargin", "The margin must be >= 0 && <= 1, fMargin set to 0.1");
1561 fMargin = 0.1;
1562 } else {
1563 fMargin = m;
1564 }
1565 if (fHistogram) {
1566 delete fHistogram;
1567 fHistogram = nullptr;
1568 fDelaunay = nullptr;
1569 }
1570}
1571
1572
1573////////////////////////////////////////////////////////////////////////////////
1574/// Sets the histogram bin height for points lying outside the TGraphDelaunay
1575/// convex hull ie: the bins in the margin.
1576
1578{
1579 fZout = z;
1580 if (fHistogram) {
1581 delete fHistogram;
1582 fHistogram = nullptr;
1583 fDelaunay = nullptr;
1584 }
1585}
1586
1587
1588////////////////////////////////////////////////////////////////////////////////
1589/// Set maximum.
1590
1592{
1593 fMaximum = maximum;
1594 TH1 * h = GetHistogram();
1595 if (h) h->SetMaximum(maximum);
1596}
1597
1598
1599////////////////////////////////////////////////////////////////////////////////
1600/// Set minimum.
1601
1603{
1604 fMinimum = minimum;
1605 TH1 * h = GetHistogram();
1606 if (h) h->SetMinimum(minimum);
1607}
1608
1609
1610////////////////////////////////////////////////////////////////////////////////
1611/// Changes the name of this 2D graph
1612
1613void TGraph2D::SetName(const char *name)
1614{
1615 // 2D graphs are named objects in a THashList.
1616 // We must update the hashlist if we change the name
1617 if (fDirectory) fDirectory->Remove(this);
1618 fName = name;
1619 if (fDirectory) fDirectory->Append(this);
1620}
1621
1622
1623////////////////////////////////////////////////////////////////////////////////
1624/// Change the name and title of this 2D graph
1625///
1626
1627void TGraph2D::SetNameTitle(const char *name, const char *title)
1628{
1629 // 2D graphs are named objects in a THashList.
1630 // We must update the hashlist if we change the name
1631 if (fDirectory) fDirectory->Remove(this);
1632 fName = name;
1633 SetTitle(title);
1634 if (fDirectory) fDirectory->Append(this);
1635}
1636
1637
1638////////////////////////////////////////////////////////////////////////////////
1639/// Sets the number of bins along X used to draw the function
1640
1642{
1643 if (npx < 4) {
1644 Warning("SetNpx", "Number of points must be >4 && < 500, fNpx set to 4");
1645 fNpx = 4;
1646 } else if (npx > 500) {
1647 Warning("SetNpx", "Number of points must be >4 && < 500, fNpx set to 500");
1648 fNpx = 500;
1649 } else {
1650 fNpx = npx;
1651 }
1652 if (fHistogram) {
1653 delete fHistogram;
1654 fHistogram = nullptr;
1655 fDelaunay = nullptr;
1656 }
1657}
1658
1659
1660////////////////////////////////////////////////////////////////////////////////
1661/// Sets the number of bins along Y used to draw the function
1662
1664{
1665 if (npy < 4) {
1666 Warning("SetNpy", "Number of points must be >4 && < 500, fNpy set to 4");
1667 fNpy = 4;
1668 } else if (npy > 500) {
1669 Warning("SetNpy", "Number of points must be >4 && < 500, fNpy set to 500");
1670 fNpy = 500;
1671 } else {
1672 fNpy = npy;
1673 }
1674 if (fHistogram) {
1675 delete fHistogram;
1676 fHistogram = nullptr;
1677 fDelaunay = nullptr;
1678 }
1679}
1680
1681
1682////////////////////////////////////////////////////////////////////////////////
1683/// Sets point number n.
1684/// If n is greater than the current size, the arrays are automatically
1685/// extended.
1686
1688{
1689 if (n < 0) return;
1690
1691 if (!fX || !fY || !fZ || n >= fSize) {
1692 // re-allocate the object
1693 Int_t newN = TMath::Max(2 * fSize, n + 1);
1694 Double_t *savex = new Double_t [newN];
1695 Double_t *savey = new Double_t [newN];
1696 Double_t *savez = new Double_t [newN];
1697 if (fX && fSize) {
1698 memcpy(savex, fX, fSize * sizeof(Double_t));
1699 memset(&savex[fSize], 0, (newN - fSize)*sizeof(Double_t));
1700 delete [] fX;
1701 }
1702 if (fY && fSize) {
1703 memcpy(savey, fY, fSize * sizeof(Double_t));
1704 memset(&savey[fSize], 0, (newN - fSize)*sizeof(Double_t));
1705 delete [] fY;
1706 }
1707 if (fZ && fSize) {
1708 memcpy(savez, fZ, fSize * sizeof(Double_t));
1709 memset(&savez[fSize], 0, (newN - fSize)*sizeof(Double_t));
1710 delete [] fZ;
1711 }
1712 fX = savex;
1713 fY = savey;
1714 fZ = savez;
1715 fSize = newN;
1716 }
1717 fX[n] = x;
1718 fY[n] = y;
1719 fZ[n] = z;
1720 fNpoints = TMath::Max(fNpoints, n + 1);
1721}
1722
1723
1724////////////////////////////////////////////////////////////////////////////////
1725/// Sets the 2D graph title.
1726///
1727/// This method allows to change the global title and the axis' titles of a 2D
1728/// graph. If `g` is the 2D graph one can do:
1729///
1730/// ~~~ {.cpp}
1731/// g->SetTitle("Graph title; X axis title; Y axis title; Z axis title");
1732/// ~~~
1733
1734void TGraph2D::SetTitle(const char* title)
1735{
1736 fTitle = title;
1737 if (fHistogram) fHistogram->SetTitle(title);
1738}
1739
1740
1741////////////////////////////////////////////////////////////////////////////////
1742/// Stream a class object
1743
1745{
1746 if (b.IsReading()) {
1747 UInt_t R__s, R__c;
1748 Version_t R__v = b.ReadVersion(&R__s, &R__c);
1749 b.ReadClassBuffer(TGraph2D::Class(), this, R__v, R__s, R__c);
1750
1752 } else {
1753 b.WriteClassBuffer(TGraph2D::Class(), this);
1754 }
1755}
#define h(i)
Definition: RSha256.hxx:106
#define e(i)
Definition: RSha256.hxx:103
short Version_t
Definition: RtypesCore.h:65
const Bool_t kFALSE
Definition: RtypesCore.h:101
float Float_t
Definition: RtypesCore.h:57
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:375
#define gDirectory
Definition: TDirectory.h:385
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t b
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t np
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t format
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t g
char name[80]
Definition: TGX11.cxx:110
float xmin
Definition: THbookFile.cxx:95
float ymin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
float ymax
Definition: THbookFile.cxx:95
#define gROOT
Definition: TROOT.h:405
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
Definition: TString.cxx:2482
R__EXTERN TSystem * gSystem
Definition: TSystem.h:560
#define gPad
Definition: TVirtualPad.h:302
#define snprintf
Definition: civetweb.c:1540
class describing the range in the coordinates it supports multiple range in a coordinate.
Definition: DataRange.h:35
Fill Area Attributes class.
Definition: TAttFill.h:19
virtual Color_t GetFillColor() const
Return the fill area color.
Definition: TAttFill.h:30
virtual Style_t GetFillStyle() const
Return the fill area style.
Definition: TAttFill.h:31
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition: TAttFill.h:37
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition: TAttFill.h:39
virtual void SaveFillAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1001)
Save fill attributes as C++ statement(s) on output stream out.
Definition: TAttFill.cxx:236
Line Attributes class.
Definition: TAttLine.h:18
virtual Color_t GetLineColor() const
Return the line color.
Definition: TAttLine.h:33
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition: TAttLine.h:42
virtual Width_t GetLineWidth() const
Return the line width.
Definition: TAttLine.h:35
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition: TAttLine.h:43
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition: TAttLine.h:40
virtual Style_t GetLineStyle() const
Return the line style.
Definition: TAttLine.h:34
virtual void SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttLine.cxx:273
Marker Attributes class.
Definition: TAttMarker.h:19
virtual void SaveMarkerAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t sizdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttMarker.cxx:345
virtual Style_t GetMarkerStyle() const
Return the marker style.
Definition: TAttMarker.h:32
virtual void SetMarkerColor(Color_t mcolor=1)
Set the marker color.
Definition: TAttMarker.h:38
virtual Color_t GetMarkerColor() const
Return the marker color.
Definition: TAttMarker.h:31
virtual Size_t GetMarkerSize() const
Return the marker size.
Definition: TAttMarker.h:33
virtual void SetMarkerStyle(Style_t mstyle=1)
Set the marker style.
Definition: TAttMarker.h:40
virtual void SetMarkerSize(Size_t msize=1)
Set the marker size.
Definition: TAttMarker.h:45
Class to manage histogram axis.
Definition: TAxis.h:30
const char * GetTitle() const override
Returns title of object.
Definition: TAxis.h:130
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition: TAxis.cxx:478
Double_t GetXmax() const
Definition: TAxis.h:135
Int_t GetLast() const
Return last bin on the axis i.e.
Definition: TAxis.cxx:469
virtual void SetLimits(Double_t xmin, Double_t xmax)
Definition: TAxis.h:155
Double_t GetXmin() const
Definition: TAxis.h:134
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition: TAxis.cxx:458
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
TDirectory::TContext keeps track and restore the current directory.
Definition: TDirectory.h:89
Describe directory structure in memory.
Definition: TDirectory.h:45
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
Definition: TDirectory.cxx:197
virtual TObject * Remove(TObject *)
Remove an object from the in-memory list.
A 2-Dim function with parameters.
Definition: TF2.h:29
Provides an indirection to the TFitResult class and with a semantics identical to a TFitResult pointe...
Definition: TFitResultPtr.h:32
Graphics object made of three arrays X, Y and Z with the same number of points each.
Definition: TGraph2D.h:41
static TClass * Class()
Int_t fMaxIter
Maximum number of iterations to find Delaunay triangles.
Definition: TGraph2D.h:48
TObject * FindObject(const char *name) const override
search object named name in the list of functions
Definition: TGraph2D.cxx:767
void SetNameTitle(const char *name, const char *title) override
Change the name and title of this 2D graph.
Definition: TGraph2D.cxx:1627
virtual Double_t GetYminE() const
Definition: TGraph2D.h:142
TGraph2D()
Graph2D default constructor.
Definition: TGraph2D.cxx:238
void Build(Int_t n)
Creates the 2D graph basic data structure.
Definition: TGraph2D.cxx:610
Double_t Interpolate(Double_t x, Double_t y)
Finds the z value at the position (x,y) thanks to the Delaunay interpolation.
Definition: TGraph2D.cxx:1205
Int_t fNpoints
Number of points in the data set.
Definition: TGraph2D.h:45
virtual Double_t GetZminE() const
Definition: TGraph2D.h:144
virtual Double_t GetErrorZ(Int_t bin) const
This function is called by Graph2DFitChisquare.
Definition: TGraph2D.cxx:935
Double_t * GetY() const
Definition: TGraph2D.h:122
virtual void FitPanel()
Display a GUI panel with all graph fit options.
Definition: TGraph2D.cxx:837
void SetMarginBinsContent(Double_t z=0.)
Sets the histogram bin height for points lying outside the TGraphDelaunay convex hull ie: the bins in...
Definition: TGraph2D.cxx:1577
Int_t fNpx
Number of bins along X in fHistogram.
Definition: TGraph2D.h:46
void SavePrimitive(std::ostream &out, Option_t *option="") override
Saves primitive as a C++ statement(s) on output stream out.
Definition: TGraph2D.cxx:1424
virtual Double_t GetYmaxE() const
Definition: TGraph2D.h:141
Double_t GetYmin() const
Returns the Y minimum.
Definition: TGraph2D.cxx:1158
Bool_t fUserHisto
Definition: TGraph2D.h:67
Double_t GetZmin() const
Returns the Z minimum.
Definition: TGraph2D.cxx:1180
void Browse(TBrowser *) override
Browse.
Definition: TGraph2D.cxx:647
Double_t * GetX() const
Definition: TGraph2D.h:121
virtual Double_t GetZmaxE() const
Definition: TGraph2D.h:143
Double_t * fZ
[fNpoints]
Definition: TGraph2D.h:52
void Streamer(TBuffer &) override
Stream a class object.
Definition: TGraph2D.cxx:1744
virtual Double_t GetErrorX(Int_t bin) const
This function is called by Graph2DFitChisquare.
Definition: TGraph2D.cxx:915
Double_t fMargin
Extra space (in %) around interpolated area for fHistogram.
Definition: TGraph2D.h:55
Double_t fMinimum
Minimum value for plotting along z.
Definition: TGraph2D.h:53
Double_t GetXmin() const
Returns the X minimum.
Definition: TGraph2D.cxx:1136
void Print(Option_t *chopt="") const override
Print 2D graph values.
Definition: TGraph2D.cxx:1284
TH2D * GetHistogram(Option_t *option="")
By default returns a pointer to the Delaunay histogram.
Definition: TGraph2D.cxx:979
TVirtualHistPainter * fPainter
!Pointer to histogram painter
Definition: TGraph2D.h:61
virtual TFitResultPtr Fit(const char *formula, Option_t *option="", Option_t *goption="")
Fits this graph with function with name fname Predefined functions such as gaus, expo and poln are au...
Definition: TGraph2D.cxx:791
Double_t GetZmax() const
Returns the Z maximum.
Definition: TGraph2D.cxx:1169
Int_t RemovePoint(Int_t ipoint)
Deletes point number ipoint.
Definition: TGraph2D.cxx:1388
Double_t fMaximum
Maximum value for plotting along z.
Definition: TGraph2D.h:54
~TGraph2D() override
TGraph2D destructor.
Definition: TGraph2D.cxx:556
TAxis * GetZaxis() const
Get z axis of the graph.
Definition: TGraph2D.cxx:883
void SetMargin(Double_t m=0.1)
Sets the extra space (in %) around interpolated area for the 2D histogram.
Definition: TGraph2D.cxx:1557
void SetName(const char *name) override
Changes the name of this 2D graph.
Definition: TGraph2D.cxx:1613
void SetNpy(Int_t npx=40)
Sets the number of bins along Y used to draw the function.
Definition: TGraph2D.cxx:1663
Double_t fZout
fHistogram bin height for points lying outside the interpolated area
Definition: TGraph2D.h:56
void SetTitle(const char *title="") override
Sets the 2D graph title.
Definition: TGraph2D.cxx:1734
TH2D * fHistogram
!2D histogram of z values linearly interpolated on the triangles
Definition: TGraph2D.h:58
virtual Double_t GetXminE() const
Definition: TGraph2D.h:140
TList * GetContourList(Double_t contour)
Returns the X and Y graphs building a contour.
Definition: TGraph2D.cxx:896
Double_t GetXmax() const
Returns the X maximum.
Definition: TGraph2D.cxx:1125
virtual Int_t GetPoint(Int_t i, Double_t &x, Double_t &y, Double_t &z) const
Get x, y and z values for point number i.
Definition: TGraph2D.cxx:1191
TAxis * GetYaxis() const
Get y axis of the graph.
Definition: TGraph2D.cxx:872
virtual Double_t GetErrorY(Int_t bin) const
This function is called by Graph2DFitChisquare.
Definition: TGraph2D.cxx:925
TObject * fDelaunay
! Pointer to Delaunay interpolator object
Definition: TGraph2D.h:59
TH1 * Project(Option_t *option="x") const
Projects a 2-d graph into 1 or 2-d histograms depending on the option parameter.
Definition: TGraph2D.cxx:1301
Int_t GetN() const
Definition: TGraph2D.h:120
virtual Double_t GetXmaxE() const
Definition: TGraph2D.h:139
virtual void Set(Int_t n)
Set number of points in the 2D graph.
Definition: TGraph2D.cxx:1500
void SetMinimum(Double_t minimum=-1111)
Set minimum.
Definition: TGraph2D.cxx:1602
TGraph2D & operator=(const TGraph2D &)
Graph2D operator "=".
Definition: TGraph2D.cxx:565
Double_t * fX
[fNpoints]
Definition: TGraph2D.h:50
Double_t * fY
[fNpoints] Data set to be plotted
Definition: TGraph2D.h:51
virtual void SetHistogram(TH2 *h, Option_t *option="")
Sets the histogram to be filled.
Definition: TGraph2D.cxx:1540
void SetMaximum(Double_t maximum=-1111)
Set maximum.
Definition: TGraph2D.cxx:1591
Double_t GetYmax() const
Returns the Y maximum.
Definition: TGraph2D.cxx:1147
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Computes distance from point px,py to a graph.
Definition: TGraph2D.cxx:706
virtual void SetDirectory(TDirectory *dir)
By default when an 2D graph is created, it is added to the list of 2D graph objects in the current di...
Definition: TGraph2D.cxx:1516
TDirectory * fDirectory
!Pointer to directory holding this 2D graph
Definition: TGraph2D.h:60
void Clear(Option_t *option="") override
Free all memory allocated by this object.
Definition: TGraph2D.cxx:657
virtual void Scale(Double_t c1=1., Option_t *option="z")
Multiply the values of a TGraph2D by a constant c1.
Definition: TGraph2D.cxx:1478
virtual void DirectoryAutoAdd(TDirectory *)
Perform the automatic addition of the graph to the given directory.
Definition: TGraph2D.cxx:691
void CreateInterpolator(Bool_t oldInterp)
Add a TGraphDelaunay in the list of the fHistogram's functions.
Definition: TGraph2D.cxx:944
Int_t fNpy
Number of bins along Y in fHistogram.
Definition: TGraph2D.h:47
TList * fFunctions
Pointer to list of functions (fits and user)
Definition: TGraph2D.h:57
virtual void SetPoint(Int_t point, Double_t x, Double_t y, Double_t z)
Sets point number n.
Definition: TGraph2D.cxx:1687
void Paint(Option_t *option="") override
Paints this 2D graph with its current attributes.
Definition: TGraph2D.cxx:1242
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Executes action corresponding to one event.
Definition: TGraph2D.cxx:758
void Draw(Option_t *option="P0") override
Specific drawing options can be used to paint a TGraph2D:
Definition: TGraph2D.cxx:738
Int_t fSize
!Real size of fX, fY and fZ
Definition: TGraph2D.h:49
@ kOldInterpolation
Definition: TGraph2D.h:70
TAxis * GetXaxis() const
Get x axis of the graph.
Definition: TGraph2D.cxx:861
Double_t * GetZ() const
Definition: TGraph2D.h:123
void SetNpx(Int_t npx=40)
Sets the number of bins along X used to draw the function.
Definition: TGraph2D.cxx:1641
TGraphDelaunay2D generates a Delaunay triangulation of a TGraph2D.
static TClass * Class()
void SetMarginBinsContent(Double_t z=0.)
TGraphDelaunay generates a Delaunay triangulation of a TGraph2D.
static TClass * Class()
void SetMarginBinsContent(Double_t z=0.)
Sets the histogram bin height for points lying outside the convex hull ie: the bins in the margin.
void SetMaxIter(Int_t n=100000)
Defines the number of triangles tested for a Delaunay triangle (number of iterations) before abandoni...
1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:620
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Compute distance from point px,py to a line.
Definition: TH1.cxx:2798
void SetTitle(const char *title) override
Change (i.e.
Definition: TH1.cxx:6700
virtual Int_t GetNbinsY() const
Definition: TH1.h:296
virtual Double_t GetBinError(Int_t bin) const
Return value of error associated to bin number bin.
Definition: TH1.cxx:8929
@ kNoStats
Don't draw stats box.
Definition: TH1.h:163
TAxis * GetXaxis()
Definition: TH1.h:322
TVirtualHistPainter * GetPainter(Option_t *option="")
Return pointer to painter.
Definition: TH1.cxx:4484
virtual Int_t GetNbinsX() const
Definition: TH1.h:295
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:400
virtual Int_t Fill(Double_t x)
Increment bin with abscissa X by 1.
Definition: TH1.cxx:3338
TAxis * GetYaxis()
Definition: TH1.h:323
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:401
virtual Double_t GetEntries() const
Return the current number of entries.
Definition: TH1.cxx:4419
TList * GetListOfFunctions() const
Definition: TH1.h:242
void Paint(Option_t *option="") override
Control routine to paint any kind of histograms.
Definition: TH1.cxx:6188
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute action corresponding to one event.
Definition: TH1.cxx:3234
static Bool_t AddDirectoryStatus()
Static function: cannot be inlined on Windows/NT.
Definition: TH1.cxx:735
2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:300
Service class for 2-D histogram classes.
Definition: TH2.h:30
Double_t GetBinContent(Int_t binx, Int_t biny) const override
Definition: TH2.h:89
Int_t Fill(Double_t) override
Invalid Fill method.
Definition: TH2.cxx:347
A doubly linked list.
Definition: TList.h:38
TObject * FindObject(const char *name) const override
Find an object in this list using its name.
Definition: TList.cxx:578
void Add(TObject *obj) override
Definition: TList.h:81
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:470
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
const char * GetName() const override
Returns name of object.
Definition: TNamed.h:47
const char * GetTitle() const override
Returns title of object.
Definition: TNamed.h:48
TString fTitle
Definition: TNamed.h:33
TString fName
Definition: TNamed.h:32
Mother of all ROOT objects.
Definition: TObject.h:41
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:439
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:201
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:955
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition: TObject.cxx:184
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a primitive as a C++ statement(s) on output stream "out".
Definition: TObject.cxx:745
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:774
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:525
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:969
virtual TClass * IsA() const
Definition: TObject.h:245
void MakeZombie()
Definition: TObject.h:53
void ResetBit(UInt_t f)
Definition: TObject.h:200
@ kCanDelete
if object in a list can be deleted
Definition: TObject.h:62
@ kInvalidObject
if object ctor succeeded but object should not be used
Definition: TObject.h:72
@ kMustCleanup
if object destructor must call RecursiveRemove()
Definition: TObject.h:64
Longptr_t ExecPlugin(int nargs, const T &... params)
Int_t LoadPlugin()
Load the plugin library for this handler.
SCoord_t fY
Definition: TPoint.h:36
SCoord_t fX
Definition: TPoint.h:35
Basic string class.
Definition: TString.h:136
Ssiz_t Length() const
Definition: TString.h:410
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1171
Int_t Atoi() const
Return integer value of string.
Definition: TString.cxx:1967
Double_t Atof() const
Return floating-point value contained in string.
Definition: TString.cxx:2033
Bool_t IsFloat() const
Returns kTRUE if string contains a floating point or integer number.
Definition: TString.cxx:1837
const char * Data() const
Definition: TString.h:369
Bool_t IsDigit() const
Returns true if all characters in string are digits (0-9) or white spaces, i.e.
Definition: TString.cxx:1809
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:693
TString & Append(const char *cs)
Definition: TString.h:565
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition: TString.cxx:2357
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:625
virtual Bool_t ExpandPathName(TString &path)
Expand a pathname getting rid of special shell characters like ~.
Definition: TSystem.cxx:1277
virtual TList * GetContourList(Double_t contour) const =0
TLine * line
Double_t y[n]
Definition: legend1.C:17
return c1
Definition: legend1.C:41
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
TH1F * h1
Definition: legend1.C:5
TFitResultPtr FitObject(TH1 *h1, TF1 *f1, Foption_t &option, const ROOT::Math::MinimizerOptions &moption, const char *goption, ROOT::Fit::DataRange &range)
fitting function for a TH1 (called from TH1::Fit)
Definition: HFitImpl.cxx:965
void FitOptionsMake(EFitObjectType type, const char *option, Foption_t &fitOption)
Decode list of options into fitOption.
Definition: HFitImpl.cxx:684
Short_t Max(Short_t a, Short_t b)
Returns the largest of a and b.
Definition: TMathBase.h:250
Double_t QuietNaN()
Returns a quiet NaN as defined by IEEE 754.
Definition: TMath.h:900
Bool_t AreEqualRel(Double_t af, Double_t bf, Double_t relPrec)
Comparing floating points.
Definition: TMath.h:425
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition: TMathBase.h:123
TMarker m
Definition: textangle.C:8
double epsilon
Definition: triangle.c:618