Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
LikelihoodIntervalPlot.cxx
Go to the documentation of this file.
1// @(#)root/roostats:$Id$
2
3/*************************************************************************
4 * Project: RooStats *
5 * Package: RooFit/RooStats *
6 * Authors: *
7 * Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke *
8 *************************************************************************
9 * Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
10 * All rights reserved. *
11 * *
12 * For the licensing terms see $ROOTSYS/LICENSE. *
13 * For the list of contributors see $ROOTSYS/README/CREDITS. *
14 *************************************************************************/
15
16
17/** \class RooStats::LikelihoodIntervalPlot
18 \ingroup Roostats
19
20 This class provides simple and straightforward utilities to plot a LikelihoodInterval
21 object.
22
23*/
24
26
27#include <algorithm>
28#include <iostream>
29#include <cmath>
30
31#include "TROOT.h"
32#include "TLine.h"
33#include "TObjArray.h"
34#include "TList.h"
35#include "TGraph.h"
36#include "TPad.h"
37#include "TCanvas.h"
38// need chisquare_quantile function - can use mathcore implementation
39// for plotting not crucial that is less precise
41
42
43#include "RooRealVar.h"
44#include "RooPlot.h"
45#include "RooMsgService.h"
46#include "RooProfileLL.h"
47#include "TF1.h"
48
49using namespace RooStats;
50
51////////////////////////////////////////////////////////////////////////////////
52/// LikelihoodIntervalPlot default constructor
53/// with default parameters
54
56
57////////////////////////////////////////////////////////////////////////////////
58/// LikelihoodIntervalPlot copy constructor
59
65
66////////////////////////////////////////////////////////////////////////////////
67
76
77////////////////////////////////////////////////////////////////////////////////
78
80{
81 fNdimPlot = params->size();
82 fParamsPlot = static_cast<RooArgSet*>(params->clone((std::string(params->GetName())+"_clone").c_str()));
83
84 return;
85}
86
87
88////////////////////////////////////////////////////////////////////////////////
89/// draw the log of the profiled likelihood function in 1D with the interval or
90/// as a 2D plot with the contours.
91/// Higher dimensional intervals cannot be drawn. One needs to call
92/// SetPlotParameters to project interval in 1 or 2dim
93///
94/// ### Options for drawing 1D intervals
95///
96/// For 1D problem the log of the profiled likelihood function is drawn by default in a RooPlot as a
97/// RooCurve
98/// The plotting range (default is the full parameter range) and the precision of the RooCurve
99/// can be specified by using SetRange(x1,x2) and SetPrecision(eps).
100/// SetNPoints(npoints) can also be used (default is npoints=100)
101/// Optionally the function can be drawn as a TF1 (option="tf1") obtained by sampling the given npoints
102/// in the given range
103///
104/// ### Options for drawing 2D intervals
105///
106/// For 2D case, a contour and optionally the profiled likelihood function is drawn by sampling npoints in
107/// the given range. A 2d histogram of nbinsX=nbinsY = sqrt(npoints) is used for sampling the profiled likelihood.
108/// The contour can be obtained by using Minuit or by the sampled histogram,
109/// If using Minuit, the number of points specifies the number of contour points. If using an histogram the number of
110/// points is approximately the total number of bins of the histogram.
111/// Possible options:
112/// - minuit/nominuit: use minuit for computing the contour
113/// - hist/nohist : sample in an histogram the profiled likelihood
114///
115/// Note that one can have both a drawing of the sampled likelihood and of the contour using minuit.
116/// The default options is "minuit nohist"
117/// The sampled histogram is drawn first by default using the option "colz" and then 8 probability contours at
118/// these CL are drawn: { 0.1,0.3,0.5,0.683,0.95,0.9973,0.9999366575,0.9999994267} re-drawing the histogram with the
119/// option "cont3"
120///
121/// The drawn object (RooPlot or sampled histogram) is saved in the class and can be retrieved using GetPlottedObject()
122/// In this way the user can eventually customize further the plot.
123/// Note that the class does not delete the plotted object. It needs, if needed, to be deleted by the user
124
126{
127 // we need to check if parameters to plot is different than parameters of interval
130 for (auto const *arg : *fParamsPlot) {
131 if (!intervalParams->contains(*arg) ) {
132 ccoutE(InputArguments) << "Parameter " << arg->GetName() << "is not in the list of LikelihoodInterval parameters "
133 << " - do not use for plotting " << std::endl;
134 fNdimPlot--;
135 extraParams.add(*arg);
136 }
137 }
138 if (!extraParams.empty())
139 fParamsPlot->remove(extraParams,true,true);
140
141 if(fNdimPlot > 2){
142 ccoutE(InputArguments) << "LikelihoodIntervalPlot::Draw(" << GetName()
143 << ") ERROR: contours for more than 2 dimensions not implemented!" << std::endl;
144 return;
145 }
146
147 // if the number of parameters to plot is less to the number of parameters of the LikelihoodInterval
148 // we need to re-do the profile likelihood function, otherwise those parameters will not be profiled
149 // when plotting
150 RooAbsReal* newProfile = nullptr;
151 std::unique_ptr<RooAbsReal> newProfileOwner;
153 if (fNdimPlot != int(intervalParams->size()) ) {
154 RooProfileLL * profilell = dynamic_cast<RooProfileLL*>(oldProfile);
155 if (!profilell) return;
156 RooAbsReal & nll = profilell->nll();
157 newProfileOwner = std::unique_ptr<RooAbsReal>{nll.createProfile(*fParamsPlot)};
159 }
160 else {
162 }
163
164 auto *myparam = static_cast<RooRealVar*>((*fParamsPlot)[0]);
165
166 // do a dummy evaluation around minimum to be sure profile has right minimum
169 newProfile->getVal();
170 }
171
172 // analyze options
173 TString opt = options;
174 opt.ToLower();
175
176 TString title = GetTitle();
177 int nPoints = fNPoints;
178
179 if(fNdimPlot == 1) {
180
181 // 1D drawing options
182 // use RooPLot for drawing the 1D PL
183 // if option is TF1 use TF1 for drawing
184 bool useRooPlot = opt.Contains("rooplot") || ! (opt.Contains("tf1"));
185 opt.ReplaceAll("rooplot","");
186 opt.ReplaceAll("tf1","");
187
188
189 // if (title.Length() == 0)
190 // title = "- log profile likelihood ratio";
191
192 if (nPoints <=0) nPoints = 100; // default in 1D
193
194 const double xcont_min = fInterval->LowerLimit(*myparam);
195 const double xcont_max = fInterval->UpperLimit(*myparam);
196
197 RooRealVar* myarg = static_cast<RooRealVar *>(newProfile->getVariables()->find(myparam->GetName()));
198 double x1 = myarg->getMin();
199 double x2 = myarg->getMax();
200
201 // default color values
202 if (fColor == 0) fColor = kBlue;
203 if (fLineColor == 0) fLineColor = kGreen;
204
205 RooPlot * frame = nullptr;
206
207 // use TF1 for drawing the function
208 if (!useRooPlot) {
209
210 // set a first estimate of range including 2 times upper and lower limit
211 double xmin = std::max( x1, 2*xcont_min - xcont_max);
212 double xmax = std::min( x2, 2*xcont_max - xcont_min);
213 if (fXmin < fXmax) { xmin = fXmin; xmax = fXmax; }
214
215 TF1 * tmp = newProfile->asTF(*myarg);
216 assert(tmp != nullptr);
217 tmp->SetRange(xmin, xmax);
218 tmp->SetNpx(nPoints);
219
220 // clone the function to avoid later to sample it
221 TF1 * f1 = static_cast<TF1*>(tmp->Clone());
222 delete tmp;
223
224 f1->SetTitle(title);
225 TString name = TString(GetName()) + TString("_PLL_") + TString(myarg->GetName());
226 f1->SetName(name);
227
228 // set range for displaying x values where function <= fMaximum
229 // if no range is set amd
230 // if no reasonable value found maintain first estimate
231 x1 = xmin; x2 = xmax;
232 if (fMaximum > 0 && fXmin >= fXmax ) {
233 double x0 = f1->GetX(0, xmin, xmax);
234 // check that minimum is between xmin and xmax
235 if ( x0 > x1 && x0 < x2) {
236 x1 = f1->GetX(fMaximum, xmin, x0);
237 x2 = f1->GetX(fMaximum, x0, xmax);
239 //std::cout << "setting range to " << x1 << " , " << x2 << " x0 = " << x0 << std::endl;
240 }
241 }
242
243 f1->SetRange(x1,x2);
244
245
247 f1->GetXaxis()->SetTitle(myarg->GetName());
248 f1->GetYaxis()->SetTitle(Form("- log #lambda(%s)",myparam->GetName()));
249 f1->Draw(opt);
251
252 }
253 else {
254 // use a RooPlot for drawing the PL function
255 double xmin = myparam->getMin(); double xmax = myparam->getMax();
256 if (fXmin < fXmax) { xmin = fXmin; xmax = fXmax; }
257
258 // set nbins (must be used in combination with precision )
259 // the curve will evaluate 2 * nbins if precision is > 1
260 int prevBins = myarg->getBins();
261 myarg->setBins(fNPoints);
262
263 // want to set range on frame not function
264 frame = myarg->frame(xmin,xmax,nPoints);
265 // for ycutoff line
266 x1= xmin;
267 x2=xmax;
268 frame->SetTitle(title);
269 frame->GetYaxis()->SetTitle(Form("- log #lambda(%s)",myparam->GetName()));
270 // frame->GetYaxis()->SetTitle("- log profile likelihood ratio");
271
272
273 // plot
276 newProfile->plotOn(frame,cmd,RooFit::LineColor(fColor));
277
278 frame->SetMaximum(fMaximum);
279 frame->SetMinimum(0.);
280
281 myarg->setBins(prevBins);
282 fPlotObject = frame;
283 }
284
285
286 //myarg->setVal(xcont_max);
287 //const double Yat_Xmax = newProfile->getVal();
289
293
294 Yline_cutoff->SetLineColor(fLineColor);
295 Yline_min->SetLineColor(fLineColor);
296 Yline_max->SetLineColor(fLineColor);
297
298 if (!useRooPlot) {
299 // need to draw the line
300 Yline_cutoff->Draw();
301 Yline_min->Draw();
302 Yline_max->Draw();
303 }
304 else {
305 // add line in the RooPlot
306 frame->addObject(Yline_min);
307 frame->addObject(Yline_max);
308 frame->addObject(Yline_cutoff);
309 frame->Draw(opt);
310 }
311
312
313 return;
314 }
315
316 // case of 2 dimensions
317
318 else if(fNdimPlot == 2){
319
320 //2D drawing options
321
322 // use Minuit for drawing the contours of the PL (default case)
323 bool useMinuit = !opt.Contains("nominuit");
324 // plot histogram in 2D
325 bool plotHist = !opt.Contains("nohist");
326 opt.ReplaceAll("nominuit","");
327 opt.ReplaceAll("nohist","");
328 if (opt.Contains("minuit") ) useMinuit= true;
329 if (useMinuit) plotHist = false; // switch off hist by default in case of Minuit
330 if (opt.Contains("hist") ) plotHist= true;
331 opt.ReplaceAll("minuit","");
332 opt.ReplaceAll("hist","");
333
334 auto *myparamY = static_cast<RooRealVar*>((*fParamsPlot)[1]);
335
337 cont_level = cont_level/2; // since we are plotting -log LR
338
339 RooArgList params(*newProfile->getVariables());
340 // set values and error for the POI to the best fit values
341 for (std::size_t i = 0; i < params.size(); ++i) {
342 RooRealVar & par = static_cast<RooRealVar &>( params[i]);
343 RooRealVar * fitPar = static_cast<RooRealVar *> (fInterval->GetBestFitParameters()->find(par.GetName() ) );
344 if (fitPar) {
345 par.setVal( fitPar->getVal() );
346 }
347 }
348 // do a profile evaluation to start from the best fit values of parameters
349 newProfile->getVal();
350
351 if (title.Length() == 0)
352 title = TString("Contour of ") + TString(myparamY->GetName() ) + TString(" vs ") + TString(myparam->GetName() );
353 // add also labels
354 title = TString::Format("%s;%s;%s",title.Data(),myparam->GetName(),myparamY->GetName());
355
356 if (nPoints <=0) nPoints = 40; // default in 2D
357
358 double xmin = myparam->getMin(); double xmax = myparam->getMax();
359 double ymin = myparamY->getMin(); double ymax = myparamY->getMax();
360 if (fXmin < fXmax) { xmin = fXmin; xmax = fXmax; }
361 if (fYmin < fYmax) { ymin = fYmin; ymax = fYmax; }
362
363
364 if (!useMinuit || plotHist) {
365
366 // find contour from a scanned histogram of points
367
368 // draw directly the TH2 from the profile LL
369 TString histName = TString::Format("_hist2D__%s_%s",myparam->GetName(),myparamY->GetName() );
370 int nBins = int( std::sqrt(double(nPoints)) + 0.5 );
371 TH2* hist2D = new TH2D(histName, title, nBins, xmin, xmax, nBins, ymin, ymax );
372 newProfile->fillHistogram(hist2D, RooArgList(*myparam,*myparamY), 1, nullptr, false, nullptr, false);
373
374 hist2D->SetTitle(title);
375 hist2D->SetStats(false);
376
377 //need many color levels for drawing with option colz
378 if (plotHist) {
379
380 const int nLevels = 51;
381 double contLevels[nLevels];
382 contLevels[0] = 0.01;
383 double maxVal = (fMaximum > 0) ? fMaximum : hist2D->GetMaximum();
384 for (int k = 1; k < nLevels; ++k) {
385 contLevels[k] = k*maxVal/double(nLevels-1);
386 }
387 hist2D->SetContour(nLevels,contLevels);
388
389 if (fMaximum>0) hist2D->SetMaximum(fMaximum);
390
391 hist2D->DrawClone("COLZ");
392 }
393
394
395 //need now less contours for drawing with option cont
396
397 const int nLevels = 8;
398 double contLevels[nLevels];
399 // last 3 are the 3,4,5 sigma levels
400 double confLevels[nLevels] = { 0.1,0.3,0.5,0.683,0.95,0.9973,0.9999366575,0.9999994267};
401 for (int k = 0; k < nLevels; ++k) {
402 //contLevels[k] = 0.5*ROOT::Math::chisquared_quantile(1.-2.*ROOT::Math::normal_cdf_c(nSigmaLevels[k],1),2);
404 }
405 hist2D->SetContour(nLevels,contLevels);
406 if (fLineColor) hist2D->SetLineColor(fLineColor);
407
408 // default options for drawing a second histogram
409 TString tmpOpt = opt;
410 tmpOpt.ReplaceAll("same","");
411 if (tmpOpt.Length() < 3) opt += "cont3";
412 // if histo is plotted draw on top
413 if (plotHist) opt += TString(" same");
414 hist2D->Draw(opt.Data());
415 gPad->Update();
416
417 // case of plotting contours without minuit
418 if (!useMinuit) {
419
420 // set levels of contours if make contours without minuit
421 TH2 * h = static_cast<TH2*>(hist2D->Clone());
423
425 // o a temporary draw to get the contour graph
426 TCanvas * tmpCanvas = new TCanvas("tmpCanvas","tmpCanvas");
427 h->Draw("CONT LIST");
428 gPad->Update();
429
430 // get graphs from the contours
431 TObjArray *contoursOrig = static_cast<TObjArray*>(gROOT->GetListOfSpecials()->FindObject("contours"));
432 // CLONE THE LIST IN CASE IT GETS DELETED
433 TObjArray *contours = nullptr;
434 if (contoursOrig) contours = static_cast<TObjArray*>(contoursOrig->Clone());
435
436 delete tmpCanvas;
437 delete h;
439
440
441 // in case of option CONT4 I need to re-make the Pad
442 if (tmpOpt.Contains("cont4")) {
443 double bm = gPad->GetBottomMargin();
444 double lm = gPad->GetLeftMargin();
445 double rm = gPad->GetRightMargin();
446 double tm = gPad->GetTopMargin();
447 double x1 = hist2D->GetXaxis()->GetXmin();
448 double y1 = hist2D->GetYaxis()->GetXmin();
449 double x2 = hist2D->GetXaxis()->GetXmax();
450 double y2 = hist2D->GetYaxis()->GetXmax();
451
452 TPad *null=new TPad("null","null",0,0,1,1);
453 null->SetFillStyle(0);
454 null->SetFrameFillStyle(0);
455 null->Draw();
456 null->cd();
457 null->Range(x1-(x2-x1)*(lm/(1-rm-lm)),
458 y1-(y2-y1)*(bm/(1-tm-lm)),
459 x2+(x2-x1)*(rm/(1-rm-lm)),
460 y2+(y2-y1)*(tm/(1-tm-lm)));
461
462 gPad->Update();
463 }
464
465
466 if (contours) {
467 int ncontours = contours->GetSize();
468 for (int icont = 0; icont < ncontours; ++icont) {
469 TList * contourList = static_cast<TList*>(contours->At(icont));
470 if (contourList && contourList->GetSize() > 0) {
474 gr->SetLineWidth(3);
475 if (fColor) {
477 gr->Draw("FL");
478 }
479 else
480 gr->Draw("L");
481 }
482 }
483 }
484 }
485 else {
486 ccoutE(InputArguments) << "LikelihoodIntervalPlot::Draw(" << GetName()
487 << ") ERROR: no contours found in ListOfSpecial" << std::endl;
488 }
489
491
492 }
493 }
494 if (useMinuit) {
495
496 // find contours using Minuit
497 TGraph * gr = new TGraph(nPoints+1);
498
500
501 if (int(ncp) < nPoints) {
502 std::cout << "Warning - Less points calculated in contours np = " << ncp << " / " << nPoints << std::endl;
503 for (int i = ncp; i < nPoints; ++i) gr->RemovePoint(i);
504 }
505 // add last point to same as first one to close the contour
506 gr->SetPoint(ncp, gr->GetX()[0], gr->GetY()[0] );
507 if (!opt.Contains("c")) opt.Append("L"); // use by default option L if C is not specified
508 // draw first a dummy 2d histogram gfor the axis
509 if (!opt.Contains("same") && !plotHist) {
510
511 TH2F* hist2D = new TH2F("_hist2D",title, nPoints, xmin, xmax, nPoints, ymin, ymax );
512 hist2D->GetXaxis()->SetTitle(myparam->GetName());
513 hist2D->GetYaxis()->SetTitle(myparamY->GetName());
514 hist2D->SetBit(TH1::kNoStats); // do not draw statistics
515 hist2D->SetFillStyle(fFillStyle);
516 hist2D->SetMaximum(1); // to avoid problem with subsequents draws
517 hist2D->Draw("AXIS");
518 }
520 if (fColor) {
521 // draw contour as filled area (add option "F")
523 opt.Append("F");
524 }
525 gr->SetLineWidth(3);
526 if (opt.Contains("same")) gr->SetFillStyle(fFillStyle); // put transparent
527 gr->Draw(opt);
528 TString name = TString("Graph_of_") + TString(fInterval->GetName());
529 gr->SetName(name);
530
531 if (!fPlotObject) fPlotObject = gr;
532 else if (fPlotObject->IsA() != TH2D::Class() ) fPlotObject = gr;
533
534 }
535
536 // draw also the minimum
537 const RooArgSet * bestFitParams = fInterval->GetBestFitParameters();
538 if (bestFitParams) {
539 TGraph * gr0 = new TGraph(1);
540 double x0 = bestFitParams->getRealValue(myparam->GetName());
541 double y0 = bestFitParams->getRealValue(myparamY->GetName());
542 gr0->SetPoint(0,x0,y0);
543 gr0->SetMarkerStyle(33);
544 if (fColor) {
545 if (fColor != kBlack) gr0->SetMarkerColor(fColor+4);
546 else gr0->SetMarkerColor(kGray);
547 }
548 gr0->Draw("P");
549 delete bestFitParams;
550 }
551
552
553
554 }
555
556 return;
557}
#define h(i)
Definition RSha256.hxx:106
#define ccoutE(a)
const char Option_t
Option string (const char)
Definition RtypesCore.h:80
@ kGray
Definition Rtypes.h:66
@ kBlack
Definition Rtypes.h:66
@ kGreen
Definition Rtypes.h:67
@ kBlue
Definition Rtypes.h:67
@ kDashed
Definition TAttLine.h:52
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
void GetParameters(TFitEditor::FuncParams_t &pars, TF1 *func)
Stores the parameters of the given function into pars.
Option_t Option_t TPoint TPoint const char x2
Option_t Option_t TPoint TPoint const char x1
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t TPoint TPoint const char y1
char name[80]
Definition TGX11.cxx:110
float xmin
float ymin
float xmax
float ymax
#define gROOT
Definition TROOT.h:411
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2495
#define gPad
double getRealValue(const char *name, double defVal=0.0, bool verbose=false) const
Get value of a RooAbsReal stored in set with given name.
virtual bool remove(const RooAbsArg &var, bool silent=false, bool matchByNameOnly=false)
Remove the specified argument from our list.
const char * GetName() const override
Returns name of object.
void assign(const RooAbsCollection &other) const
Sets the value, cache and constant attribute of any argument in our set that also appears in the othe...
Storage_t::size_type size() const
Abstract base class for objects that represent a real value and implements functionality common to al...
Definition RooAbsReal.h:63
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition RooArgList.h:22
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:24
TObject * clone(const char *newname=nullptr) const override
Definition RooArgSet.h:111
Named container for two doubles, two integers two object points and three string pointers that can be...
Definition RooCmdArg.h:26
Plot frame and a container for graphics objects within that frame.
Definition RooPlot.h:43
void SetTitle(const char *name) override
Set the title of the RooPlot to 'title'.
Definition RooPlot.cxx:1202
void addObject(TObject *obj, Option_t *drawOptions="", bool invisible=false)
Add a generic object to this plot.
Definition RooPlot.cxx:325
virtual void SetMinimum(double minimum=-1111)
Set minimum value of Y axis.
Definition RooPlot.cxx:1006
virtual void SetMaximum(double maximum=-1111)
Set maximum value of Y axis.
Definition RooPlot.cxx:996
TAxis * GetYaxis() const
Definition RooPlot.cxx:1223
void Draw(Option_t *options=nullptr) override
Draw this plot and all of the elements it contains.
Definition RooPlot.cxx:596
Implements the profile likelihood estimator for a given likelihood and set of parameters of interest.
Variable that can be changed from the outside.
Definition RooRealVar.h:37
void setVal(double value) override
Set value of variable to 'value'.
Color_t fColor
color for the contour (for 2D) or function (in 1D)
void SetPlotParameters(const RooArgSet *params)
Int_t fNPoints
number of points used to scan the PL, default depends if 1D or 2D
Style_t fFillStyle
fill style for contours, half transparent by default
void Draw(const Option_t *options=nullptr) override
draw the likelihood interval or contour for the 1D case a RooPlot is drawn by default of the profiled...
LikelihoodIntervalPlot()
LikelihoodIntervalPlot default constructor with default parameters.
double fPrecision
RooCurve precision, use default in case of -1.
void SetLikelihoodInterval(LikelihoodInterval *theInterval)
Color_t fLineColor
line color for the interval (1D) or for other contours (2D)
LikelihoodInterval is a concrete implementation of the RooStats::ConfInterval interface.
double ConfidenceLevel() const override
return confidence level
double UpperLimit(const RooRealVar &param)
return the upper bound of the interval on a given parameter
Int_t GetContourPoints(const RooRealVar &paramX, const RooRealVar &paramY, double *x, double *y, Int_t npoints=30)
return the 2D-contour points for the given subset of parameters by default make the contour using 30 ...
RooArgSet * GetParameters() const override
return a cloned list of parameters of interest. User manages the return object
double LowerLimit(const RooRealVar &param)
return the lower bound of the interval on a given parameter
RooAbsReal * GetLikelihoodRatio()
return the profile log-likelihood ratio function
const RooArgSet * GetBestFitParameters() const
return a pointer to a snapshot with best fit parameter of interest
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition TAttFill.h:38
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition TAttFill.h:40
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition TAttLine.h:44
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition TAttLine.h:45
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition TAttLine.h:42
The Canvas class.
Definition TCanvas.h:23
1-Dim function class
Definition TF1.h:182
virtual TH1 * GetHistogram() const
Return a pointer to the histogram used to visualise the function Note that this histogram is managed ...
Definition TF1.cxx:1611
TAxis * GetYaxis() const
Get y axis of the function.
Definition TF1.cxx:2436
virtual void SetMaximum(Double_t maximum=-1111)
Set the maximum value along Y for this function In case the function is already drawn,...
Definition TF1.cxx:3425
virtual void SetRange(Double_t xmin, Double_t xmax)
Initialize the upper and lower bounds to draw the function.
Definition TF1.cxx:3559
void SetTitle(const char *title="") override
Set function title if title has the form "fffffff;xxxx;yyyy", it is assumed that the function title i...
Definition TF1.cxx:3589
void Draw(Option_t *option="") override
Draw this function with its current attributes.
Definition TF1.cxx:1340
virtual Double_t GetX(Double_t y, Double_t xmin=0, Double_t xmax=0, Double_t epsilon=1.E-10, Int_t maxiter=100, Bool_t logx=false) const
Returns the X value corresponding to the function value fy for (xmin<x<xmax).
Definition TF1.cxx:1890
TAxis * GetXaxis() const
Get x axis of the function.
Definition TF1.cxx:2425
A TGraph is an object made of two arrays X and Y with npoints each.
Definition TGraph.h:41
virtual void SetPoint(Int_t i, Double_t x, Double_t y)
Set x and y values for point number i.
Definition TGraph.cxx:2290
Double_t * GetY() const
Definition TGraph.h:139
Double_t * GetX() const
Definition TGraph.h:138
virtual Int_t RemovePoint()
Delete point close to the mouse position Returns index of removed point (or -1 if nothing was changed...
Definition TGraph.cxx:2037
void SetName(const char *name="") override
Set graph name.
Definition TGraph.cxx:2329
void Draw(Option_t *chopt="") override
Draw this graph with its current attributes.
Definition TGraph.cxx:832
@ kNoStats
Don't draw stats box.
Definition TH1.h:404
virtual void SetContour(Int_t nlevels, const Double_t *levels=nullptr)
Set the number and values of contour levels.
Definition TH1.cxx:8524
2-D histogram with a double per channel (see TH1 documentation)
Definition TH2.h:356
static TClass * Class()
2-D histogram with a float per channel (see TH1 documentation)
Definition TH2.h:307
Service class for 2-D histogram classes.
Definition TH2.h:30
Use the TLine constructor to create a simple line.
Definition TLine.h:22
A doubly linked list.
Definition TList.h:38
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:173
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:50
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:149
An array of TObjects.
Definition TObjArray.h:31
virtual TClass * IsA() const
Definition TObject.h:246
The most important graphics class in the ROOT system.
Definition TPad.h:28
Basic string class.
Definition TString.h:138
Ssiz_t Length() const
Definition TString.h:425
void ToLower()
Change string to lower-case.
Definition TString.cxx:1189
const char * Data() const
Definition TString.h:384
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:712
TString & Append(const char *cs)
Definition TString.h:580
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:2384
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:640
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition TVirtualPad.h:51
RooCmdArg Precision(double prec)
RooCmdArg LineColor(TColorNumber color)
double chisquared_quantile(double z, double r)
Inverse ( ) of the cumulative distribution function of the lower tail of the distribution with degr...
TGraphErrors * gr
Definition legend1.C:25
TF1 * f1
Definition legend1.C:11
Namespace for the RooStats classes.
Definition CodegenImpl.h:61