TGraph2D
class description - source file - inheritance tree
protected:
void Build(Int_t n)
Double_t ComputeZ(Double_t x, Double_t y)
void DefineGridLevels()
Bool_t Enclose(Int_t T1, Int_t T2, Int_t T3, Int_t Ex) const
void FileIt(Int_t P, Int_t N, Int_t M)
void FindAllTriangles()
void FindHull()
Bool_t InHull(Int_t E, Int_t X) const
Double_t InterpolateOnPlane(Int_t TI1, Int_t TI2, Int_t TI3, Int_t E) const
void PaintLevels(Int_t* T, Double_t* x, Double_t* y, Double_t zmin, Double_t zmax, Int_t grid)
void PaintPolyMarker0(Int_t n, Double_t* x, Double_t* y)
void PaintTriangles(Option_t* option)
void Reset(Int_t level = 0)
public:
TGraph2D()
TGraph2D(Int_t n, Option_t* option)
TGraph2D(Int_t n, Int_t* x, Int_t* y, Int_t* z, Option_t* option)
TGraph2D(Int_t n, Float_t* x, Float_t* y, Float_t* z, Option_t* option)
TGraph2D(Int_t n, Double_t* x, Double_t* y, Double_t* z, Option_t* option)
TGraph2D(const char* name, const char* title, Int_t n, Double_t* x, Double_t* y, Double_t* z, Option_t* option)
TGraph2D(const char* filename, const char* format = "%lg %lg %lg", Option_t* option)
TGraph2D(const TGraph2D&)
TGraph2D operator=(const TGraph2D&)
virtual ~TGraph2D()
static TClass* Class()
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
virtual void Draw(Option_t* option)
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual TObject* FindObject(const char* name) const
virtual TObject* FindObject(const TObject* obj) const
virtual Int_t Fit(const char* formula, Option_t* option, Option_t* goption)
virtual Int_t Fit(TF2* f2, Option_t* option, Option_t* goption)
TDirectory* GetDirectory() const
virtual Double_t GetErrorX(Int_t bin) const
virtual Double_t GetErrorY(Int_t bin) const
virtual Double_t GetErrorZ(Int_t bin) const
TH2D* GetHistogram(Option_t* option) const
TList* GetListOfFunctions() const
Double_t GetMargin() const
Double_t GetMarginBinsContent() const
Int_t GetN() const
Int_t GetNpx() const
Int_t GetNpy() const
Double_t* GetX() const
Double_t GetXmax() const
Double_t GetXmin() const
Double_t* GetY() const
Double_t GetYmax() const
Double_t GetYmin() const
Double_t* GetZ() const
Double_t GetZmax() const
Double_t GetZmin() const
Double_t Interpolate(Double_t x, Double_t y) const
virtual TClass* IsA() const
virtual void Paint(Option_t* option)
TH1* Project(Option_t* option = "x") const
Int_t RemovePoint(Int_t ipoint)
virtual void SavePrimitive(ofstream& out, Option_t* option)
virtual void SetDirectory(TDirectory* dir)
void SetMargin(Double_t m = 0.1)
void SetMarginBinsContent(Double_t z = 0.)
void SetMaximum(Double_t maximum = -1111)
void SetMaxIter(Int_t n = 100000)
void SetMinimum(Double_t minimum = -1111)
virtual void SetName(const char* name)
void SetNpx(Int_t npx = 40)
void SetNpy(Int_t npx = 40)
void SetPoint(Int_t point, Double_t x, Double_t y, Double_t z)
virtual void SetTitle(const char* title)
virtual void ShowMembers(TMemberInspector& insp, char* parent)
virtual void Streamer(TBuffer& b)
void StreamerNVirtual(TBuffer& b)
protected:
Int_t fNpoints Number of points in the data set
Int_t fNpx Number of bins along X in fHistogram
Int_t fNpy Number of bins along Y in fHistogram
Int_t fNdt !Number of Delaunay triangles found
Int_t fNhull !Number of points in the hull
Int_t fSize !Real size of fX, fY and fZ
Double_t* fX [fNpoints]
Double_t* fY [fNpoints] Data set to be plotted
Double_t* fZ [fNpoints]
Double_t* fXN !Normalized version of fX
Double_t* fYN !Normalized version of fY
Double_t fXNmin !Minimum value of fXN
Double_t fXNmax !Maximum value of fXN
Double_t fYNmin !Minimum value of fYN
Double_t fYNmax !Maximum value of fYN
Double_t fXoffset !
Double_t fYoffset !Parameters used to normalize fX and fY
Double_t fScaleFactor !
Double_t* fGridLevels !Grid levels along Z axis
Double_t fMargin Extra space (in %) around interpolated area for 2D histo
Double_t fMinimum Minimum value for plotting along z
Double_t fMaximum Maximum value for plotting along z
Double_t fZout Histogram bin height for points lying outside the convex hull
Double_t* fDist !Array used to order mass points by distance
Int_t fMaxIter !Maximum number of iterations to find Delaunay triangles
Int_t fTriedSize !Real size of the fxTried arrays
Int_t fNbLevels |Number of Grid levels
Int_t* fPTried !
Int_t* fNTried !Delaunay triangles storage
Int_t* fMTried !
Int_t* fHullPoints !Hull points
Int_t* fOrder !Array used to order mass points by distance
TList* fFunctions Pointer to list of functions (fits and user)
TH2D* fHistogram !2D histogram of z values linearly interpolated
TDirectory* fDirectory !Pointer to directory holding this 2D graph
TView* fView !TView used to paint the triangles
public:
static const enum TGraph2D:: kFitInit
See also
-
TGraph2DErrors
A Graph2D is a graphics object made of three arrays X, Y and Z with the same
number of points each. Graph2D uses Delaunay triangulation to draw the X, Y
Z arrays. This triangulation code derives from an implementation done by
Luke Jones (Royal Holloway, University of London) in April 2002 in the PAW
context.
This class has different constructors:
1) With an array dimension and three arrays x, y, and z:
TGraph2D *g = new TGraph2D(n, x, y, z);
x, y, z arrays can be doubles, floats, or ints.
2) With an array dimension only:
TGraph2D *g = new TGraph2D(n);
The internal arrays are then filled with SetPoint. The following line
fills the the internal arrays at the position "i" with the values x,y,z.
g->SetPoint(i, x, y, z);
3) Without parameters:
TGraph2D *g = new TGraph2D();
again SetPoint must be used to fill the internal arrays.
4) From a file:
TGraph2D *g = new TGraph2D("graph.dat");
Arrays are read from the ASCII file "graph.dat" according to a specifies
format. The format's default value is "%lg %lg %lg"
Note that in any of these three cases, SetPoint can be used to change a data
point or add a new one. If the data point index (i) is greater than the
current size of the internal arrays, they are automatically extended.
Specific drawing options can be used to paint a TGraph2D:
"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.
"TRIW" : The Delaunay triangles are drawn as wire frame
"TRI1" : The Delaunay triangles are painted with color levels. The edges
of each triangles are painted with the current line color.
"TRI2" : the Delaunay triangles are painted with color levels.
"P" : Draw a marker at each vertex
"P0" : Draw a circle at each vertex. Each circle background is white.
A TGraph2D can be also drawn with ANY options valid to draw a 2D histogram.
When a TGraph2D is drawn with one of the 2D histogram drawing option,
a intermediate 2D histogram is filled using the Delaunay triangles
technique to interpolate the data set.
TGraph2D linearly interpolate a Z value for any (X,Y) point given some
existing (X,Y,Z) points. The existing (X,Y,Z) points can be randomly
scattered. The algorithm works by joining the existing points to make
Delaunay triangles in (X,Y). These are then used to define flat planes
in (X,Y,Z) over which to interpolate. The interpolated surface thus takes
the form of tessellating triangles at various angles. Output can take the
form of a 2D histogram or a vector. The triangles found can be drawn in 3D.
This software cannot be guaranteed to work under all circumstances. They
were originally written to work with a few hundred points in an XY space
with similar X and Y ranges.
The picture below has been generated by the following macro:
{
TCanvas *c = new TCanvas("c","Graph2D example",0,0,700,600);
Double_t x, y, z, P = 6.;
Int_t np = 200;
TGraph2D *dt = new TGraph2D();
TRandom *r = new TRandom();
for (Int_t N=0; N<np; N++) {
x = 2*P*(r->Rndm(N))-P;
y = 2*P*(r->Rndm(N))-P;
z = (sin(x)/x)*(sin(y)/y)+0.2;
dt->SetPoint(N,x,y,z);
}
gStyle->SetPalette(1);
dt->Draw("surf1");
}
/*
*/
A more complete example can be find in $ROOTSYS/tutorial/graph2dfit.C. It
produces the following output:
/*
*/
Definition of Delaunay triangulation (After B. Delaunay):
For a set S of points in the Euclidean plane, the unique triangulation DT(S)
of S such that no point in S is inside the circumcircle of any triangle in
DT(S). DT(S) is the dual of the Voronoi diagram of S.
If n is the number of points in S, the Voronoi diagram of S is the partitioning
of the plane containing S points into n convex polygons such that each polygon
contains exactly one point and every point in a given polygon is closer to its
central point than to any other. A Voronoi diagram is sometimes also known as
a Dirichlet tessellation.
/*
This applet
gives a nice practical view of Delaunay triangulation and Voronoi diagram.
*/
TGraph2D()
: TNamed("Graph2D","Graph2D"), TAttLine(1,1,1), TAttFill(0,1001),
TAttMarker(), fNpoints(0)
Graph2D default constructor
TGraph2D(Int_t n, Int_t *x, Int_t *y, Int_t *z, Option_t *)
: TNamed("Graph2D","Graph2D"), TAttLine(1,1,1), TAttFill(0,1001),
TAttMarker(), fNpoints(n)
Graph2D constructor with three vectors of ints as input.
TGraph2D(Int_t n, Float_t *x, Float_t *y, Float_t *z, Option_t *)
: TNamed("Graph2D","Graph2D"), TAttLine(1,1,1), TAttFill(0,1001),
TAttMarker(), fNpoints(n)
Graph2D constructor with three vectors of floats as input.
TGraph2D(Int_t n, Double_t *x, Double_t *y, Double_t *z, Option_t *)
: TNamed("Graph2D","Graph2D"), TAttLine(1,1,1), TAttFill(0,1001),
TAttMarker(), fNpoints(n)
Graph2D constructor with three vectors of doubles as input.
TGraph2D(const char *name,const char *title,
Int_t n, Double_t *x, Double_t *y, Double_t *z, Option_t *)
: TNamed(name,title), TAttLine(1,1,1), TAttFill(0,1001),
TAttMarker(), fNpoints(n)
Graph2D constructor with name, title and three vectors of doubles as input.
name : name of 2D graph (avoid blanks)
title : 2D graph title
if title is of the form "stringt;stringx;stringy;stringz"
the 2D graph title is set to stringt, the x axis title to stringy,
the y axis title to stringy,etc
TGraph2D(Int_t n, Option_t *)
: TNamed("Graph2D","Graph2D"), TAttLine(1,1,1), TAttFill(0,1001),
TAttMarker(), fNpoints(0)
Graph2D constructor. The arrays fX, fY and fZ should be filled via
calls to SetPoint
TGraph2D(const char *filename, const char *format, Option_t *)
: TNamed("Graph2D",filename), TAttLine(1,1,1), TAttFill(0,1001),
TAttMarker(), fNpoints(0)
Graph2D constructor reading input from filename
filename is assumed to contain at least three columns of numbers
TGraph2D(const TGraph2D &g)
: TNamed(g), TAttLine(g), TAttFill(g), TAttMarker(g)
Graph2D copy constructor.
~TGraph2D()
TGraph2D destructor.
void Build(Int_t n)
Creates the 2D graph basic data structure
Double_t ComputeZ(Double_t xx, Double_t yy)
Finds the Delaunay triangle that the point (xx,yy) sits in (if any) and
calculate a z-value for it by linearly interpolating the z-values that
make up that triangle.
void DefineGridLevels()
Define the grid levels drawn on the triangles.
The grid levels are aligned on the Z axis' main tick marks.
The function assumes that fView has been defined.
Int_t DistancetoPrimitive(Int_t px, Int_t py)
Computes distance from point px,py to a graph
void Draw(Option_t *option)
Specific drawing options can be used to paint a TGraph2D:
"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.
"TRIW" : The Delaunay triangles are drawn as wire frame
"TRI1" : The Delaunay triangles are painted with color levels. The edges
of each triangles are painted with the current line color.
"TRI2" : the Delaunay triangles are painted with color levels.
"P" : Draw a marker at each vertex
"P0" : Draw a circle at each vertex. Each circle background is white.
A TGraph2D can be also drawn with ANY options valid to draw a 2D histogram.
When a TGraph2D is drawn with one of the 2D histogram drawing option,
a intermediate 2D histogram is filled using the Delaunay triangles
technique to interpolate the data set.
Bool_t Enclose(Int_t T1, Int_t T2, Int_t T3, Int_t Ex) const
Is point E inside the triangle T1-T2-T3 ?
void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Executes action corresponding to one event
void FileIt(Int_t P, Int_t N, Int_t M)
Files the triangle defined by the 3 vertices P, N and M into the
fxTried arrays. If these arrays are to small they are automatically
expanded.
void FindAllTriangles()
Attempt to find all the Delaunay triangles of the point set. It is not
guaranteed that it will fully succeed, and no check is made that it has
fully succeeded (such a check would be possible by referencing the points
that make up the convex hull). The method is to check if each triangle
shares all three of its sides with other triangles. If not, a point is
generated just outside the triangle on the side(s) not shared, and a new
triangle is found for that point. If this method is not working properly
(many triangles are not being found) it's probably because the new points
are too far beyond or too close to the non-shared sides. Fiddling with the
size of the `alittlebit' parameter may help.
void FindHull()
Finds those points which make up the convex hull of the set. If the xy
plane were a sheet of wood, and the points were nails hammered into it
at the respective coordinates, then if an elastic band were stretched
over all the nails it would form the shape of the convex hull. Those
nails in contact with it are the points that make up the hull.
Bool_t InHull(Int_t E, Int_t X) const
Is point E inside the hull defined by all points apart from X ?
Double_t Interpolate(Double_t x, Double_t y) const
Finds the z value at the position (x,y) thanks to
the Delaunay interpolation.
Double_t InterpolateOnPlane(Int_t TI1, Int_t TI2, Int_t TI3, Int_t E) const
Finds the z-value at point E given that it lies
on the plane defined by T1,T2,T3
TObject* FindObject(const char *name) const
search object named name in the list of functions
TObject* FindObject(const TObject *obj) const
search object obj in the list of functions
Int_t Fit(const char *fname, Option_t *option, Option_t *)
Fits this graph with function with name fname
Int_t Fit(TF2 *f2, Option_t *option, Option_t *)
Fits this 2D graph with function f2
f2 is an already predefined function created by TF2.
Predefined functions such as gaus, expo and poln are automatically
created by ROOT.
The list of fit options is given in parameter option.
option = "W" Set all errors to 1
= "U" Use a User specified fitting algorithm (via SetFCN)
= "Q" Quiet mode (minimum printing)
= "V" Verbose mode (default is between Q and V)
= "R" Use the Range specified in the function range
= "N" Do not store the graphics function, do not draw
= "0" Do not plot the result of the fit. By default the fitted function
is drawn unless the option"N" above is specified.
= "+" Add this new fitted function to the list of fitted functions
(by default, any previous function is deleted)
In order to use the Range option, one must first create a function
with the expression to be fitted. For example, if your graph2d
has a defined range between -4 and 4 and you want to fit a gaussian
only in the interval 1 to 3, you can do:
TF2 *f2 = new TF2("f2","gaus",1,3);
graph2d->Fit("f2","R");
Setting initial conditions
==========================
Parameters must be initialized before invoking the Fit function.
The setting of the parameter initial values is automatic for the
predefined functions : poln, expo, gaus. One can however disable
this automatic computation by specifying the option "B".
You can specify boundary limits for some or all parameters via
f2->SetParLimits(p_number, parmin, parmax);
if parmin>=parmax, the parameter is fixed
Note that you are not forced to fix the limits for all parameters.
For example, if you fit a function with 6 parameters, you can do:
func->SetParameters(0,3.1,1.e-6,0.1,-8,100);
func->SetParLimits(4,-10,-4);
func->SetParLimits(5, 1,1);
With this setup, parameters 0->3 can vary freely
Parameter 4 has boundaries [-10,-4] with initial value -8
Parameter 5 is fixed to 100.
Fit range
=========
The fit range can be specified in two ways:
- specify rxmax > rxmin (default is rxmin=rxmax=0)
- specify the option "R". In this case, the function will be taken
instead of the full graph range.
Changing the fitting function
=============================
By default the fitting function Graph2DFitChisquare is used.
To specify a User defined fitting function, specify option "U" and
call the following functions:
TVirtualFitter::Fitter(mygraph)->SetFCN(MyFittingFunction)
where MyFittingFunction is of type:
extern void MyFittingFunction(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag);
Associated functions
====================
One or more object (typically a TF2*) can be added to the list
of functions (fFunctions) associated to each graph.
When TGraph::Fit is invoked, the fitted function is added to this list.
Given a graph gr, one can retrieve an associated function
with: TF2 *myfunc = gr->GetFunction("myfunc");
Access to the fit results
=========================
If the graph is made persistent, the list of
associated functions is also persistent. Given a pointer (see above)
to an associated function myfunc, one can retrieve the function/fit
parameters with calls such as:
Double_t chi2 = myfunc->GetChisquare();
Double_t par0 = myfunc->GetParameter(0); //value of 1st parameter
Double_t err0 = myfunc->GetParError(0); //error on first parameter
Fit Statistics
==============
You can change the statistics box to display the fit parameters with
the TStyle::SetOptFit(mode) method. This mode has four digits.
mode = pcev (default = 0111)
v = 1; print name/values of parameters
e = 1; print errors (if e=1, v must be 1)
c = 1; print Chisquare/Number of degress of freedom
p = 1; print Probability
For example: gStyle->SetOptFit(1011);
prints the fit probability, parameter names/values, and errors.
You can change the position of the statistics box with these lines
(where g is a pointer to the TGraph):
Root > TPaveStats *st = (TPaveStats*)g->GetListOfFunctions()->FindObject("stats")
Root > st->SetX1NDC(newx1); //new x start position
Root > st->SetX2NDC(newx2); //new x end position
Double_t GetErrorX(Int_t) const
This function is called by Graph2DFitChisquare.
It always returns a negative value. Real implementation in TGraph2DErrors
Double_t GetErrorY(Int_t) const
This function is called by Graph2DFitChisquare.
It always returns a negative value. Real implementation in TGraph2DErrors
Double_t GetErrorZ(Int_t) const
This function is called by Graph2DFitChisquare.
It always returns a negative value. Real implementation in TGraph2DErrors
TH2D* GetHistogram(Option_t *option) const
By default returns a pointer to the Delaunay histogram. If fHistogram
doesn't exist, books the 2D histogram fHistogram with a margin around
the hull. Calls ComputeZ at each bin centre to build up interpolated 2D
histogram.
If the "empty" option is selected, returns an empty histogram booked with
the limits of fX, fY and fZ. This option is used when the data set is drawn
with markers only. In that particular case there is no need to find the
Delaunay triangles.
Double_t GetXmax() const
Returns the X maximum
Double_t GetXmin() const
Returns the X minimum
Double_t GetYmax() const
Returns the Y maximum
Double_t GetYmin() const
Returns the Y minimum
Double_t GetZmax() const
Returns the Z maximum
Double_t GetZmin() const
Returns the Z minimum
void Paint(Option_t *option)
Paints this 2D graph with its current attributes
void PaintLevels(Int_t *T,Double_t *x, Double_t *y,
Double_t zmin, Double_t zmax, Int_t grid)
Paints one triangle according to the "grid" value.
grid = 0 : paint the color levels
grid = 1 : paint the grid
void PaintPolyMarker0(Int_t n, Double_t *x, Double_t *y)
Paints a circle at each vertex. Each circle background is white.
void PaintTriangles(Option_t *option)
Paints the 2D graph triangles
TH1* Project(Option_t *option) const
Projects a 2-d graph into 1 or 2-d histograms depending on the
option parameter
option may contain a combination of the characters x,y,z
option = "x" return the x projection into a TH1D histogram
option = "y" return the y projection into a TH1D histogram
option = "xy" return the x versus y projection into a TH2D histogram
option = "yx" return the y versus x projection into a TH2D histogram
Int_t RemovePoint(Int_t ipoint)
Deletes point number ipoint
void Reset(Int_t level)
Called each time fHistogram should be recreated.
level = 0 : it is enough to delete fHistogram
level = 1 : the data set has changed, the hull and triangles
must be recomputed.
void SavePrimitive(ofstream &out, Option_t *option)
Saves primitive as a C++ statement(s) on output stream out
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 directory in memory.
Remove reference to this 2D graph from current directory and add
reference to new directory dir. dir can be 0 in which case the
2D graph does not belong to any directory.
void SetMargin(Double_t m)
Sets the extra space (in %) around interpolated area for the 2D histogram
void SetMaximum(Double_t maximum)
void SetMinimum(Double_t minimum)
void SetMaxIter(Int_t n)
Defines the number of triangles tested for a Delaunay triangle
(number of iterations) before abandoning the search
void SetName(const char *name)
Changes the name of this 2D graph
void SetNpx(Int_t npx)
Sets the number of bins along X used to draw the function
void SetNpy(Int_t npy)
Sets the number of bins along Y used to draw the function
void SetMarginBinsContent(Double_t z)
Sets the histogram bin height for points lying outside the convex hull ie:
the bins in the margin.
void SetPoint(Int_t n, Double_t x, Double_t y, Double_t z)
Sets point number n.
If n is greater than the current size, the arrays are automatically
extended.
void SetTitle(const char* title)
Sets graph title
void Streamer(TBuffer &b)
Stream a class object
Inline Functions
TGraph2D operator=(const TGraph2D&)
TDirectory* GetDirectory() const
Double_t GetMargin() const
Int_t GetNpx() const
Int_t GetNpy() const
Double_t GetMarginBinsContent() const
TList* GetListOfFunctions() const
Int_t GetN() const
Double_t* GetX() const
Double_t* GetY() const
Double_t* GetZ() const
TClass* Class()
TClass* IsA() const
void ShowMembers(TMemberInspector& insp, char* parent)
void StreamerNVirtual(TBuffer& b)
Author: Olivier Couet, Luke Jones (Royal Holloway, University of London)
Last update: root/graf:$Name: $:$Id: TGraph2D.cxx,v 1.00
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
ROOT page - Class index - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.