Logo ROOT  
Reference Guide
RooPlot.cxx
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * @(#)root/roofitcore:$Id$
5 * Authors: *
6 * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7 * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8 * *
9 * Copyright (c) 2000-2005, Regents of the University of California *
10 * and Stanford University. All rights reserved. *
11 * *
12 * Redistribution and use in source and binary forms, *
13 * with or without modification, are permitted according to the terms *
14 * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15 *****************************************************************************/
16
17/**
18\file RooPlot.cxx
19\class RooPlot
20\ingroup Roofitcore
21
22A RooPlot is a plot frame and a container for graphics objects
23within that frame. As a frame, it provides the TH1-style public interface
24for setting plot ranges, configuring axes, etc. As a container, it
25holds an arbitrary set of objects that might be histograms of data,
26curves representing a fit model, or text labels. Use the Draw()
27method to draw a frame and the objects it contains. Use the various
28add...() methods to add objects to be drawn. In general, the
29add...() methods create a private copy of the object you pass them
30and return a pointer to this copy. The caller owns the input object
31and this class owns the returned object.
32All RooAbsReal and RooAbsData derived classes implement plotOn()
33functions that facilitate to plot themselves on a given RooPlot, e.g.
34~~~ {.cpp}
35RooPlot *frame = x.frame() ;
36data.plotOn(frame) ;
37pdf.plotOn(frame) ;
38~~~
39These high level functions also take care of any projections
40or other mappings that need to be made to plot a multi-dimensional
41object onto a one-dimensional plot.
42**/
43
44#include "RooPlot.h"
45
46#include "RooAbsReal.h"
47#include "RooAbsRealLValue.h"
48#include "RooPlotable.h"
49#include "RooArgSet.h"
50#include "RooCurve.h"
51#include "RooHist.h"
52#include "RooMsgService.h"
53
54#include "TClass.h"
55#include "TBuffer.h"
56#include "TH1D.h"
57#include "TBrowser.h"
58#include "TVirtualPad.h"
59
60#include "TAttLine.h"
61#include "TAttFill.h"
62#include "TAttMarker.h"
63#include "TAttText.h"
64#include "TDirectoryFile.h"
65#include "TLegend.h"
66#include "strlcpy.h"
67
68#include <algorithm>
69#include <cstring>
70#include <iostream>
71
72using namespace std;
73
75
76
77bool RooPlot::_addDirStatus = true ;
78
80bool RooPlot::setAddDirectoryStatus(bool flag) { bool ret = flag ; _addDirStatus = flag ; return ret ; }
81
82
83////////////////////////////////////////////////////////////////////////////////
84/// Default constructor
85/// coverity[UNINIT_CTOR]
86
88{
91 }
92}
93
94
95////////////////////////////////////////////////////////////////////////////////
96/// Constructor of RooPlot with range [xmin,xmax]
97
98RooPlot::RooPlot(double xmin, double xmax)
99{
100 _hist = new TH1D(histName(),"A RooPlot",100,xmin,xmax) ;
101 _hist->Sumw2(false) ;
102 _hist->GetSumw2()->Set(0) ;
103 _hist->SetDirectory(nullptr);
104
105 // Create an empty frame with the specified x-axis limits.
106 initialize();
107
108}
109
110
111
112////////////////////////////////////////////////////////////////////////////////
113/// Construct of a two-dimensional RooPlot with ranges [xmin,xmax] x [ymin,ymax]
114
115RooPlot::RooPlot(double xmin, double xmax, double ymin, double ymax) :
116 _defYmax(0)
117{
118 _hist = new TH1D(histName(),"A RooPlot",100,xmin,xmax) ;
119 _hist->Sumw2(false) ;
120 _hist->GetSumw2()->Set(0) ;
121 _hist->SetDirectory(nullptr);
122
125 initialize();
126}
127
128
129////////////////////////////////////////////////////////////////////////////////
130/// Construct a two-dimensional RooPlot with ranges and properties taken
131/// from variables var1 and var2
132
134 _defYmax(0)
135{
136 _hist = new TH1D(histName(),"A RooPlot",100,var1.getMin(),var1.getMax()) ;
137 _hist->Sumw2(false) ;
138 _hist->GetSumw2()->Set(0) ;
139 _hist->SetDirectory(nullptr);
140
141 if(!var1.hasMin() || !var1.hasMax()) {
142 coutE(InputArguments) << "RooPlot::RooPlot: cannot create plot for variable without finite limits: "
143 << var1.GetName() << endl;
144 return;
145 }
146 if(!var2.hasMin() || !var2.hasMax()) {
147 coutE(InputArguments) << "RooPlot::RooPlot: cannot create plot for variable without finite limits: "
148 << var1.GetName() << endl;
149 return;
150 }
151 SetMinimum(var2.getMin());
152 SetMaximum(var2.getMax());
153 SetXTitle(var1.getTitle(true));
154 SetYTitle(var2.getTitle(true));
155 initialize();
156}
157
158
159////////////////////////////////////////////////////////////////////////////////
160/// Construct a two-dimensional RooPlot with ranges and properties taken
161/// from variables var1 and var2 but with an overriding range definition
162/// of [xmin,xmax] x [ymin,ymax]
163
165 double xmin, double xmax, double ymin, double ymax) :
166 _defYmax(0)
167{
168 _hist = new TH1D(histName(),"A RooPlot",100,xmin,xmax) ;
169 _hist->Sumw2(false) ;
170 _hist->GetSumw2()->Set(0) ;
171 _hist->SetDirectory(nullptr);
172
175 SetXTitle(var1.getTitle(true));
176 SetYTitle(var2.getTitle(true));
177 initialize();
178}
179
180
181////////////////////////////////////////////////////////////////////////////////
182/// Create an 1-dimensional with all properties taken from 'var', but
183/// with an explicit range [xmin,xmax] and a default binning of 'nbins'
184
185RooPlot::RooPlot(const char* name, const char* title, const RooAbsRealLValue &var, double xmin, double xmax, Int_t nbins)
186{
187 _hist = new TH1D(name,title,nbins,xmin,xmax) ;
188 _hist->Sumw2(false) ;
189 _hist->GetSumw2()->Set(0) ;
190 _hist->SetDirectory(nullptr);
191
192 // In the past, the plot variable was cloned, but there was no apparent reason for doing so.
193 _plotVar = const_cast<RooAbsRealLValue*>(&var);
194
195 TString xtitle= var.getTitle(true);
196 SetXTitle(xtitle.Data());
197
198 initialize();
199
200 _normBinWidth = (xmax-xmin)/nbins ;
201}
202
203
204////////////////////////////////////////////////////////////////////////////////
205/// Create an 1-dimensional with all properties taken from 'var', but
206/// with an explicit range [xmin,xmax] and a default binning of 'nbins'
207
208RooPlot::RooPlot(const RooAbsRealLValue &var, double xmin, double xmax, Int_t nbins)
209{
210 _hist = new TH1D(histName(),"RooPlot",nbins,xmin,xmax) ;
211 _hist->Sumw2(false) ;
212 _hist->GetSumw2()->Set(0) ;
213 _hist->SetDirectory(nullptr);
214
215 // In the past, the plot variable was cloned, but there was no apparent reason for doing so.
216 _plotVar = const_cast<RooAbsRealLValue*>(&var);
217
218 TString xtitle= var.getTitle(true);
219 SetXTitle(xtitle.Data());
220
221 TString title("A RooPlot of \"");
222 title.Append(var.getTitle());
223 title.Append("\"");
224 SetTitle(title.Data());
225 initialize();
226
227 _normBinWidth = (xmax-xmin)/nbins ;
228}
229
230////////////////////////////////////////////////////////////////////////////////
231/// Create a new frame for a given variable in x. This is just a
232/// wrapper for the RooPlot constructor with the same interface.
233///
234/// More details.
235/// \param[in] var The variable on the x-axis
236/// \param[in] xmin Left edge of the x-axis
237/// \param[in] xmax Right edge of the x-axis
238/// \param[in] nBins number of bins on the x-axis
239RooPlot* RooPlot::frame(const RooAbsRealLValue &var, double xmin, double xmax, Int_t nBins){
240 return new RooPlot(var,xmin,xmax,nBins);
241}
242
243////////////////////////////////////////////////////////////////////////////////
244/// Create a new frame for a given variable in x, adding bin labels.
245/// The binning will be extracted from the variable given. The bin
246/// labels will be set as "%g-%g" for the left and right edges of each
247/// bin of the given variable.
248///
249/// More details.
250/// \param[in] var The variable on the x-axis
252 RooPlot* pl = new RooPlot();
253 int nbins = var.getBinning().numBins();
254
255 pl->_hist = new TH1D(pl->histName(),"RooPlot",nbins,var.getMin(),var.getMax()) ;
256 pl->_hist->Sumw2(false) ;
257 pl->_hist->GetSumw2()->Set(0) ;
258 pl->_hist->SetDirectory(nullptr);
259
260 pl->_hist->SetNdivisions(-nbins);
261 for(int i=0; i<nbins; ++i){
262 TString s = TString::Format("%g-%g",var.getBinning().binLow(i),var.getBinning().binHigh(i));
263 pl->_hist->GetXaxis()->SetBinLabel(i+1,s);
264 }
265
266 // In the past, the plot variable was cloned, but there was no apparent reason for doing so.
267 pl->_plotVar = const_cast<RooAbsRealLValue*>(&var);
268
269 TString xtitle= var.getTitle(true);
270 pl->SetXTitle(xtitle.Data());
271
272 TString title("A RooPlot of \"");
273 title.Append(var.getTitle());
274 title.Append("\"");
275 pl->SetTitle(title.Data());
276 pl->initialize();
277
278 pl->_normBinWidth = 1.;
279 return pl;
280}
281
282////////////////////////////////////////////////////////////////////////////////
283/// Return empty clone of current RooPlot
284
286{
288 clone->SetName(name) ;
289 return clone ;
290}
291
292
293////////////////////////////////////////////////////////////////////////////////
294/// Perform initialization that is common to all constructors.
295
297{
298 SetName(histName()) ;
299
302 }
303
304 // We do not have useful stats of our own
305 _hist->SetStats(false);
306 _hist->SetDirectory(nullptr);
307 // Default vertical padding of our enclosed objects
308 setPadFactor(0.05);
309 // We don't know our normalization yet
310 _normNumEvts= 0;
311 _normBinWidth = 0;
312}
313
314
315////////////////////////////////////////////////////////////////////////////////
316/// Construct automatic name of internal TH1
317
319{
320 if (_plotVar) {
321 return TString(Form("frame_%s_%zx",_plotVar->GetName(),(size_t)this)) ;
322 } else {
323 return TString(Form("frame_%zx",(size_t)this)) ;
324 }
325}
326
327
328////////////////////////////////////////////////////////////////////////////////
329/// Destructor
330
332{
333 // Delete the items in our container and our iterator.
334 if (_dir) {
335 _dir->GetList()->RecursiveRemove(this) ;
336 }
337
338 for(auto& item : _items) delete item.first;
339 if(_plotVarSet) delete _plotVarSet;
340 if(_normVars) delete _normVars;
341 delete _hist ;
342
343}
344
345
346////////////////////////////////////////////////////////////////////////////////
347/// Set the directory that this plot is associated to.
348/// Setting it to `nullptr` will remove the object from all directories.
349/// Like TH1::SetDirectory.
351 if (_dir) {
352 _dir->GetList()->RecursiveRemove(this);
353 }
354 _dir = dir;
355 if (_dir) {
356 _dir->Append(this);
357 }
358}
359
360
361////////////////////////////////////////////////////////////////////////////////
362/// Install the given set of observables are reference normalization
363/// variables for this frame. These observables are e.g. later used
364/// to automatically project out observables when plotting functions
365/// on this frame. This function is only effective when called the
366/// first time on a frame
367
369{
370 if(_normVars == nullptr) {
371 _normVars = new RooArgSet;
372 vars.snapshot(*_normVars, true);
373 }
374}
375
376
377////////////////////////////////////////////////////////////////////////////////
378/// Add a generic object to this plot. The specified options will be
379/// used to Draw() this object later. The caller transfers ownership
380/// of the object with this call, and the object will be deleted
381/// when its containing plot object is destroyed.
382
383void RooPlot::addObject(TObject *obj, Option_t *drawOptions, bool invisible)
384{
385 if(0 == obj) {
386 coutE(InputArguments) << fName << "::addObject: called with a null pointer" << endl;
387 return;
388 }
389 DrawOpt opt(drawOptions) ;
390 opt.invisible = invisible ;
391 _items.emplace_back(obj,opt.rawOpt());
392}
393
394
395////////////////////////////////////////////////////////////////////////////////
396/// Add a TH1 histogram object to this plot. The specified options
397/// will be used to Draw() this object later. "SAME" will be added to
398/// the options if they are not already present. The caller transfers
399/// ownership of the object with this call, and the object will be
400/// deleted when its containing plot object is destroyed.
401
402void RooPlot::addTH1(TH1 *hist, Option_t *drawOptions, bool invisible)
403{
404 if(0 == hist) {
405 coutE(InputArguments) << fName << "::addTH1: called with a null pointer" << endl;
406 return;
407 }
408 // check that this histogram is really 1D
409 if(1 != hist->GetDimension()) {
410 coutE(InputArguments) << fName << "::addTH1: cannot plot histogram with "
411 << hist->GetDimension() << " dimensions" << endl;
412 return;
413 }
414
415 // add option "SAME" if necessary
416 TString options(drawOptions);
417 options.ToUpper();
418 if(!options.Contains("SAME")) options.Append("SAME");
419
420 // update our y-axis label and limits
421 updateYAxis(hist->GetMinimum(),hist->GetMaximum(),hist->GetYaxis()->GetTitle());
422
423 // use this histogram's normalization if necessary
424 updateFitRangeNorm(hist);
425
426 // add the histogram to our list
427 addObject(hist,options.Data(),invisible);
428}
429
430
431namespace {
432 // this helper function is intended to translate a graph from a regular axis to a labelled axis
433 // this version uses TGraph, which is a parent of RooCurve
434 void translateGraph(TH1* hist, RooAbsRealLValue* xvar, TGraph* graph){
435 // if the graph already has a labelled axis, don't do anything
436 if(graph->GetXaxis()->IsAlphanumeric()) return;
437 double xmin = hist->GetXaxis()->GetXmin();
438 double xmax = hist->GetXaxis()->GetXmax();
439 if(graph->TestBit(TGraph::kIsSortedX)){
440 // sorted graphs are "line graphs"
441 // evaluate the graph at the lower and upper edge as well as the center of each bin
442 std::vector<double> x;
443 std::vector<double> y;
444 x.push_back(xmin);
445 y.push_back(graph->Eval(xvar->getBinning().binLow(0)));
446 for(int i=0; i<hist->GetNbinsX(); ++i){
447 x.push_back(hist->GetXaxis()->GetBinUpEdge(i+1));
448 y.push_back(graph->Eval(xvar->getBinning().binHigh(i)));
449 x.push_back(hist->GetXaxis()->GetBinCenter(i+1));
450 y.push_back(graph->Eval(xvar->getBinning().binCenter(i)));
451 }
452 int n = x.size();
453 graph->Set(n);
454 for(int i=0; i<n; ++i){
455 graph->SetPoint(i,x[i],y[i]);
456 }
457 graph->Sort();
458 } else {
459 // unsorted graphs are "area graphs"
460 std::map<int,double> minValues;
461 std::map<int,double> maxValues;
462 int n = graph->GetN();
463 double x, y;
464 // for each bin, find the min and max points to form an envelope
465 for(int i=0; i<n; ++i){
466 graph->GetPoint(i,x,y);
467 int bin = xvar->getBinning().binNumber(x)+1;
468 if(maxValues.find(bin)!=maxValues.end()){
469 maxValues[bin] = std::max(maxValues[bin],y);
470 } else {
471 maxValues[bin] = y;
472 }
473 if(minValues.find(bin)!=minValues.end()){
474 minValues[bin] = std::min(minValues[bin],y);
475 } else {
476 minValues[bin] = y;
477 }
478 }
479 double xminY = graph->Eval(xmin);
480 double xmaxY = graph->Eval(xmax);
481 graph->Set(hist->GetNbinsX()+2);
482 int np=0;
483 graph->SetPoint(np,xmin,xminY);
484 // assign the calculated envelope boundaries to the bin centers of the bins
485 for(auto it = maxValues.begin(); it != maxValues.end(); ++it){
486 graph->SetPoint(++np,hist->GetXaxis()->GetBinCenter(it->first),it->second);
487 }
488 graph->SetPoint(++np,xmax,xmaxY);
489 for(auto it = minValues.rbegin(); it != minValues.rend(); ++it){
490 graph->SetPoint(++np,hist->GetXaxis()->GetBinCenter(it->first),it->second);
491 }
492 graph->SetPoint(++np,xmin,xminY);
493 }
494 // make sure that the graph also has the labels set, such that subsequent calls to translate this graph will not do anything
495 graph->GetXaxis()->Set(hist->GetNbinsX(),xmin,xmax);
496 for(int i=0; i<hist->GetNbinsX(); ++i){
497 graph->GetXaxis()->SetBinLabel(i+1,hist->GetXaxis()->GetBinLabel(i+1));
498 }
499 }
500 // this version uses TGraphErrors, which is a parent of RooHist
501 void translateGraph(TH1* hist, RooAbsRealLValue* xvar, TGraphAsymmErrors* graph){
502 // if the graph already has a labelled axis, don't do anything
503 if(graph->GetXaxis()->IsAlphanumeric()) return;
504 int n = graph->GetN();
505 double xmin = hist->GetXaxis()->GetXmin();
506 double xmax = hist->GetXaxis()->GetXmax();
507 double x, y;
508 // as this graph is histogram-like, we expect there to be one point per bin
509 // we just move these points to the respective bin centers
510 for(int i=0; i<n; ++i){
511 if(graph->GetPoint(i,x,y)!=i) break;
512 int bin = xvar->getBinning().binNumber(x);
513 graph->SetPoint(i,hist->GetXaxis()->GetBinCenter(bin+1),y);
514 graph->SetPointEXhigh(i,0.5*hist->GetXaxis()->GetBinWidth(bin+1));
515 graph->SetPointEXlow(i,0.5*hist->GetXaxis()->GetBinWidth(bin+1));
516 }
517 graph->GetXaxis()->Set(hist->GetNbinsX(),xmin,xmax);
518 // make sure that the graph also has the labels set, such that subsequent calls to translate this graph will not do anything
519 for(int i=0; i<hist->GetNbinsX(); ++i){
520 graph->GetXaxis()->SetBinLabel(i+1,hist->GetXaxis()->GetBinLabel(i+1));
521 }
522 }
523}
524
525////////////////////////////////////////////////////////////////////////////////
526/// Add the specified plotable object to our plot. Increase our y-axis
527/// limits to fit this object if necessary. The default lower-limit
528/// is zero unless we are plotting an object that takes on negative values.
529/// This call transfers ownership of the plotable object to this class.
530/// The plotable object will be deleted when this plot object is deleted.
531void RooPlot::addPlotable(RooPlotable *plotable, Option_t *drawOptions, bool invisible, bool refreshNorm)
532{
533 // update our y-axis label and limits
534 updateYAxis(plotable->getYAxisMin(),plotable->getYAxisMax(),plotable->getYAxisLabel());
535
536 // use this object's normalization if necessary
537 updateFitRangeNorm(plotable,refreshNorm) ;
538
539 // add this element to our list and remember its drawing option
540 TObject *obj= plotable->crossCast();
541 if(0 == obj) {
542 coutE(InputArguments) << fName << "::add: cross-cast to TObject failed (nothing added)" << endl;
543 }
544 else {
545 // if the frame axis is alphanumeric, the coordinates of the graph need to be translated to this binning
546 if(_hist->GetXaxis()->IsAlphanumeric()){
547 if(obj->InheritsFrom(RooCurve::Class())){
548 ::translateGraph(_hist,_plotVar,static_cast<RooCurve*>(obj));
549 } else if(obj->InheritsFrom(RooHist::Class())){
550 ::translateGraph(_hist,_plotVar,static_cast<RooHist*>(obj));
551 }
552 }
553
554 DrawOpt opt(drawOptions) ;
555 opt.invisible = invisible ;
556 _items.emplace_back(obj,opt.rawOpt());
557 }
558}
559
560
561////////////////////////////////////////////////////////////////////////////////
562/// Update our plot normalization over our plot variable's fit range,
563/// which will be determined by the first suitable object added to our plot.
564
566{
567 const TAxis* xa = ((TH1*)hist)->GetXaxis() ;
568 _normBinWidth = (xa->GetXmax()-xa->GetXmin())/hist->GetNbinsX() ;
570}
571
572
573////////////////////////////////////////////////////////////////////////////////
574/// Update our plot normalization over our plot variable's fit range,
575/// which will be determined by the first suitable object added to our plot.
576
577void RooPlot::updateFitRangeNorm(const RooPlotable* rp, bool refreshNorm)
578{
579 if (_normNumEvts != 0) {
580
581 // If refresh feature is disabled stop here
582 if (!refreshNorm) return ;
583
584 double corFac(1.0) ;
585 if (dynamic_cast<const RooHist*>(rp)) corFac = _normBinWidth/rp->getFitRangeBinW() ;
586
587
588 if (std::abs(rp->getFitRangeNEvt()/corFac-_normNumEvts)>1e-6) {
589 coutI(Plotting) << "RooPlot::updateFitRangeNorm: New event count of " << rp->getFitRangeNEvt()/corFac
590 << " will supercede previous event count of " << _normNumEvts << " for normalization of PDF projections" << endl ;
591 }
592
593 // Nominal bin width (i.e event density) is already locked in by previously drawn histogram
594 // scale this histogram to match that density
595 _normNumEvts = rp->getFitRangeNEvt()/corFac ;
596 _normObj = rp ;
597 // cout << "correction factor = " << _normBinWidth << "/" << rp->getFitRangeBinW() << endl ;
598 // cout << "updating numevts to " << _normNumEvts << endl ;
599
600 } else {
601
602 _normObj = rp ;
604 if (rp->getFitRangeBinW()) {
606 }
607
608 // cout << "updating numevts to " << _normNumEvts << endl ;
609 }
610
611}
612
613
614
615////////////////////////////////////////////////////////////////////////////////
616/// Update our y-axis limits to accomodate an object whose spread
617/// in y is (ymin,ymax). Use the specified y-axis label if we don't
618/// have one assigned already.
619
620void RooPlot::updateYAxis(double ymin, double ymax, const char *label)
621{
622 // force an implicit lower limit of zero if appropriate
623 if(GetMinimum() == 0 && ymin > 0) ymin= 0;
624
625 // calculate padded values
626 double ypad= getPadFactor()*(ymax-ymin);
627 ymax+= ypad;
628 if(ymin < 0) ymin-= ypad;
629
630 // update our limits if necessary
631 if(GetMaximum() < ymax) {
632 _defYmax = ymax ;
634 // if we don't do this - Unzoom on y-axis will reset upper bound to 1
636 }
637 if(GetMinimum() > ymin) {
638 _defYmin = ymin ;
640 }
641
642 // use the specified y-axis label if we don't have one already
643 if(0 == strlen(_hist->GetYaxis()->GetTitle())) _hist->SetYTitle(label);
644}
645
646
647////////////////////////////////////////////////////////////////////////////////
648/// Draw this plot and all of the elements it contains. The specified options
649/// only apply to the drawing of our frame. The options specified in our add...()
650/// methods will be used to draw each object we contain.
651
653{
654 TString optArg = option ;
655 optArg.ToLower() ;
656
657 // This draw options prevents the histogram with one dummy entry
658 // to be drawn
659 if (optArg.Contains("same")) {
660 _hist->Draw("FUNCSAME");
661 } else {
662 _hist->Draw("FUNC");
663 }
664
665 for(auto const& item : _items) {
666 TObject &obj = *item.first;
667 DrawOpt opt(item.second.c_str()) ;
668 if (!opt.invisible) {
669 //LM: in case of a TGraph derived object, do not use default "" option
670 // which is "ALP" from 5.34.10 (and will then redrawn the axis) but use "LP"
671 if (!strlen(opt.drawOptions) && obj.IsA()->InheritsFrom(TGraph::Class()) ) strlcpy(opt.drawOptions,"LP",3);
672 obj.Draw(opt.drawOptions);
673 }
674 }
675
676 _hist->Draw("AXISSAME");
677}
678
679
680
681////////////////////////////////////////////////////////////////////////////////
682/// Print frame name
683
684void RooPlot::printName(ostream& os) const
685{
686 os << GetName() ;
687}
688
689
690////////////////////////////////////////////////////////////////////////////////
691/// Print frame title
692
693void RooPlot::printTitle(ostream& os) const
694{
695 os << GetTitle() ;
696}
697
698
699////////////////////////////////////////////////////////////////////////////////
700/// Print frame class name
701
702void RooPlot::printClassName(ostream& os) const
703{
704 os << ClassName() ;
705}
706
707
708
709////////////////////////////////////////////////////////////////////////////////
710
711void RooPlot::printArgs(ostream& os) const
712{
713 if (_plotVar) {
714 os << "[" ;
716 os << "]" ;
717 }
718}
719
720
721
722////////////////////////////////////////////////////////////////////////////////
723/// Print frame arguments
724
725void RooPlot::printValue(ostream& os) const
726{
727 os << "(" ;
728 bool first(true) ;
729 for(auto const& item : _items) {
730 TObject &obj = *item.first;
731 if (first) {
732 first=false ;
733 } else {
734 os << "," ;
735 }
736 if(obj.IsA()->InheritsFrom(RooPrintable::Class())) {
737 auto po = dynamic_cast<RooPrintable&>(obj) ;
738 // coverity[FORWARD_NULL]
740 }
741 // is it a TNamed subclass?
742 else {
743 os << obj.ClassName() << "::" << obj.GetName() ;
744 }
745 }
746 os << ")" ;
747}
748
749
750////////////////////////////////////////////////////////////////////////////////
751/// Frame detailed printing
752
753void RooPlot::printMultiline(ostream& os, Int_t /*content*/, bool verbose, TString indent) const
754{
755 TString deeper(indent);
756 deeper.Append(" ");
757 if(0 != _plotVar) {
758 os << indent << "RooPlot " << GetName() << " (" << GetTitle() << ") plots variable ";
760 }
761 else {
762 os << indent << "RooPlot " << GetName() << " (" << GetTitle() << ") has no associated plot variable" << endl ;
763 }
764 os << indent << " Plot frame contains " << _items.size() << " object(s):" << endl;
765
766 if(verbose) {
767 Int_t i=0 ;
768 for(auto const& item : _items) {
769 TObject &obj = *item.first;
770 os << deeper << "[" << i++ << "] (Options=\"" << item.second << "\") ";
771 // Is this a printable object?
772 if(obj.IsA()->InheritsFrom(RooPrintable::Class())) {
773 auto po = dynamic_cast<RooPrintable&>(obj) ;
775 }
776 // is it a TNamed subclass?
777 else {
778 os << obj.ClassName() << "::" << obj.GetName() << endl;
779 }
780 }
781 }
782}
783
784
785
786////////////////////////////////////////////////////////////////////////////////
787/// Return the name of the object at slot 'idx' in this RooPlot.
788/// If the given index is out of range, return a null pointer
789
790const char* RooPlot::nameOf(Int_t idx) const
791{
792 TObject* obj = _items.at(idx).first;
793 if (!obj) {
794 coutE(InputArguments) << "RooPlot::nameOf(" << GetName() << ") index " << idx << " out of range" << endl ;
795 return 0 ;
796 }
797 return obj->GetName() ;
798}
799
800
801
802////////////////////////////////////////////////////////////////////////////////
803/// Return the name of the object at slot 'idx' in this RooPlot.
804/// If the given index is out of range, return a null pointer
805
807{
808 TObject* obj = _items.at(idx).first;
809 if (!obj) {
810 coutE(InputArguments) << "RooPlot::getObject(" << GetName() << ") index " << idx << " out of range" << endl ;
811 return 0 ;
812 }
813 return obj ;
814}
815
816
817
818////////////////////////////////////////////////////////////////////////////////
819/// Return a pointer to the line attributes of the named object in this plot,
820/// or zero if the named object does not exist or does not have line attributes.
821
823{
824 return dynamic_cast<TAttLine*>(findObject(name));
825}
826
827
828////////////////////////////////////////////////////////////////////////////////
829/// Return a pointer to the fill attributes of the named object in this plot,
830/// or zero if the named object does not exist or does not have fill attributes.
831
833{
834 return dynamic_cast<TAttFill*>(findObject(name));
835}
836
837
838////////////////////////////////////////////////////////////////////////////////
839/// Return a pointer to the marker attributes of the named object in this plot,
840/// or zero if the named object does not exist or does not have marker attributes.
841
843{
844 return dynamic_cast<TAttMarker*>(findObject(name));
845}
846
847
848////////////////////////////////////////////////////////////////////////////////
849/// Return a pointer to the text attributes of the named object in this plot,
850/// or zero if the named object does not exist or does not have text attributes.
851
853{
854 return dynamic_cast<TAttText*>(findObject(name));
855}
856
857
858
859////////////////////////////////////////////////////////////////////////////////
860/// Return a RooCurve pointer of the named object in this plot,
861/// or zero if the named object does not exist or is not a RooCurve
862
863RooCurve* RooPlot::getCurve(const char* name) const
864{
865 return dynamic_cast<RooCurve*>(findObject(name)) ;
866}
867
868
869////////////////////////////////////////////////////////////////////////////////
870/// Return a RooCurve pointer of the named object in this plot,
871/// or zero if the named object does not exist or is not a RooCurve
872
873RooHist* RooPlot::getHist(const char* name) const
874{
875 return dynamic_cast<RooHist*>(findObject(name)) ;
876}
877
878
879
880////////////////////////////////////////////////////////////////////////////////
881/// Remove object with given name, or last object added if no name is given.
882
883void RooPlot::remove(const char* name, bool deleteToo)
884{
885 if(name == nullptr) {
886 if(!_items.empty()) {
887 if(deleteToo) delete _items.back().first;
888 _items.pop_back();
889 } else {
890 coutE(InputArguments) << "RooPlot::remove(" << GetName() << ") ERROR: plot frame is empty, cannot remove last object" << endl ;
891 }
892 } else {
893 auto item = findItem(name);
894 if(item == _items.end()) {
895 coutE(InputArguments) << "RooPlot::remove(" << GetName() << ") ERROR: no object found with name " << name << endl ;
896 } else {
897 if(deleteToo) delete item->first;
898 _items.erase(item);
899 }
900 }
901}
902
903
904namespace {
905
906template<class Iter>
907void moveBefore(Iter before, Iter target) {
908 auto d = std::distance(before, target);
909 if(d > 0) std::rotate(before, target, target + 1);
910 else if(d < 0) std::rotate(target, target+1, before);
911}
912
913} // namespace
914
915
916////////////////////////////////////////////////////////////////////////////////
917/// Change the order in which our contained objects are drawn so that
918/// the target object is drawn just before the specified object.
919/// Returns false if either object does not exist.
920
921bool RooPlot::drawBefore(const char *before, const char *target)
922{
923 auto iterBefore = findItem(before);
924 auto iterTarget = findItem(target);
925 if(iterBefore == _items.end() || iterTarget == _items.end()) return false;
926 moveBefore(iterBefore, iterTarget);
927 return true;
928}
929
930
931////////////////////////////////////////////////////////////////////////////////
932/// Change the order in which our contained objects are drawn so that
933/// the target object is drawn just after the specified object.
934/// Returns false if either object does not exist.
935
936bool RooPlot::drawAfter(const char *after, const char *target)
937{
938 auto iterAfter = findItem(after);
939 auto iterTarget = findItem(target);
940 if(iterAfter == _items.end() || iterTarget == _items.end()) return false;
941 moveBefore(iterAfter + 1, iterTarget);
942 return true;
943}
944
945
946////////////////////////////////////////////////////////////////////////////////
947/// Find the named object in our list of items and return a pointer
948/// to it. Return zero and print a warning message if the named
949/// object cannot be found. If no name is supplied the last object
950/// added is returned.
951///
952/// Note that the returned pointer is to a
953/// TObject and so will generally need casting. Use the getAtt...()
954/// methods to change the drawing style attributes of a contained
955/// object directly.
956
957TObject *RooPlot::findObject(const char *name, const TClass* clas) const
958{
959 TObject *ret = nullptr;
960
961 for(auto const& item : _items) {
962 TObject &obj = *item.first;
963 if ((!name || name[0] == '\0' || !TString(name).CompareTo(obj.GetName()))
964 && (!clas || (obj.IsA()==clas))) {
965 ret = &obj ;
966 }
967 }
968
969 if (ret == nullptr) {
970 coutE(InputArguments) << "RooPlot::findObject(" << GetName() << ") cannot find object " << (name?name:"<last>") << endl ;
971 }
972 return ret ;
973}
974
975
976RooPlot::Items::iterator RooPlot::findItem(std::string const& name)
977{
978 return std::find_if(_items.begin(), _items.end(), [&name](auto const& item){
979 return name == item.first->GetName();
980 });
981}
982
983RooPlot::Items::const_iterator RooPlot::findItem(std::string const& name) const
984{
985 return std::find_if(_items.begin(), _items.end(), [&name](auto const& item){
986 return name == item.first->GetName();
987 });
988}
989
990
991////////////////////////////////////////////////////////////////////////////////
992/// Return the Draw() options registered for the named object. Return
993/// an empty string if the named object cannot be found.
994
996{
997 auto item = findItem(name);
998 if(item == _items.end()) return "";
999
1000 return DrawOpt{item->second.c_str()}.drawOptions;
1001}
1002
1003
1004////////////////////////////////////////////////////////////////////////////////
1005/// Register the specified drawing options for the named object.
1006/// Return false if the named object cannot be found.
1007
1008bool RooPlot::setDrawOptions(const char *name, TString options)
1009{
1010 auto item = findItem(name);
1011 if(item == _items.end()) return false;
1012
1013 DrawOpt opt(item->second.c_str()) ;
1014 strlcpy(opt.drawOptions,options,128) ;
1015 item->second = opt.rawOpt();
1016 return true;
1017}
1018
1019
1020////////////////////////////////////////////////////////////////////////////////
1021/// Returns true of object with given name is set to be invisible
1022
1023bool RooPlot::getInvisible(const char* name) const
1024{
1025 auto item = findItem(name);
1026 if(item == _items.end()) return false;
1027
1028 return DrawOpt{item->second.c_str()}.invisible ;
1029}
1030
1031
1032////////////////////////////////////////////////////////////////////////////////
1033/// If flag is true object with 'name' is set to be invisible
1034/// i.e. it is not drawn when Draw() is called
1035
1036void RooPlot::setInvisible(const char* name, bool flag)
1037{
1038 auto item = findItem(name);
1039 if(item != _items.end()) {
1040 DrawOpt opt;
1041 opt.initialize(item->second.c_str());
1042 opt.invisible = flag;
1043 item->second = opt.rawOpt();
1044 }
1045
1046}
1047
1048
1049////////////////////////////////////////////////////////////////////////////////
1050/// Set maximum value of Y axis
1051
1052void RooPlot::SetMaximum(double maximum)
1053{
1054 _hist->SetMaximum(maximum==-1111?_defYmax:maximum) ;
1055}
1056
1057
1058
1059////////////////////////////////////////////////////////////////////////////////
1060/// Set minimum value of Y axis
1061
1062void RooPlot::SetMinimum(double minimum)
1063{
1064 _hist->SetMinimum(minimum==-1111?_defYmin:minimum) ;
1065}
1066
1067
1068
1069////////////////////////////////////////////////////////////////////////////////
1070/// Calculate and return reduced chi-squared between a curve and a histogram.
1071///
1072/// \param[in] curvename Name of the curve or nullptr for last curve
1073/// \param[in] histname Name of the histogram to compare to or nullptr for last added histogram
1074/// \param[in] nFitParam If non-zero, reduce the number of degrees of freedom by this
1075/// number. This means that the curve was fitted to the data with nFitParam floating
1076/// parameters, which needs to be reflected in the calculation of \f$\chi^2 / \mathrm{ndf}\f$.
1077///
1078/// \return \f$ \chi^2 / \mathrm{ndf} \f$ between the plotted curve and the data.
1079///
1080/// \note The \f$ \chi^2 \f$ is calculated between a *plot of the original distribution* and the data.
1081/// It therefore has more rounding errors than directly calculating the \f$ \chi^2 \f$ from a PDF or
1082/// function. To do this, use RooChi2Var.
1083double RooPlot::chiSquare(const char* curvename, const char* histname, int nFitParam) const
1084{
1085
1086 // Find curve object
1087 RooCurve* curve = (RooCurve*) findObject(curvename,RooCurve::Class()) ;
1088 if (!curve) {
1089 coutE(InputArguments) << "RooPlot::chiSquare(" << GetName() << ") cannot find curve" << endl ;
1090 return -1. ;
1091 }
1092
1093 // Find histogram object
1094 RooHist* hist = (RooHist*) findObject(histname,RooHist::Class()) ;
1095 if (!hist) {
1096 coutE(InputArguments) << "RooPlot::chiSquare(" << GetName() << ") cannot find histogram" << endl ;
1097 return -1. ;
1098 }
1099
1100 return curve->chiSquare(*hist,nFitParam) ;
1101}
1102
1103
1104////////////////////////////////////////////////////////////////////////////////
1105/// Return a RooHist (derives from TGraphAsymErrors) containing the residuals of a histogram.
1106/// The plotting range of the graph is adapted to the plotting range of the current plot.
1107///
1108/// \param histname Name of the data histogram.
1109/// Passing an empty string or `nullptr` will create residuals of the last-plotted histogram.
1110/// \param curvename Name of the curve to compare to data.
1111/// Passing an empty string or `nullptr` will create residuals of the last-plotted curve.
1112/// \param normalize If true, the residuals are divided by the error
1113/// of the histogram, effectively returning a pull histogram.
1114/// \param useAverage If true, the histogram is compared with the curve averaged in each bin.
1115/// Otherwise, the curve is evaluated at the bin centres, which is not accurate for strongly curved distributions.
1116RooHist* RooPlot::residHist(const char* histname, const char* curvename, bool normalize, bool useAverage) const
1117{
1118 // Find all curve objects with the name "curvename" or the name of the last
1119 // plotted curve (there might be multiple in the case of multi-range fits).
1120 std::vector<RooCurve *> curves;
1121
1122 for(auto it = _items.rbegin(); it != _items.rend(); ++it) {
1123 TObject &obj = *it->first;
1124 if(obj.IsA() == RooCurve::Class()) {
1125 // If no curvename was passed, we take by default the last curve and all
1126 // other curves that have the same name
1127 if((!curvename || curvename[0] == '\0') || std::string(curvename) == obj.GetName()) {
1128 curvename = obj.GetName();
1129 curves.push_back(static_cast<RooCurve*>(&obj));
1130 }
1131 }
1132 }
1133
1134 if (curves.empty()) {
1135 coutE(InputArguments) << "RooPlot::residHist(" << GetName() << ") cannot find curve" << std::endl;
1136 return nullptr;
1137 }
1138
1139 // Find histogram object
1140 auto hist = static_cast<RooHist*>(findObject(histname,RooHist::Class()));
1141 if (!hist) {
1142 coutE(InputArguments) << "RooPlot::residHist(" << GetName() << ") cannot find histogram" << std::endl;
1143 return nullptr;
1144 }
1145
1146 auto residHist = hist->createEmptyResidHist(*curves.front(), normalize);
1147
1148 // We consider all curves with the same name as long as the ranges don't
1149 // overlap, to create also the full residual plot in multi-range fits.
1150 std::vector<std::pair<double, double>> coveredRanges;
1151 for(RooCurve * curve : curves) {
1152 const double xmin = curve->GetPointX(0);
1153 const double xmax = curve->GetPointX(curve->GetN() - 1);
1154
1155 for(auto const& prevRange : coveredRanges) {
1156 const double pxmin = prevRange.first;
1157 const double pxmax = prevRange.second;
1158 // If either xmin or xmax is within any previous range, the ranges
1159 // overloap and it makes to sense to also consider this curve for the
1160 // residuals (i.e., they can't come from a multi-range fit).
1161 if((pxmax > xmin && pxmin <= xmin) || (pxmax > xmax && pxmin <= xmax)) {
1162 continue;
1163 }
1164 }
1165
1166 coveredRanges.emplace_back(xmin, xmax);
1167
1168 hist->fillResidHist(*residHist, *curve, normalize, useAverage);
1169 }
1172 residHist->GetHistogram()->GetYaxis()->SetTitle(normalize ? "(Data - curve) / #sigma_{data}" : "Data - curve");
1173 return residHist.release();
1174}
1175
1176
1177
1178////////////////////////////////////////////////////////////////////////////////
1179/// Initialize the DrawOpt helper class
1180
1181void RooPlot::DrawOpt::initialize(const char* inRawOpt)
1182{
1183 if (!inRawOpt) {
1184 drawOptions[0] = 0 ;
1185 invisible=false ;
1186 return ;
1187 }
1188 strlcpy(drawOptions,inRawOpt,128) ;
1189 strtok(drawOptions,":") ;
1190 const char* extraOpt = strtok(0,":") ;
1191 if (extraOpt) {
1192 invisible = (extraOpt[0]=='I') ;
1193 }
1194}
1195
1196
1197////////////////////////////////////////////////////////////////////////////////
1198/// Return the raw draw options
1199
1200const char* RooPlot::DrawOpt::rawOpt() const
1201{
1202 static char buf[128] ;
1203 strlcpy(buf,drawOptions,128) ;
1204 if (invisible) {
1205 strlcat(buf,":I",128) ;
1206 }
1207 return buf ;
1208}
1209
1210
1211
1212////////////////////////////////////////////////////////////////////////////////
1213/// Return the number of events that is associated with the range [xlo,xhi]
1214/// This method is only fully functional for ranges not equal to the full
1215/// range if the object that inserted the normalization data provided
1216/// a link to an external object that can calculate the event count in
1217/// in sub ranges. An error will be printed if this function is used
1218/// on sub-ranges while that information is not available
1219
1220double RooPlot::getFitRangeNEvt(double xlo, double xhi) const
1221{
1222 double scaleFactor = 1.0 ;
1223 if (_normObj) {
1224 scaleFactor = _normObj->getFitRangeNEvt(xlo,xhi)/_normObj->getFitRangeNEvt() ;
1225 } else {
1226 coutW(Plotting) << "RooPlot::getFitRangeNEvt(" << GetName() << ") WARNING: Unable to obtain event count in range "
1227 << xlo << " to " << xhi << ", substituting full event count" << endl ;
1228 }
1229 return getFitRangeNEvt()*scaleFactor ;
1230}
1231
1232
1233////////////////////////////////////////////////////////////////////////////////
1234/// Set the name of the RooPlot to 'name'
1235
1236void RooPlot::SetName(const char *name)
1237{
1238 if (_dir) _dir->GetList()->Remove(this);
1240 if (_dir) _dir->GetList()->Add(this);
1241}
1242
1243
1244////////////////////////////////////////////////////////////////////////////////
1245/// Set the name and title of the RooPlot to 'name' and 'title'
1246
1247void RooPlot::SetNameTitle(const char *name, const char* title)
1248{
1249 if (_dir) _dir->GetList()->Remove(this);
1250 TNamed::SetNameTitle(name,title) ;
1251 if (_dir) _dir->GetList()->Add(this);
1252}
1253
1254
1255////////////////////////////////////////////////////////////////////////////////
1256/// Set the title of the RooPlot to 'title'
1257
1258void RooPlot::SetTitle(const char* title)
1259{
1260 TNamed::SetTitle(title) ;
1261 _hist->SetTitle(title) ;
1262}
1263
1264
1265
1266////////////////////////////////////////////////////////////////////////////////
1267/// Define default print options, for a given print style
1268
1270{
1271 return kName|kArgs|kValue ;
1272}
1273
1274
1275
1276/// \see TH1::GetXaxis()
1277TAxis* RooPlot::GetXaxis() const { return _hist->GetXaxis() ; }
1278/// \see TH1::GetYaxis()
1279TAxis* RooPlot::GetYaxis() const { return _hist->GetYaxis() ; }
1280/// \see TH1::GetNbinsX()
1282/// \see TH1::GetNdivisions()
1284/// \see TH1::GetMinimum()
1285double RooPlot::GetMinimum(double minval) const { return _hist->GetMinimum(minval) ; }
1286/// \see TH1::GetMaximum()
1287double RooPlot::GetMaximum(double maxval) const { return _hist->GetMaximum(maxval) ; }
1288
1289
1290/// \see TH1::SetAxisColor()
1291void RooPlot::SetAxisColor(Color_t color, Option_t* axis) { _hist->SetAxisColor(color,axis) ; }
1292/// \see TH1::SetAxisRange()
1293void RooPlot::SetAxisRange(double xmin, double xmax, Option_t* axis) { _hist->SetAxisRange(xmin,xmax,axis) ; }
1294/// \see TH1::SetBarOffset()
1296/// \see TH1::SetBarWidth()
1298/// \see TH1::SetContour()
1299void RooPlot::SetContour(Int_t nlevels, const double* levels) { _hist->SetContour(nlevels,levels) ; }
1300/// \see TH1::SetContourLevel()
1302/// \see TH1::SetDrawOption()
1304/// \see TH1::SetFillAttributes()
1306/// \see TH1::SetFillColor()
1308/// \see TH1::SetFillStyle()
1310/// \see TH1::SetLabelColor()
1311void RooPlot::SetLabelColor(Color_t color, Option_t* axis) { _hist->SetLabelColor(color,axis) ; }
1312/// \see TH1::SetLabelFont()
1313void RooPlot::SetLabelFont(Style_t font, Option_t* axis) { _hist->SetLabelFont(font,axis) ; }
1314/// \see TH1::SetLabelOffset()
1316/// \see TH1::SetLabelSize()
1318/// \see TH1::SetLineAttributes()
1320/// \see TH1::SetLineColor()
1322/// \see TH1::SetLineStyle()
1324/// \see TH1::SetLineWidth()
1326/// \see TH1::SetMarkerAttributes()
1328/// \see TH1::SetMarkerColor()
1330/// \see TH1::SetMarkerSize()
1332/// \see TH1::SetMarkerStyle()
1334/// \see TH1::SetNdivisions()
1336/// \see TH1::SetOption()
1338/// Like TH1::SetStats(), but statistics boxes are *off* by default in RooFit.
1339void RooPlot::SetStats(bool stats) { _hist->SetStats(stats) ; }
1340/// \see TH1::SetTickLength()
1342/// \see TH1::SetTitleFont()
1343void RooPlot::SetTitleFont(Style_t font, Option_t* axis) { _hist->SetTitleFont(font,axis) ; }
1344/// \see TH1::SetTitleOffset()
1346/// \see TH1::SetTitleSize()
1348/// \see TH1::SetXTitle()
1349void RooPlot::SetXTitle(const char *title) { _hist->SetXTitle(title) ; }
1350/// \see TH1::SetYTitle()
1351void RooPlot::SetYTitle(const char *title) { _hist->SetYTitle(title) ; }
1352/// \see TH1::SetZTitle()
1353void RooPlot::SetZTitle(const char *title) { _hist->SetZTitle(title) ; }
1354
1355
1356
1357
1358////////////////////////////////////////////////////////////////////////////////
1359/// Plot RooPlot when double-clicked in browser
1360
1362{
1363 Draw();
1364 gPad->Update();
1365}
1366
1367
1368
1369
1370////////////////////////////////////////////////////////////////////////////////
1371
1373{
1374 // Custom streamer, needed for backward compatibility
1375
1376 if (R__b.IsReading()) {
1377 const bool oldAddDir = TH1::AddDirectoryStatus();
1378 TH1::AddDirectory(false);
1379
1380 // The default c'tor might have registered this with a TDirectory.
1381 // Streaming the TNamed will make this not retrievable anymore, so
1382 // unregister first.
1383 if (_dir)
1384 _dir->Remove(this);
1385
1386 UInt_t R__s, R__c;
1387 Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
1388 if (R__v > 1) {
1389 R__b.ReadClassBuffer(RooPlot::Class(),this,R__v,R__s,R__c);
1390 } else {
1391 // backward compatible streamer code here
1392 // Version 1 of RooPlot was deriving from TH1 and RooPrintable
1393 // Version 2 derives instead from TNamed and RooPrintable
1394 _hist = new TH1F();
1395 _hist->TH1::Streamer(R__b);
1396 SetName(_hist->GetName());
1399 {
1400 TList itemsList;
1401 itemsList.Streamer(R__b);
1403 }
1404 R__b >> _padFactor;
1405 R__b >> _plotVar;
1406 R__b >> _plotVarSet;
1407 R__b >> _normVars;
1408 R__b >> _normNumEvts;
1409 R__b >> _normBinWidth;
1410 R__b >> _defYmin;
1411 R__b >> _defYmax;
1412 R__b.CheckByteCount(R__s, R__c, RooPlot::IsA());
1413 }
1414
1415 TH1::AddDirectory(oldAddDir);
1416 if (_dir)
1417 _dir->Append(this);
1418
1419 } else {
1420 R__b.WriteClassBuffer(RooPlot::Class(),this);
1421 }
1422}
1423
1424////////////////////////////////////////////////////////////////////////////////
1425/// Build a legend that contains all objects that have been drawn on the plot.
1426std::unique_ptr<TLegend> RooPlot::BuildLegend() const {
1427 auto leg = std::make_unique<TLegend>(0.5, 0.7, 0.9, 0.9);
1428 leg->SetBorderSize(0);
1429 leg->SetFillStyle(0);
1430 for (std::size_t i=0; i < _items.size(); ++i) {
1431 leg->AddEntry(getObject(i));
1432 }
1433
1434 return leg;
1435}
1436
1437/// RooFit-internal function for backwards compatibility.
1439 for(TObject * obj : tlist) {
1440 items.emplace_back(obj, obj->GetOption());
1441 }
1442}
1443
1444/// Replaces the pointer to the plot variable with a pointer to a clone of the
1445/// plot variable that is owned by this RooPlot. The RooPlot references the
1446/// plotted variable by non-owning pointer by default since ROOT 6.28, which
1447/// resulted in a big speedup when plotting complicated pdfs that are expensive
1448/// to clone. However, going back to an owned clone is useful in rare cases.
1449/// For example in the RooUnitTest, where the registered plots need to live
1450/// longer than the scope of the unit test.
1452 // If the plot variable is already cloned, we don't need to do anything.
1453 if(_plotVarSet) return;
1454 _plotVarSet = static_cast<RooArgSet*>(RooArgSet(*_plotVar).snapshot());
1456}
#define d(i)
Definition: RSha256.hxx:102
#define e(i)
Definition: RSha256.hxx:103
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
#define coutI(a)
Definition: RooMsgService.h:34
#define coutW(a)
Definition: RooMsgService.h:36
#define coutE(a)
Definition: RooMsgService.h:37
short Style_t
Definition: RtypesCore.h:89
short Color_t
Definition: RtypesCore.h:92
float Size_t
Definition: RtypesCore.h:96
short Version_t
Definition: RtypesCore.h:65
short Width_t
Definition: RtypesCore.h:91
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:375
static void indent(ostringstream &buf, int indent_level)
#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 Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
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 target
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 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 length
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t width
char name[80]
Definition: TGX11.cxx:110
float xmin
Definition: THbookFile.cxx:95
float ymin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
float ymax
Definition: THbookFile.cxx:95
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition: TString.cxx:2468
#define gPad
Definition: TVirtualPad.h:302
int binNumber(double x) const
Returns the bin number corresponding to the value x.
Definition: RooAbsBinning.h:60
virtual double binCenter(Int_t bin) const =0
Int_t numBins() const
Return number of bins.
Definition: RooAbsBinning.h:36
virtual double binLow(Int_t bin) const =0
virtual double binHigh(Int_t bin) const =0
RooAbsArg * find(const char *name) const
Find object with given name in list.
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
virtual const RooAbsBinning & getBinning(const char *name=nullptr, bool verbose=true, bool createOnTheFly=false) const =0
Retrive binning configuration with given name or default binning.
virtual double getMax(const char *name=nullptr) const
Get maximum of currently defined range.
bool hasMax(const char *name=nullptr) const
Check if variable has an upper bound.
virtual double getMin(const char *name=nullptr) const
Get minimum of currently defined range.
bool hasMin(const char *name=nullptr) const
Check if variable has a lower bound.
TString getTitle(bool appendUnit=false) const
Return this variable's title std::string.
Definition: RooAbsReal.cxx:225
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:56
RooArgSet * snapshot(bool deepCopy=true) const
Use RooAbsCollection::snapshot(), but return as RooArgSet.
Definition: RooArgSet.h:179
A RooCurve is a one-dimensional graphical representation of a real-valued function.
Definition: RooCurve.h:32
double chiSquare(const RooHist &hist, int nFitParam) const
Calculate the chi^2/NDOF of this curve with respect to the histogram 'hist' accounting nFitParam floa...
Definition: RooCurve.cxx:555
static TClass * Class()
A RooHist is a graphical representation of binned data based on the TGraphAsymmErrors class.
Definition: RooHist.h:29
static TClass * Class()
char drawOptions[128]
Definition: RooPlot.h:220
void initialize(const char *_rawOpt)
Initialize the DrawOpt helper class.
Definition: RooPlot.cxx:1181
const char * rawOpt() const
Return the raw draw options.
Definition: RooPlot.cxx:1200
A RooPlot is a plot frame and a container for graphics objects within that frame.
Definition: RooPlot.h:43
RooPlot()
Default constructor coverity[UNINIT_CTOR].
Definition: RooPlot.cxx:87
void SetName(const char *name) override
Set the name of the RooPlot to 'name'.
Definition: RooPlot.cxx:1236
void SetAxisColor(Color_t color=1, Option_t *axis="X")
Definition: RooPlot.cxx:1291
void remove(const char *name=nullptr, bool deleteToo=true)
Remove object with given name, or last object added if no name is given.
Definition: RooPlot.cxx:883
void SetDrawOption(Option_t *option="") override
Definition: RooPlot.cxx:1303
void updateYAxis(double ymin, double ymax, const char *label="")
Update our y-axis limits to accomodate an object whose spread in y is (ymin,ymax).
Definition: RooPlot.cxx:620
Items _items
A list of the items we contain.
Definition: RooPlot.h:235
void SetMarkerSize(Size_t msize=1)
Definition: RooPlot.cxx:1331
static RooPlot * frame(const RooAbsRealLValue &var, double xmin, double xmax, Int_t nBins)
Create a new frame for a given variable in x.
Definition: RooPlot.cxx:239
const RooPlotable * _normObj
! Pointer to normalization object ;
Definition: RooPlot.h:241
double _normNumEvts
Number of events in histogram (for normalization)
Definition: RooPlot.h:242
TObject * findObject(const char *name, const TClass *clas=nullptr) const
Find the named object in our list of items and return a pointer to it.
Definition: RooPlot.cxx:957
bool drawBefore(const char *before, const char *target)
Change the order in which our contained objects are drawn so that the target object is drawn just bef...
Definition: RooPlot.cxx:921
bool getInvisible(const char *name) const
Returns true of object with given name is set to be invisible.
Definition: RooPlot.cxx:1023
void SetTitle(const char *name) override
Set the title of the RooPlot to 'title'.
Definition: RooPlot.cxx:1258
RooArgSet * _normVars
Variables that PDF plots should be normalized over.
Definition: RooPlot.h:239
void addObject(TObject *obj, Option_t *drawOptions="", bool invisible=false)
Add a generic object to this plot.
Definition: RooPlot.cxx:383
void addTH1(TH1 *hist, Option_t *drawOptions="", bool invisible=false)
Add a TH1 histogram object to this plot.
Definition: RooPlot.cxx:402
double _padFactor
Scale our y-axis to _padFactor of our maximum contents.
Definition: RooPlot.h:236
void SetMarkerColor(Color_t tcolor=1)
Definition: RooPlot.cxx:1329
void printMultiline(std::ostream &os, Int_t content, bool verbose=false, TString indent="") const override
Frame detailed printing.
Definition: RooPlot.cxx:753
void SetXTitle(const char *title)
Definition: RooPlot.cxx:1349
void SetFillColor(Color_t fcolor)
Definition: RooPlot.cxx:1307
RooArgSet * _plotVarSet
A list owning the cloned tree nodes of the plotVarClone.
Definition: RooPlot.h:238
void SetNdivisions(Int_t n=510, Option_t *axis="X")
Definition: RooPlot.cxx:1335
TDirectory * _dir
! non-persistent
Definition: RooPlot.h:248
TString histName() const
Construct automatic name of internal TH1.
Definition: RooPlot.cxx:318
TH1 * _hist
Histogram that we uses as basis for drawing the content.
Definition: RooPlot.h:234
void SetMarkerStyle(Style_t mstyle=1)
Definition: RooPlot.cxx:1333
void printName(std::ostream &os) const override
Print frame name.
Definition: RooPlot.cxx:684
TString getDrawOptions(const char *name) const
Return the Draw() options registered for the named object.
Definition: RooPlot.cxx:995
double _normBinWidth
Histogram bin width (for normalization)
Definition: RooPlot.h:243
void SetZTitle(const char *title)
Definition: RooPlot.cxx:1353
void setInvisible(const char *name, bool flag=true)
If flag is true object with 'name' is set to be invisible i.e.
Definition: RooPlot.cxx:1036
void Streamer(TBuffer &) override
Stream an object of class TObject.
Definition: RooPlot.cxx:1372
void SetContour(Int_t nlevels, const double *levels=nullptr)
Definition: RooPlot.cxx:1299
void printClassName(std::ostream &os) const override
Print frame class name.
Definition: RooPlot.cxx:702
bool setDrawOptions(const char *name, TString options)
Register the specified drawing options for the named object.
Definition: RooPlot.cxx:1008
void SetStats(bool stats=true)
Like TH1::SetStats(), but statistics boxes are off by default in RooFit.
Definition: RooPlot.cxx:1339
double getFitRangeNEvt() const
Return the number of events in the fit range.
Definition: RooPlot.h:139
virtual void SetMinimum(double minimum=-1111)
Set minimum value of Y axis.
Definition: RooPlot.cxx:1062
std::vector< std::pair< TObject *, std::string > > Items
Definition: RooPlot.h:45
double GetMaximum(double maxval=FLT_MAX) const
Definition: RooPlot.cxx:1287
TAttLine * getAttLine(const char *name=nullptr) const
Return a pointer to the line attributes of the named object in this plot, or zero if the named object...
Definition: RooPlot.cxx:822
bool drawAfter(const char *after, const char *target)
Change the order in which our contained objects are drawn so that the target object is drawn just aft...
Definition: RooPlot.cxx:936
RooAbsRealLValue * _plotVar
The variable we are plotting.
Definition: RooPlot.h:237
void SetDirectory(TDirectory *dir)
Set the directory that this plot is associated to.
Definition: RooPlot.cxx:350
~RooPlot() override
Destructor.
Definition: RooPlot.cxx:331
void SetLabelOffset(Float_t offset=0.005, Option_t *axis="X")
Definition: RooPlot.cxx:1315
TAttFill * getAttFill(const char *name=nullptr) const
Return a pointer to the fill attributes of the named object in this plot, or zero if the named object...
Definition: RooPlot.cxx:832
void printTitle(std::ostream &os) const override
Print frame title.
Definition: RooPlot.cxx:693
void SetLineWidth(Width_t lwidth)
Definition: RooPlot.cxx:1325
void SetTickLength(Float_t length=0.02, Option_t *axis="X")
Definition: RooPlot.cxx:1341
void SetFillAttributes()
Definition: RooPlot.cxx:1305
void SetContourLevel(Int_t level, double value)
Definition: RooPlot.cxx:1301
static bool addDirectoryStatus()
Query whether new instances of RooPlot will add themselves to gDirectory.
Definition: RooPlot.cxx:79
void SetLabelSize(Float_t size=0.02, Option_t *axis="X")
Definition: RooPlot.cxx:1317
double chiSquare(int nFitParam=0) const
Shortcut for RooPlot::chiSquare(const char* pdfname, const char* histname, int nFitParam=nullptr)
Definition: RooPlot.h:174
Items::iterator findItem(std::string const &name)
Definition: RooPlot.cxx:976
void SetOption(Option_t *option=" ")
Definition: RooPlot.cxx:1337
TObject * getObject(Int_t idx) const
Return the name of the object at slot 'idx' in this RooPlot.
Definition: RooPlot.cxx:806
virtual void SetMaximum(double maximum=-1111)
Set maximum value of Y axis.
Definition: RooPlot.cxx:1052
TAxis * GetYaxis() const
Definition: RooPlot.cxx:1279
void Draw(Option_t *options=nullptr) override
Draw this plot and all of the elements it contains.
Definition: RooPlot.cxx:652
void SetLabelFont(Style_t font=62, Option_t *axis="X")
Definition: RooPlot.cxx:1313
void Browse(TBrowser *b) override
Plot RooPlot when double-clicked in browser.
Definition: RooPlot.cxx:1361
double _defYmax
Default maximum for Yaxis (as calculated from contents)
Definition: RooPlot.h:246
void SetLineStyle(Style_t lstyle)
Definition: RooPlot.cxx:1323
TAttMarker * getAttMarker(const char *name=nullptr) const
Return a pointer to the marker attributes of the named object in this plot, or zero if the named obje...
Definition: RooPlot.cxx:842
void SetTitleFont(Style_t font=62, Option_t *axis="X")
Definition: RooPlot.cxx:1343
void SetAxisRange(double xmin, double xmax, Option_t *axis="X")
Definition: RooPlot.cxx:1293
TAxis * GetXaxis() const
Definition: RooPlot.cxx:1277
void SetLineColor(Color_t lcolor)
Definition: RooPlot.cxx:1321
void SetFillStyle(Style_t fstyle)
Definition: RooPlot.cxx:1309
const char * nameOf(Int_t idx) const
Return the name of the object at slot 'idx' in this RooPlot.
Definition: RooPlot.cxx:790
void updateNormVars(const RooArgSet &vars)
Install the given set of observables are reference normalization variables for this frame.
Definition: RooPlot.cxx:368
RooHist * residHist(const char *histname=nullptr, const char *pdfname=nullptr, bool normalize=false, bool useAverage=true) const
Return a RooHist (derives from TGraphAsymErrors) containing the residuals of a histogram.
Definition: RooPlot.cxx:1116
RooPlot * emptyClone(const char *name)
Return empty clone of current RooPlot.
Definition: RooPlot.cxx:285
void SetMarkerAttributes()
Definition: RooPlot.cxx:1327
void createInternalPlotVarClone()
Replaces the pointer to the plot variable with a pointer to a clone of the plot variable that is owne...
Definition: RooPlot.cxx:1451
void SetNameTitle(const char *name, const char *title) override
Set the name and title of the RooPlot to 'name' and 'title'.
Definition: RooPlot.cxx:1247
void setPadFactor(double factor)
Definition: RooPlot.h:144
Int_t defaultPrintContents(Option_t *opt) const override
Define default print options, for a given print style.
Definition: RooPlot.cxx:1269
RooCurve * getCurve(const char *name=nullptr) const
Return a RooCurve pointer of the named object in this plot, or zero if the named object does not exis...
Definition: RooPlot.cxx:863
static bool setAddDirectoryStatus(bool flag)
Configure whether new instances of RooPlot will add themselves to gDirectory.
Definition: RooPlot.cxx:80
TAttText * getAttText(const char *name=nullptr) const
Return a pointer to the text attributes of the named object in this plot, or zero if the named object...
Definition: RooPlot.cxx:852
void SetLabelColor(Color_t color=1, Option_t *axis="X")
Definition: RooPlot.cxx:1311
TClass * IsA() const override
Definition: RooPlot.h:252
Int_t GetNbinsX() const
Definition: RooPlot.cxx:1281
static void fillItemsFromTList(Items &items, TList const &tlist)
RooFit-internal function for backwards compatibility.
Definition: RooPlot.cxx:1438
void SetLineAttributes()
Definition: RooPlot.cxx:1319
static bool _addDirStatus
static flag controlling AutoDirectoryAdd feature
Definition: RooPlot.h:250
void printValue(std::ostream &os) const override
Print frame arguments.
Definition: RooPlot.cxx:725
void SetYTitle(const char *title)
Definition: RooPlot.cxx:1351
double getPadFactor() const
Definition: RooPlot.h:143
void printArgs(std::ostream &os) const override
Interface for printing of object arguments.
Definition: RooPlot.cxx:711
std::unique_ptr< TLegend > BuildLegend() const
Build a legend that contains all objects that have been drawn on the plot.
Definition: RooPlot.cxx:1426
RooHist * getHist(const char *name=nullptr) const
Return a RooCurve pointer of the named object in this plot, or zero if the named object does not exis...
Definition: RooPlot.cxx:873
void updateFitRangeNorm(const TH1 *hist)
Update our plot normalization over our plot variable's fit range, which will be determined by the fir...
Definition: RooPlot.cxx:565
void SetTitleSize(Float_t size=0.02, Option_t *axis="X")
Definition: RooPlot.cxx:1347
double _defYmin
Default minimum for Yaxis (as calculated from contents)
Definition: RooPlot.h:245
static TClass * Class()
void SetBarOffset(Float_t offset=0.25)
Definition: RooPlot.cxx:1295
void SetBarWidth(Float_t width=0.5)
Definition: RooPlot.cxx:1297
Int_t GetNdivisions(Option_t *axis="X") const
Definition: RooPlot.cxx:1283
void addPlotable(RooPlotable *plotable, Option_t *drawOptions="", bool invisible=false, bool refreshNorm=false)
Add the specified plotable object to our plot.
Definition: RooPlot.cxx:531
void initialize()
Perform initialization that is common to all constructors.
Definition: RooPlot.cxx:296
static RooPlot * frameWithLabels(const RooAbsRealLValue &var)
Create a new frame for a given variable in x, adding bin labels.
Definition: RooPlot.cxx:251
void SetTitleOffset(Float_t offset=1, Option_t *axis="X")
Definition: RooPlot.cxx:1345
double GetMinimum(double minval=-FLT_MAX) const
Definition: RooPlot.cxx:1285
Class RooPotable is a base class for objects that can be inserted into RooPlots and take advantage of...
Definition: RooPlotable.h:26
virtual double getFitRangeNEvt() const =0
TObject * crossCast()
Return cast of RooPlotable as TObject.
Definition: RooPlotable.cxx:52
double getYAxisMin() const
Definition: RooPlotable.h:41
double getYAxisMax() const
Definition: RooPlotable.h:42
const char * getYAxisLabel() const
Definition: RooPlotable.h:31
virtual double getFitRangeBinW() const =0
RooPlotable is a 'mix-in' base class that define the standard RooFit plotting and printing methods.
Definition: RooPrintable.h:25
static TClass * Class()
virtual void Streamer(TBuffer &)
virtual void printStream(std::ostream &os, Int_t contents, StyleOption style, TString indent="") const
Print description of object on ostream, printing contents set by contents integer,...
void Set(Int_t n) override
Set size of this array to n doubles.
Definition: TArrayD.cxx:106
Fill Area Attributes class.
Definition: TAttFill.h:19
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition: TAttFill.h:37
virtual void SetFillAttributes()
Invoke the DialogCanvas Fill attributes.
Definition: TAttFill.cxx:251
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition: TAttFill.h:39
Line Attributes class.
Definition: TAttLine.h:18
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition: TAttLine.h:42
virtual void SetLineAttributes()
Invoke the DialogCanvas Line attributes.
Definition: TAttLine.cxx:292
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
Marker Attributes class.
Definition: TAttMarker.h:19
virtual void SetMarkerColor(Color_t mcolor=1)
Set the marker color.
Definition: TAttMarker.h:38
virtual void SetMarkerAttributes()
Invoke the DialogCanvas Marker attributes.
Definition: TAttMarker.cxx:364
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
Text Attributes class.
Definition: TAttText.h:18
Class to manage histogram axis.
Definition: TAxis.h:30
virtual void SetBinLabel(Int_t bin, const char *label)
Set label for bin.
Definition: TAxis.cxx:851
Bool_t IsAlphanumeric() const
Definition: TAxis.h:84
const char * GetTitle() const override
Returns title of object.
Definition: TAxis.h:130
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition: TAxis.cxx:478
Double_t GetXmax() const
Definition: TAxis.h:135
const char * GetBinLabel(Int_t bin) const
Return label for bin.
Definition: TAxis.cxx:440
Double_t GetXmin() const
Definition: TAxis.h:134
virtual void SetRangeUser(Double_t ufirst, Double_t ulast)
Set the viewing range for the axis from ufirst to ulast (in user coordinates, that is,...
Definition: TAxis.cxx:978
virtual Double_t GetBinWidth(Int_t bin) const
Return bin width.
Definition: TAxis.cxx:540
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition: TAxis.cxx:528
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
virtual Version_t ReadVersion(UInt_t *start=nullptr, UInt_t *bcnt=nullptr, const TClass *cl=nullptr)=0
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=nullptr)=0
Bool_t IsReading() const
Definition: TBuffer.h:86
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:81
Bool_t InheritsFrom(const char *cl) const override
Return kTRUE if this class inherits from a class with name "classname".
Definition: TClass.cxx:4863
Describe directory structure in memory.
Definition: TDirectory.h:45
virtual TList * GetList() const
Definition: TDirectory.h:222
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
Definition: TDirectory.cxx:197
virtual TObject * Remove(TObject *)
Remove an object from the in-memory list.
TGraph with asymmetric error bars.
A TGraph is an object made of two arrays X and Y with npoints each.
Definition: TGraph.h:41
static TClass * Class()
@ kIsSortedX
Graph is sorted in X points.
Definition: TGraph.h:77
TH1F * GetHistogram() const
Returns a pointer to the histogram used to draw the axis Takes into account the two following cases.
Definition: TGraph.cxx:1401
1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:620
1-D histogram with a float per channel (see TH1 documentation)}
Definition: TH1.h:577
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
virtual void SetLabelFont(Style_t font=62, Option_t *axis="X")
Set font number used to draw axis labels.
Definition: Haxis.cxx:249
virtual void SetDirectory(TDirectory *dir)
By default, when a histogram is created, it is added to the list of histogram objects in the current ...
Definition: TH1.cxx:8803
virtual void SetBarOffset(Float_t offset=0.25)
Set the bar offset as fraction of the bin width for drawing mode "B".
Definition: TH1.h:361
virtual void SetTitleSize(Float_t size=0.02, Option_t *axis="X")
Set the axis' title size.
Definition: Haxis.cxx:365
virtual void SetLabelOffset(Float_t offset=0.005, Option_t *axis="X")
Set offset between axis and axis' labels.
Definition: Haxis.cxx:267
void SetTitle(const char *title) override
Change (i.e.
Definition: TH1.cxx:6700
virtual void SetXTitle(const char *title)
Definition: TH1.h:415
virtual Int_t GetDimension() const
Definition: TH1.h:281
static void AddDirectory(Bool_t add=kTRUE)
Sets the flag controlling the automatic add of histograms in memory.
Definition: TH1.cxx:1267
virtual void SetContourLevel(Int_t level, Double_t value)
Set value for one contour level.
Definition: TH1.cxx:8388
TAxis * GetXaxis()
Definition: TH1.h:322
virtual void SetNdivisions(Int_t n=510, Option_t *axis="X")
Set the number of divisions to draw an axis.
Definition: Haxis.cxx:170
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:8411
virtual Int_t GetNbinsX() const
Definition: TH1.h:295
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:400
TAxis * GetYaxis()
Definition: TH1.h:323
void Draw(Option_t *option="") override
Draw this histogram with options.
Definition: TH1.cxx:3060
virtual Int_t GetNdivisions(Option_t *axis="X") const
Return the number of divisions for "axis".
Definition: Haxis.cxx:27
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:401
virtual void SetBinContent(Int_t bin, Double_t content)
Set bin content see convention for numbering bins in TH1::GetBin In case the bin number is greater th...
Definition: TH1.cxx:9088
virtual Double_t GetEntries() const
Return the current number of entries.
Definition: TH1.cxx:4419
virtual void SetZTitle(const char *title)
Definition: TH1.h:417
virtual TArrayD * GetSumw2()
Definition: TH1.h:311
virtual void SetTitleOffset(Float_t offset=1, Option_t *axis="X")
Specify a parameter offset to control the distance between the axis and the axis' title.
Definition: Haxis.cxx:345
virtual void SetLabelColor(Color_t color=1, Option_t *axis="X")
Set axis labels color.
Definition: Haxis.cxx:226
virtual void SetAxisColor(Color_t color=1, Option_t *axis="X")
Set color to draw the axis line and tick marks.
Definition: Haxis.cxx:187
virtual void SetOption(Option_t *option=" ")
Definition: TH1.h:408
virtual void SetContour(Int_t nlevels, const Double_t *levels=nullptr)
Set the number and values of contour levels.
Definition: TH1.cxx:8349
virtual void SetAxisRange(Double_t xmin, Double_t xmax, Option_t *axis="X")
Set the "axis" range.
Definition: Haxis.cxx:201
virtual void SetYTitle(const char *title)
Definition: TH1.h:416
virtual void SetTitleFont(Style_t font=62, Option_t *axis="X")
Set the axis' title font.
Definition: Haxis.cxx:323
virtual Double_t GetMinimum(Double_t minval=-FLT_MAX) const
Return minimum value larger than minval of bins in the range, unless the value has been overridden by...
Definition: TH1.cxx:8501
virtual void SetLabelSize(Float_t size=0.02, Option_t *axis="X")
Set size of axis' labels.
Definition: Haxis.cxx:285
virtual void Sumw2(Bool_t flag=kTRUE)
Create structure to store sum of squares of weights.
Definition: TH1.cxx:8886
static Bool_t AddDirectoryStatus()
Static function: cannot be inlined on Windows/NT.
Definition: TH1.cxx:735
virtual void SetBarWidth(Float_t width=0.5)
Set the width of bars as fraction of the bin width for drawing mode "B".
Definition: TH1.h:362
virtual void SetStats(Bool_t stats=kTRUE)
Set statistics option on/off.
Definition: TH1.cxx:8856
virtual void SetTickLength(Float_t length=0.02, Option_t *axis="X")
Set the axis' tick marks length.
Definition: Haxis.cxx:302
A doubly linked list.
Definition: TList.h:38
void Streamer(TBuffer &) override
Stream all objects in the collection to or from the I/O buffer.
Definition: TList.cxx:1191
void RecursiveRemove(TObject *obj) override
Remove object from this collection and recursively remove the object from all other objects (and coll...
Definition: TList.cxx:764
void Add(TObject *obj) override
Definition: TList.h:81
TObject * Remove(TObject *obj) override
Remove object from the list.
Definition: TList.cxx:822
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
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 fName
Definition: TNamed.h:32
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:140
virtual void SetNameTitle(const char *name, const char *title)
Set all the TNamed parameters (name and title).
Definition: TNamed.cxx:154
Mother of all ROOT objects.
Definition: TObject.h:41
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:439
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:207
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:525
virtual void SetDrawOption(Option_t *option="")
Set drawing option for object.
Definition: TObject.cxx:758
virtual TClass * IsA() const
Definition: TObject.h:245
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
Definition: TObject.cxx:274
Basic string class.
Definition: TString.h:136
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1171
const char * Data() const
Definition: TString.h:369
void ToUpper()
Change string to upper case.
Definition: TString.cxx:1184
TString & Append(const char *cs)
Definition: TString.h:565
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition: TString.cxx:2357
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:625
RVec< PromoteType< T > > abs(const RVec< T > &v)
Definition: RVec.hxx:1778
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
leg
Definition: legend1.C:34
@ InputArguments
Definition: RooGlobalFunc.h:63
static constexpr double s
Definition: first.py:1
Definition: graph.py:1