Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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 = nullptr;
247 fHistogram = nullptr;
248 fDelaunay = nullptr;
249 fMaximum = -1111;
250 fMinimum = -1111;
251 fX = nullptr;
252 fY = nullptr;
253 fZ = nullptr;
254 fZout = 0;
255 fMaxIter = 100000;
256 fPainter = nullptr;
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 = nullptr ;
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.empty()) {
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 != nullptr && 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(nullptr, 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 = nullptr ;
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(nullptr), fY(nullptr), fZ(nullptr),
533 fHistogram(nullptr), fDirectory(nullptr), fPainter(nullptr)
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] : nullptr;
585 fY = (fSize > 0) ? new Double_t[fSize] : nullptr;
586 fZ = (fSize > 0) ? new Double_t[fSize] : nullptr;
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 = nullptr;
622 fHistogram = nullptr;
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 = nullptr;
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 = nullptr;
661 if (fY) delete [] fY;
662 fY = nullptr;
663 if (fZ) delete [] fZ;
664 fZ = nullptr;
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 = nullptr;
676 }
677 if (fDirectory) {
678 fDirectory->Remove(this);
679 fDirectory = nullptr;
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{
760 if (fHistogram) fHistogram->ExecuteEvent(event, px, py);
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 nullptr;
771}
772
773
774////////////////////////////////////////////////////////////////////////////////
775/// search object obj in the list of functions
776
778{
779 if (fFunctions) return fFunctions->FindObject(obj);
780 return nullptr;
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 nullptr;
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 nullptr;
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 nullptr;
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 nullptr;
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 Double_t hzmax, hzmin;
1069 if (empty) {
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 hzmin = GetZminE();
1115 hzmax = GetZmaxE();
1116 if (hzmin < fHistogram->GetMinimum()) fHistogram->SetMinimum(hzmin);
1117 if (hzmax > fHistogram->GetMaximum()) fHistogram->SetMaximum(hzmax);
1118
1119 if (fMinimum != -1111) fHistogram->SetMinimum(fMinimum);
1120 if (fMaximum != -1111) fHistogram->SetMaximum(fMaximum);
1121
1122 return fHistogram;
1123}
1124
1125
1126////////////////////////////////////////////////////////////////////////////////
1127/// Returns the X maximum
1128
1130{
1131 Double_t v = fX[0];
1132 for (Int_t i = 1; i < fNpoints; i++) if (fX[i] > v) v = fX[i];
1133 return v;
1134}
1135
1136
1137////////////////////////////////////////////////////////////////////////////////
1138/// Returns the X minimum
1139
1141{
1142 Double_t v = fX[0];
1143 for (Int_t i = 1; i < fNpoints; i++) if (fX[i] < v) v = fX[i];
1144 return v;
1145}
1146
1147
1148////////////////////////////////////////////////////////////////////////////////
1149/// Returns the Y maximum
1150
1152{
1153 Double_t v = fY[0];
1154 for (Int_t i = 1; i < fNpoints; i++) if (fY[i] > v) v = fY[i];
1155 return v;
1156}
1157
1158
1159////////////////////////////////////////////////////////////////////////////////
1160/// Returns the Y minimum
1161
1163{
1164 Double_t v = fY[0];
1165 for (Int_t i = 1; i < fNpoints; i++) if (fY[i] < v) v = fY[i];
1166 return v;
1167}
1168
1169
1170////////////////////////////////////////////////////////////////////////////////
1171/// Returns the Z maximum
1172
1174{
1175 Double_t v = fZ[0];
1176 for (Int_t i = 1; i < fNpoints; i++) if (fZ[i] > v) v = fZ[i];
1177 return v;
1178}
1179
1180
1181////////////////////////////////////////////////////////////////////////////////
1182/// Returns the Z minimum
1183
1185{
1186 Double_t v = fZ[0];
1187 for (Int_t i = 1; i < fNpoints; i++) if (fZ[i] < v) v = fZ[i];
1188 return v;
1189}
1190
1191////////////////////////////////////////////////////////////////////////////////
1192/// Get x, y and z values for point number i.
1193/// The function returns -1 in case of an invalid request or the point number otherwise
1194
1196{
1197 if (i < 0 || i >= fNpoints) return -1;
1198 if (!fX || !fY || !fZ) return -1;
1199 x = fX[i];
1200 y = fY[i];
1201 z = fZ[i];
1202 return i;
1203}
1204
1205////////////////////////////////////////////////////////////////////////////////
1206/// Finds the z value at the position (x,y) thanks to
1207/// the Delaunay interpolation.
1208
1210{
1211 if (fNpoints <= 0) {
1212 Error("Interpolate", "Empty TGraph2D");
1213 return 0;
1214 }
1215
1216 if (!fHistogram) GetHistogram("empty");
1217 if (!fDelaunay) {
1219 if (!TestBit(kOldInterpolation) ) {
1220 fDelaunay = hl->FindObject("TGraphDelaunay2D");
1221 if (!fDelaunay) fDelaunay = hl->FindObject("TGraphDelaunay");
1222 }
1223 else {
1224 // if using old implementation
1225 fDelaunay = hl->FindObject("TGraphDelaunay");
1226 if (!fDelaunay) fDelaunay = hl->FindObject("TGraphDelaunay2D");
1227 }
1228 }
1229
1230 if (!fDelaunay) return TMath::QuietNaN();
1231
1233 return ((TGraphDelaunay2D*)fDelaunay)->ComputeZ(x, y);
1234 else if (fDelaunay->IsA() == TGraphDelaunay::Class() )
1235 return ((TGraphDelaunay*)fDelaunay)->ComputeZ(x, y);
1236
1237 // cannot be here
1238 assert(false);
1239 return TMath::QuietNaN();
1240}
1241
1242
1243////////////////////////////////////////////////////////////////////////////////
1244/// Paints this 2D graph with its current attributes
1245
1247{
1248 if (fNpoints <= 0) {
1249 Error("Paint", "Empty TGraph2D");
1250 return;
1251 }
1252
1253 TString opt = option;
1254 opt.ToLower();
1255 if (opt.Contains("p") && !opt.Contains("tri")) {
1256 if (!opt.Contains("pol") &&
1257 !opt.Contains("sph") &&
1258 !opt.Contains("psr")) opt.Append("tri0");
1259 }
1260
1261 if (opt.Contains("line") && !opt.Contains("tri")) opt.Append("tri0");
1262
1263 if (opt.Contains("err") && !opt.Contains("tri")) opt.Append("tri0");
1264
1265 if (opt.Contains("tri0")) {
1266 GetHistogram("empty");
1267 } else if (opt.Contains("old")) {
1268 GetHistogram("old");
1269 } else {
1270 GetHistogram();
1271 }
1272
1281 fHistogram->Paint(opt.Data());
1282}
1283
1284
1285////////////////////////////////////////////////////////////////////////////////
1286/// Print 2D graph values.
1287
1289{
1290 for (Int_t i = 0; i < fNpoints; i++) {
1291 printf("x[%d]=%g, y[%d]=%g, z[%d]=%g\n", i, fX[i], i, fY[i], i, fZ[i]);
1292 }
1293}
1294
1295
1296////////////////////////////////////////////////////////////////////////////////
1297/// Projects a 2-d graph into 1 or 2-d histograms depending on the option parameter.
1298/// option may contain a combination of the characters x,y,z:
1299///
1300/// - option = "x" return the x projection into a TH1D histogram
1301/// - option = "y" return the y projection into a TH1D histogram
1302/// - option = "xy" return the x versus y projection into a TH2D histogram
1303/// - option = "yx" return the y versus x projection into a TH2D histogram
1304
1306{
1307 if (fNpoints <= 0) {
1308 Error("Project", "Empty TGraph2D");
1309 return nullptr;
1310 }
1311
1312 TString opt = option;
1313 opt.ToLower();
1314
1315 Int_t pcase = 0;
1316 if (opt.Contains("x")) pcase = 1;
1317 if (opt.Contains("y")) pcase = 2;
1318 if (opt.Contains("xy")) pcase = 3;
1319 if (opt.Contains("yx")) pcase = 4;
1320
1321 // Create the projection histogram
1322 TH1D *h1 = nullptr;
1323 TH2D *h2 = nullptr;
1324 Int_t nch = strlen(GetName()) + opt.Length() + 2;
1325 char *name = new char[nch];
1326 snprintf(name, nch, "%s_%s", GetName(), option);
1327 nch = strlen(GetTitle()) + opt.Length() + 2;
1328 char *title = new char[nch];
1329 snprintf(title, nch, "%s_%s", GetTitle(), option);
1330
1331 Double_t hxmin = GetXmin();
1332 Double_t hxmax = GetXmax();
1333 Double_t hymin = GetYmin();
1334 Double_t hymax = GetYmax();
1335
1336 switch (pcase) {
1337 case 1:
1338 // "x"
1339 h1 = new TH1D(name, title, fNpx, hxmin, hxmax);
1340 break;
1341 case 2:
1342 // "y"
1343 h1 = new TH1D(name, title, fNpy, hymin, hymax);
1344 break;
1345 case 3:
1346 // "xy"
1347 h2 = new TH2D(name, title, fNpx, hxmin, hxmax, fNpy, hymin, hymax);
1348 break;
1349 case 4:
1350 // "yx"
1351 h2 = new TH2D(name, title, fNpy, hymin, hymax, fNpx, hxmin, hxmax);
1352 break;
1353 }
1354
1355 delete [] name;
1356 delete [] title;
1357 TH1 *h = h1;
1358 if (h2) h = h2;
1359 if (h == nullptr) return nullptr;
1360
1361 // Fill the projected histogram
1362 Double_t entries = 0;
1363 for (Int_t n = 0; n < fNpoints; n++) {
1364 switch (pcase) {
1365 case 1:
1366 // "x"
1367 h1->Fill(fX[n], fZ[n]);
1368 break;
1369 case 2:
1370 // "y"
1371 h1->Fill(fY[n], fZ[n]);
1372 break;
1373 case 3:
1374 // "xy"
1375 h2->Fill(fX[n], fY[n], fZ[n]);
1376 break;
1377 case 4:
1378 // "yx"
1379 h2->Fill(fY[n], fX[n], fZ[n]);
1380 break;
1381 }
1382 entries += fZ[n];
1383 }
1384 h->SetEntries(entries);
1385 return h;
1386}
1387
1388
1389////////////////////////////////////////////////////////////////////////////////
1390/// Deletes point number ipoint
1391
1393{
1394 if (ipoint < 0) return -1;
1395 if (ipoint >= fNpoints) return -1;
1396
1397 fNpoints--;
1398 Double_t *newX = new Double_t[fNpoints];
1399 Double_t *newY = new Double_t[fNpoints];
1400 Double_t *newZ = new Double_t[fNpoints];
1401 Int_t j = -1;
1402 for (Int_t i = 0; i < fNpoints + 1; i++) {
1403 if (i == ipoint) continue;
1404 j++;
1405 newX[j] = fX[i];
1406 newY[j] = fY[i];
1407 newZ[j] = fZ[i];
1408 }
1409 delete [] fX;
1410 delete [] fY;
1411 delete [] fZ;
1412 fX = newX;
1413 fY = newY;
1414 fZ = newZ;
1415 fSize = fNpoints;
1416 if (fHistogram) {
1417 delete fHistogram;
1418 fHistogram = nullptr;
1419 fDelaunay = nullptr;
1420 }
1421 return ipoint;
1422}
1423
1424
1425////////////////////////////////////////////////////////////////////////////////
1426/// Saves primitive as a C++ statement(s) on output stream out
1427
1428void TGraph2D::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
1429{
1430 char quote = '"';
1431 out << " " << std::endl;
1432 if (gROOT->ClassSaved(TGraph2D::Class())) {
1433 out << " ";
1434 } else {
1435 out << " TGraph2D *";
1436 }
1437
1438 out << "graph2d = new TGraph2D(" << fNpoints << ");" << std::endl;
1439 out << " graph2d->SetName(" << quote << GetName() << quote << ");" << std::endl;
1440 out << " graph2d->SetTitle(" << quote << GetTitle() << ";"
1441 << GetXaxis()->GetTitle() << ";"
1442 << GetYaxis()->GetTitle() << ";"
1443 << GetZaxis()->GetTitle() << quote << ");" << std::endl;
1444
1445 if (fDirectory == nullptr) {
1446 out << " graph2d->SetDirectory(0);" << std::endl;
1447 }
1448
1449 SaveFillAttributes(out, "graph2d", 0, 1001);
1450 SaveLineAttributes(out, "graph2d", 1, 1, 1);
1451 SaveMarkerAttributes(out, "graph2d", 1, 1, 1);
1452
1453 for (Int_t i = 0; i < fNpoints; i++) {
1454 out << " graph2d->SetPoint(" << i << "," << fX[i] << "," << fY[i] << "," << fZ[i] << ");" << std::endl;
1455 }
1456
1457 // save list of functions
1458 TIter next(fFunctions);
1459 TObject *obj;
1460 while ((obj = next())) {
1461 obj->SavePrimitive(out, "nodraw");
1462 out << " graph2d->GetListOfFunctions()->Add(" << obj->GetName() << ");" << std::endl;
1463 if (obj->InheritsFrom("TPaveStats")) {
1464 out << " ptstats->SetParent(graph2d->GetListOfFunctions());" << std::endl;
1465 } else if (obj->InheritsFrom("TF1")) {
1466 out << " " << obj->GetName() << "->SetParent(graph);\n";
1467 }
1468
1469 }
1470
1471 out << " graph2d->Draw(" << quote << option << quote << ");" << std::endl;
1472}
1473
1474////////////////////////////////////////////////////////////////////////////////
1475/// Multiply the values of a TGraph2D by a constant c1.
1476///
1477/// If option contains "x" the x values are scaled
1478/// If option contains "y" the y values are scaled
1479/// If option contains "z" the z values are scaled
1480/// If option contains "xyz" all three x, y and z values are scaled
1481
1483{
1484 TString opt = option; opt.ToLower();
1485 if (opt.Contains("x")) {
1486 for (Int_t i=0; i<GetN(); i++)
1487 GetX()[i] *= c1;
1488 }
1489 if (opt.Contains("y")) {
1490 for (Int_t i=0; i<GetN(); i++)
1491 GetY()[i] *= c1;
1492 }
1493 if (opt.Contains("z")) {
1494 for (Int_t i=0; i<GetN(); i++)
1495 GetZ()[i] *= c1;
1496 }
1497}
1498
1499////////////////////////////////////////////////////////////////////////////////
1500/// Set number of points in the 2D graph.
1501/// Existing coordinates are preserved.
1502/// New coordinates above fNpoints are preset to 0.
1503
1505{
1506 if (n < 0) n = 0;
1507 if (n == fNpoints) return;
1508 if (n > fNpoints) SetPoint(n, 0, 0, 0);
1509 fNpoints = n;
1510}
1511
1512
1513////////////////////////////////////////////////////////////////////////////////
1514/// By default when an 2D graph is created, it is added to the list
1515/// of 2D graph objects in the current directory in memory.
1516/// This method removes reference to this 2D graph from current directory and add
1517/// reference to new directory dir. dir can be 0 in which case the
1518/// 2D graph does not belong to any directory.
1519
1521{
1522 if (fDirectory == dir) return;
1523 if (fDirectory) fDirectory->Remove(this);
1524 fDirectory = dir;
1525 if (fDirectory) fDirectory->Append(this);
1526}
1527
1528
1529////////////////////////////////////////////////////////////////////////////////
1530/// Sets the histogram to be filled.
1531/// If the 2D graph needs to be save in a TFile the following set should be
1532/// followed to read it back:
1533/// 1. Create TGraph2D
1534/// 2. Call g->SetHistogram(h), and do whatever you need to do
1535/// 3. Save g and h to the TFile, exit
1536/// 4. Open the TFile, retrieve g and h
1537/// 5. Call h->SetDirectory(0)
1538/// 6. Call g->SetHistogram(h) again
1539/// 7. Carry on as normal
1540///
1541/// By default use the new interpolation routine based on Triangles
1542/// If the option "old" the old interpolation is used
1543
1545{
1546 TString opt = option;
1547 opt.ToLower();
1548 Bool_t oldInterp = opt.Contains("old");
1549
1550 fUserHisto = kTRUE;
1551 fHistogram = (TH2D*)h;
1552 fNpx = h->GetNbinsX();
1553 fNpy = h->GetNbinsY();
1554 CreateInterpolator(oldInterp);
1555}
1556
1557
1558////////////////////////////////////////////////////////////////////////////////
1559/// Sets the extra space (in %) around interpolated area for the 2D histogram
1560
1562{
1563 if (m < 0 || m > 1) {
1564 Warning("SetMargin", "The margin must be >= 0 && <= 1, fMargin set to 0.1");
1565 fMargin = 0.1;
1566 } else {
1567 fMargin = m;
1568 }
1569 if (fHistogram) {
1570 delete fHistogram;
1571 fHistogram = nullptr;
1572 fDelaunay = nullptr;
1573 }
1574}
1575
1576
1577////////////////////////////////////////////////////////////////////////////////
1578/// Sets the histogram bin height for points lying outside the TGraphDelaunay
1579/// convex hull ie: the bins in the margin.
1580
1582{
1583 fZout = z;
1584 if (fHistogram) {
1585 delete fHistogram;
1586 fHistogram = nullptr;
1587 fDelaunay = nullptr;
1588 }
1589}
1590
1591
1592////////////////////////////////////////////////////////////////////////////////
1593/// Set maximum.
1594
1596{
1597 fMaximum = maximum;
1598 TH1 * h = GetHistogram();
1599 if (h) h->SetMaximum(maximum);
1600}
1601
1602
1603////////////////////////////////////////////////////////////////////////////////
1604/// Set minimum.
1605
1607{
1608 fMinimum = minimum;
1609 TH1 * h = GetHistogram();
1610 if (h) h->SetMinimum(minimum);
1611}
1612
1613
1614////////////////////////////////////////////////////////////////////////////////
1615/// Changes the name of this 2D graph
1616
1617void TGraph2D::SetName(const char *name)
1618{
1619 // 2D graphs are named objects in a THashList.
1620 // We must update the hashlist if we change the name
1621 if (fDirectory) fDirectory->Remove(this);
1622 fName = name;
1623 if (fDirectory) fDirectory->Append(this);
1624}
1625
1626
1627////////////////////////////////////////////////////////////////////////////////
1628/// Change the name and title of this 2D graph
1629///
1630
1631void TGraph2D::SetNameTitle(const char *name, const char *title)
1632{
1633 // 2D graphs are named objects in a THashList.
1634 // We must update the hashlist if we change the name
1635 if (fDirectory) fDirectory->Remove(this);
1636 fName = name;
1637 SetTitle(title);
1638 if (fDirectory) fDirectory->Append(this);
1639}
1640
1641
1642////////////////////////////////////////////////////////////////////////////////
1643/// Sets the number of bins along X used to draw the function
1644
1646{
1647 if (npx < 4) {
1648 Warning("SetNpx", "Number of points must be >4 && < 500, fNpx set to 4");
1649 fNpx = 4;
1650 } else if (npx > 500) {
1651 Warning("SetNpx", "Number of points must be >4 && < 500, fNpx set to 500");
1652 fNpx = 500;
1653 } else {
1654 fNpx = npx;
1655 }
1656 if (fHistogram) {
1657 delete fHistogram;
1658 fHistogram = nullptr;
1659 fDelaunay = nullptr;
1660 }
1661}
1662
1663
1664////////////////////////////////////////////////////////////////////////////////
1665/// Sets the number of bins along Y used to draw the function
1666
1668{
1669 if (npy < 4) {
1670 Warning("SetNpy", "Number of points must be >4 && < 500, fNpy set to 4");
1671 fNpy = 4;
1672 } else if (npy > 500) {
1673 Warning("SetNpy", "Number of points must be >4 && < 500, fNpy set to 500");
1674 fNpy = 500;
1675 } else {
1676 fNpy = npy;
1677 }
1678 if (fHistogram) {
1679 delete fHistogram;
1680 fHistogram = nullptr;
1681 fDelaunay = nullptr;
1682 }
1683}
1684
1685
1686////////////////////////////////////////////////////////////////////////////////
1687/// Sets point number n.
1688/// If n is greater than the current size, the arrays are automatically
1689/// extended.
1690
1692{
1693 if (n < 0) return;
1694
1695 if (!fX || !fY || !fZ || n >= fSize) {
1696 // re-allocate the object
1697 Int_t newN = TMath::Max(2 * fSize, n + 1);
1698 Double_t *savex = new Double_t [newN];
1699 Double_t *savey = new Double_t [newN];
1700 Double_t *savez = new Double_t [newN];
1701 if (fX && fSize) {
1702 memcpy(savex, fX, fSize * sizeof(Double_t));
1703 memset(&savex[fSize], 0, (newN - fSize)*sizeof(Double_t));
1704 delete [] fX;
1705 }
1706 if (fY && fSize) {
1707 memcpy(savey, fY, fSize * sizeof(Double_t));
1708 memset(&savey[fSize], 0, (newN - fSize)*sizeof(Double_t));
1709 delete [] fY;
1710 }
1711 if (fZ && fSize) {
1712 memcpy(savez, fZ, fSize * sizeof(Double_t));
1713 memset(&savez[fSize], 0, (newN - fSize)*sizeof(Double_t));
1714 delete [] fZ;
1715 }
1716 fX = savex;
1717 fY = savey;
1718 fZ = savez;
1719 fSize = newN;
1720 }
1721 fX[n] = x;
1722 fY[n] = y;
1723 fZ[n] = z;
1724 fNpoints = TMath::Max(fNpoints, n + 1);
1725}
1726
1727
1728////////////////////////////////////////////////////////////////////////////////
1729/// Sets the 2D graph title.
1730///
1731/// This method allows to change the global title and the axis' titles of a 2D
1732/// graph. If `g` is the 2D graph one can do:
1733///
1734/// ~~~ {.cpp}
1735/// g->SetTitle("Graph title; X axis title; Y axis title; Z axis title");
1736/// ~~~
1737
1738void TGraph2D::SetTitle(const char* title)
1739{
1740 fTitle = title;
1741 if (fHistogram) fHistogram->SetTitle(title);
1742}
1743
1744
1745////////////////////////////////////////////////////////////////////////////////
1746/// Stream a class object
1747
1749{
1750 if (b.IsReading()) {
1751 UInt_t R__s, R__c;
1752 Version_t R__v = b.ReadVersion(&R__s, &R__c);
1753 b.ReadClassBuffer(TGraph2D::Class(), this, R__v, R__s, R__c);
1754
1756 } else {
1757 b.WriteClassBuffer(TGraph2D::Class(), this);
1758 }
1759}
#define b(i)
Definition RSha256.hxx:100
#define g(i)
Definition RSha256.hxx:105
#define h(i)
Definition RSha256.hxx:106
#define e(i)
Definition RSha256.hxx:103
short Version_t
Definition RtypesCore.h:65
float Float_t
Definition RtypesCore.h:57
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
double Double_t
Definition RtypesCore.h:59
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
const char Option_t
Definition RtypesCore.h:66
#define ClassImp(name)
Definition Rtypes.h:377
#define gDirectory
Definition TDirectory.h:384
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 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
char name[80]
Definition TGX11.cxx:110
float xmin
float ymin
float xmax
float ymax
#define gROOT
Definition TROOT.h:406
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
Definition TString.cxx:2503
R__EXTERN TSystem * gSystem
Definition TSystem.h:560
#define gPad
#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:239
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:275
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.
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:31
const char * GetTitle() const override
Returns title of object.
Definition TAxis.h:135
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition TAxis.cxx:478
Double_t GetXmax() const
Definition TAxis.h:140
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:164
Double_t GetXmin() const
Definition TAxis.h:139
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.
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...
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.
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.
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 GetMinimum() const
Definition TGraph2D.h:116
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...
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.
virtual Double_t GetYmaxE() const
Definition TGraph2D.h:141
Double_t GetYmin() const
Returns the Y minimum.
Bool_t fUserHisto
Definition TGraph2D.h:67
Double_t GetZmin() const
Returns the Z minimum.
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.
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.
void Print(Option_t *chopt="") const override
Print 2D graph values.
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.
Int_t RemovePoint(Int_t ipoint)
Deletes point number ipoint.
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.
void SetName(const char *name) override
Changes the name of this 2D graph.
void SetNpy(Int_t npx=40)
Sets the number of bins along Y used to draw the function.
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.
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.
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.
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.
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.
void SetMinimum(Double_t minimum=-1111)
Set minimum.
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.
void SetMaximum(Double_t maximum=-1111)
Set maximum.
Double_t GetYmax() const
Returns the Y maximum.
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...
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.
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.
void Paint(Option_t *option="") override
Paints this 2D graph with its current attributes.
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.
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:664
TH1 is the base class of all histogram classes in ROOT.
Definition TH1.h:59
TAxis * GetZaxis()
Definition TH1.h:326
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Compute distance from point px,py to a line.
Definition TH1.cxx:2819
void SetTitle(const char *title) override
Change/set the title.
Definition TH1.cxx:6682
@ kNoStats
Don't draw stats box.
Definition TH1.h:165
TAxis * GetXaxis()
Definition TH1.h:324
TVirtualHistPainter * GetPainter(Option_t *option="")
Return pointer to painter.
Definition TH1.cxx:4484
virtual Double_t GetMaximum(Double_t maxval=FLT_MAX) const
Return maximum value smaller than maxval of bins in the range, unless the value has been overridden b...
Definition TH1.cxx:8510
virtual void SetMaximum(Double_t maximum=-1111)
Definition TH1.h:403
virtual Int_t Fill(Double_t x)
Increment bin with abscissa X by 1.
Definition TH1.cxx:3340
TAxis * GetYaxis()
Definition TH1.h:325
virtual void SetMinimum(Double_t minimum=-1111)
Definition TH1.h:404
virtual Double_t GetEntries() const
Return the current number of entries.
Definition TH1.cxx:4419
TList * GetListOfFunctions() const
Definition TH1.h:244
void Paint(Option_t *option="") override
Control routine to paint any kind of histograms.
Definition TH1.cxx:6170
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute action corresponding to one event.
Definition TH1.cxx:3236
static Bool_t AddDirectoryStatus()
Static function: cannot be inlined on Windows/NT.
Definition TH1.cxx:752
2-D histogram with a double per channel (see TH1 documentation)
Definition TH2.h:338
Service class for 2-D histogram classes.
Definition TH2.h:30
Int_t Fill(Double_t) override
Invalid Fill method.
Definition TH2.cxx:350
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:962
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:751
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
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:976
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)
Int_t LoadPlugin()
Load the plugin library for this handler.
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:419
void ToLower()
Change string to lower-case.
Definition TString.cxx:1182
Int_t Atoi() const
Return integer value of string.
Definition TString.cxx:1988
Double_t Atof() const
Return floating-point value contained in string.
Definition TString.cxx:2054
Bool_t IsFloat() const
Returns kTRUE if string contains a floating point or integer number.
Definition TString.cxx:1858
const char * Data() const
Definition TString.h:378
Bool_t IsDigit() const
Returns true if all characters in string are digits (0-9) or white spaces, i.e.
Definition TString.cxx:1830
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:706
TString & Append(const char *cs)
Definition TString.h:574
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:2378
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:634
virtual Bool_t ExpandPathName(TString &path)
Expand a pathname getting rid of special shell characters like ~.
Definition TSystem.cxx:1262
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:972
void FitOptionsMake(EFitObjectType type, const char *option, Foption_t &fitOption)
Decode list of options into fitOption.
Definition HFitImpl.cxx:685
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:902
Bool_t AreEqualRel(Double_t af, Double_t bf, Double_t relPrec)
Comparing floating points.
Definition TMath.h:426
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:123
th1 Draw()
TMarker m
Definition textangle.C:8