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(0 == _normVars) _normVars= (RooArgSet*) vars.snapshot(true);
371}
372
373
374////////////////////////////////////////////////////////////////////////////////
375/// A plot object is a frame without any bin contents of its own so this
376/// method always returns zero.
377
379 return 0;
380}
381
382
383////////////////////////////////////////////////////////////////////////////////
384/// A plot object is a frame without any bin contents of its own so this
385/// method always returns zero.
386
388{
389 return 0;
390}
391
392
393////////////////////////////////////////////////////////////////////////////////
394/// A plot object is a frame without any bin contents of its own so this
395/// method always returns zero.
396
398{
399 return 0;
400}
401
402
403
404////////////////////////////////////////////////////////////////////////////////
405/// Add a generic object to this plot. The specified options will be
406/// used to Draw() this object later. The caller transfers ownership
407/// of the object with this call, and the object will be deleted
408/// when its containing plot object is destroyed.
409
410void RooPlot::addObject(TObject *obj, Option_t *drawOptions, bool invisible)
411{
412 if(0 == obj) {
413 coutE(InputArguments) << fName << "::addObject: called with a null pointer" << endl;
414 return;
415 }
416 DrawOpt opt(drawOptions) ;
417 opt.invisible = invisible ;
418 _items.emplace_back(obj,opt.rawOpt());
419}
420
421
422////////////////////////////////////////////////////////////////////////////////
423/// Add a TH1 histogram object to this plot. The specified options
424/// will be used to Draw() this object later. "SAME" will be added to
425/// the options if they are not already present. The caller transfers
426/// ownership of the object with this call, and the object will be
427/// deleted when its containing plot object is destroyed.
428
429void RooPlot::addTH1(TH1 *hist, Option_t *drawOptions, bool invisible)
430{
431 if(0 == hist) {
432 coutE(InputArguments) << fName << "::addTH1: called with a null pointer" << endl;
433 return;
434 }
435 // check that this histogram is really 1D
436 if(1 != hist->GetDimension()) {
437 coutE(InputArguments) << fName << "::addTH1: cannot plot histogram with "
438 << hist->GetDimension() << " dimensions" << endl;
439 return;
440 }
441
442 // add option "SAME" if necessary
443 TString options(drawOptions);
444 options.ToUpper();
445 if(!options.Contains("SAME")) options.Append("SAME");
446
447 // update our y-axis label and limits
448 updateYAxis(hist->GetMinimum(),hist->GetMaximum(),hist->GetYaxis()->GetTitle());
449
450 // use this histogram's normalization if necessary
451 updateFitRangeNorm(hist);
452
453 // add the histogram to our list
454 addObject(hist,options.Data(),invisible);
455}
456
457
458namespace {
459 // this helper function is intended to translate a graph from a regular axis to a labelled axis
460 // this version uses TGraph, which is a parent of RooCurve
461 void translateGraph(TH1* hist, RooAbsRealLValue* xvar, TGraph* graph){
462 // if the graph already has a labelled axis, don't do anything
463 if(graph->GetXaxis()->IsAlphanumeric()) return;
464 double xmin = hist->GetXaxis()->GetXmin();
465 double xmax = hist->GetXaxis()->GetXmax();
466 if(graph->TestBit(TGraph::kIsSortedX)){
467 // sorted graphs are "line graphs"
468 // evaluate the graph at the lower and upper edge as well as the center of each bin
469 std::vector<double> x;
470 std::vector<double> y;
471 x.push_back(xmin);
472 y.push_back(graph->Eval(xvar->getBinning().binLow(0)));
473 for(int i=0; i<hist->GetNbinsX(); ++i){
474 x.push_back(hist->GetXaxis()->GetBinUpEdge(i+1));
475 y.push_back(graph->Eval(xvar->getBinning().binHigh(i)));
476 x.push_back(hist->GetXaxis()->GetBinCenter(i+1));
477 y.push_back(graph->Eval(xvar->getBinning().binCenter(i)));
478 }
479 int n = x.size();
480 graph->Set(n);
481 for(int i=0; i<n; ++i){
482 graph->SetPoint(i,x[i],y[i]);
483 }
484 graph->Sort();
485 } else {
486 // unsorted graphs are "area graphs"
487 std::map<int,double> minValues;
488 std::map<int,double> maxValues;
489 int n = graph->GetN();
490 double x, y;
491 // for each bin, find the min and max points to form an envelope
492 for(int i=0; i<n; ++i){
493 graph->GetPoint(i,x,y);
494 int bin = xvar->getBinning().binNumber(x)+1;
495 if(maxValues.find(bin)!=maxValues.end()){
496 maxValues[bin] = std::max(maxValues[bin],y);
497 } else {
498 maxValues[bin] = y;
499 }
500 if(minValues.find(bin)!=minValues.end()){
501 minValues[bin] = std::min(minValues[bin],y);
502 } else {
503 minValues[bin] = y;
504 }
505 }
506 double xminY = graph->Eval(xmin);
507 double xmaxY = graph->Eval(xmax);
508 graph->Set(hist->GetNbinsX()+2);
509 int np=0;
510 graph->SetPoint(np,xmin,xminY);
511 // assign the calculated envelope boundaries to the bin centers of the bins
512 for(auto it = maxValues.begin(); it != maxValues.end(); ++it){
513 graph->SetPoint(++np,hist->GetXaxis()->GetBinCenter(it->first),it->second);
514 }
515 graph->SetPoint(++np,xmax,xmaxY);
516 for(auto it = minValues.rbegin(); it != minValues.rend(); ++it){
517 graph->SetPoint(++np,hist->GetXaxis()->GetBinCenter(it->first),it->second);
518 }
519 graph->SetPoint(++np,xmin,xminY);
520 }
521 // make sure that the graph also has the labels set, such that subsequent calls to translate this graph will not do anything
522 graph->GetXaxis()->Set(hist->GetNbinsX(),xmin,xmax);
523 for(int i=0; i<hist->GetNbinsX(); ++i){
524 graph->GetXaxis()->SetBinLabel(i+1,hist->GetXaxis()->GetBinLabel(i+1));
525 }
526 }
527 // this version uses TGraphErrors, which is a parent of RooHist
528 void translateGraph(TH1* hist, RooAbsRealLValue* xvar, TGraphAsymmErrors* graph){
529 // if the graph already has a labelled axis, don't do anything
530 if(graph->GetXaxis()->IsAlphanumeric()) return;
531 int n = graph->GetN();
532 double xmin = hist->GetXaxis()->GetXmin();
533 double xmax = hist->GetXaxis()->GetXmax();
534 double x, y;
535 // as this graph is histogram-like, we expect there to be one point per bin
536 // we just move these points to the respective bin centers
537 for(int i=0; i<n; ++i){
538 if(graph->GetPoint(i,x,y)!=i) break;
539 int bin = xvar->getBinning().binNumber(x);
540 graph->SetPoint(i,hist->GetXaxis()->GetBinCenter(bin+1),y);
541 graph->SetPointEXhigh(i,0.5*hist->GetXaxis()->GetBinWidth(bin+1));
542 graph->SetPointEXlow(i,0.5*hist->GetXaxis()->GetBinWidth(bin+1));
543 }
544 graph->GetXaxis()->Set(hist->GetNbinsX(),xmin,xmax);
545 // make sure that the graph also has the labels set, such that subsequent calls to translate this graph will not do anything
546 for(int i=0; i<hist->GetNbinsX(); ++i){
547 graph->GetXaxis()->SetBinLabel(i+1,hist->GetXaxis()->GetBinLabel(i+1));
548 }
549 }
550}
551
552////////////////////////////////////////////////////////////////////////////////
553/// Add the specified plotable object to our plot. Increase our y-axis
554/// limits to fit this object if necessary. The default lower-limit
555/// is zero unless we are plotting an object that takes on negative values.
556/// This call transfers ownership of the plotable object to this class.
557/// The plotable object will be deleted when this plot object is deleted.
558void RooPlot::addPlotable(RooPlotable *plotable, Option_t *drawOptions, bool invisible, bool refreshNorm)
559{
560 // update our y-axis label and limits
561 updateYAxis(plotable->getYAxisMin(),plotable->getYAxisMax(),plotable->getYAxisLabel());
562
563 // use this object's normalization if necessary
564 updateFitRangeNorm(plotable,refreshNorm) ;
565
566 // add this element to our list and remember its drawing option
567 TObject *obj= plotable->crossCast();
568 if(0 == obj) {
569 coutE(InputArguments) << fName << "::add: cross-cast to TObject failed (nothing added)" << endl;
570 }
571 else {
572 // if the frame axis is alphanumeric, the coordinates of the graph need to be translated to this binning
573 if(_hist->GetXaxis()->IsAlphanumeric()){
574 if(obj->InheritsFrom(RooCurve::Class())){
575 ::translateGraph(_hist,_plotVar,static_cast<RooCurve*>(obj));
576 } else if(obj->InheritsFrom(RooHist::Class())){
577 ::translateGraph(_hist,_plotVar,static_cast<RooHist*>(obj));
578 }
579 }
580
581 DrawOpt opt(drawOptions) ;
582 opt.invisible = invisible ;
583 _items.emplace_back(obj,opt.rawOpt());
584 }
585}
586
587
588////////////////////////////////////////////////////////////////////////////////
589/// Update our plot normalization over our plot variable's fit range,
590/// which will be determined by the first suitable object added to our plot.
591
593{
594 const TAxis* xa = ((TH1*)hist)->GetXaxis() ;
595 _normBinWidth = (xa->GetXmax()-xa->GetXmin())/hist->GetNbinsX() ;
597}
598
599
600////////////////////////////////////////////////////////////////////////////////
601/// Update our plot normalization over our plot variable's fit range,
602/// which will be determined by the first suitable object added to our plot.
603
604void RooPlot::updateFitRangeNorm(const RooPlotable* rp, bool refreshNorm)
605{
606 if (_normNumEvts != 0) {
607
608 // If refresh feature is disabled stop here
609 if (!refreshNorm) return ;
610
611 double corFac(1.0) ;
612 if (dynamic_cast<const RooHist*>(rp)) corFac = _normBinWidth/rp->getFitRangeBinW() ;
613
614
615 if (fabs(rp->getFitRangeNEvt()/corFac-_normNumEvts)>1e-6) {
616 coutI(Plotting) << "RooPlot::updateFitRangeNorm: New event count of " << rp->getFitRangeNEvt()/corFac
617 << " will supercede previous event count of " << _normNumEvts << " for normalization of PDF projections" << endl ;
618 }
619
620 // Nominal bin width (i.e event density) is already locked in by previously drawn histogram
621 // scale this histogram to match that density
622 _normNumEvts = rp->getFitRangeNEvt()/corFac ;
623 _normObj = rp ;
624 // cout << "correction factor = " << _normBinWidth << "/" << rp->getFitRangeBinW() << endl ;
625 // cout << "updating numevts to " << _normNumEvts << endl ;
626
627 } else {
628
629 _normObj = rp ;
631 if (rp->getFitRangeBinW()) {
633 }
634
635 // cout << "updating numevts to " << _normNumEvts << endl ;
636 }
637
638}
639
640
641
642////////////////////////////////////////////////////////////////////////////////
643/// Update our y-axis limits to accomodate an object whose spread
644/// in y is (ymin,ymax). Use the specified y-axis label if we don't
645/// have one assigned already.
646
647void RooPlot::updateYAxis(double ymin, double ymax, const char *label)
648{
649 // force an implicit lower limit of zero if appropriate
650 if(GetMinimum() == 0 && ymin > 0) ymin= 0;
651
652 // calculate padded values
653 double ypad= getPadFactor()*(ymax-ymin);
654 ymax+= ypad;
655 if(ymin < 0) ymin-= ypad;
656
657 // update our limits if necessary
658 if(GetMaximum() < ymax) {
659 _defYmax = ymax ;
661 // if we don't do this - Unzoom on y-axis will reset upper bound to 1
663 }
664 if(GetMinimum() > ymin) {
665 _defYmin = ymin ;
667 }
668
669 // use the specified y-axis label if we don't have one already
670 if(0 == strlen(_hist->GetYaxis()->GetTitle())) _hist->SetYTitle(label);
671}
672
673
674////////////////////////////////////////////////////////////////////////////////
675/// Draw this plot and all of the elements it contains. The specified options
676/// only apply to the drawing of our frame. The options specified in our add...()
677/// methods will be used to draw each object we contain.
678
680{
681 TString optArg = option ;
682 optArg.ToLower() ;
683
684 // This draw options prevents the histogram with one dummy entry
685 // to be drawn
686 if (optArg.Contains("same")) {
687 _hist->Draw("FUNCSAME");
688 } else {
689 _hist->Draw("FUNC");
690 }
691
692 for(auto const& item : _items) {
693 TObject &obj = *item.first;
694 DrawOpt opt(item.second.c_str()) ;
695 if (!opt.invisible) {
696 //LM: in case of a TGraph derived object, do not use default "" option
697 // which is "ALP" from 5.34.10 (and will then redrawn the axis) but use "LP"
698 if (!strlen(opt.drawOptions) && obj.IsA()->InheritsFrom(TGraph::Class()) ) strlcpy(opt.drawOptions,"LP",3);
699 obj.Draw(opt.drawOptions);
700 }
701 }
702
703 _hist->Draw("AXISSAME");
704}
705
706
707
708////////////////////////////////////////////////////////////////////////////////
709/// Print frame name
710
711void RooPlot::printName(ostream& os) const
712{
713 os << GetName() ;
714}
715
716
717////////////////////////////////////////////////////////////////////////////////
718/// Print frame title
719
720void RooPlot::printTitle(ostream& os) const
721{
722 os << GetTitle() ;
723}
724
725
726////////////////////////////////////////////////////////////////////////////////
727/// Print frame class name
728
729void RooPlot::printClassName(ostream& os) const
730{
731 os << ClassName() ;
732}
733
734
735
736////////////////////////////////////////////////////////////////////////////////
737
738void RooPlot::printArgs(ostream& os) const
739{
740 if (_plotVar) {
741 os << "[" ;
743 os << "]" ;
744 }
745}
746
747
748
749////////////////////////////////////////////////////////////////////////////////
750/// Print frame arguments
751
752void RooPlot::printValue(ostream& os) const
753{
754 os << "(" ;
755 bool first(true) ;
756 for(auto const& item : _items) {
757 TObject &obj = *item.first;
758 if (first) {
759 first=false ;
760 } else {
761 os << "," ;
762 }
763 if(obj.IsA()->InheritsFrom(RooPrintable::Class())) {
764 auto po = dynamic_cast<RooPrintable&>(obj) ;
765 // coverity[FORWARD_NULL]
767 }
768 // is it a TNamed subclass?
769 else {
770 os << obj.ClassName() << "::" << obj.GetName() ;
771 }
772 }
773 os << ")" ;
774}
775
776
777////////////////////////////////////////////////////////////////////////////////
778/// Frame detailed printing
779
780void RooPlot::printMultiline(ostream& os, Int_t /*content*/, bool verbose, TString indent) const
781{
782 TString deeper(indent);
783 deeper.Append(" ");
784 if(0 != _plotVar) {
785 os << indent << "RooPlot " << GetName() << " (" << GetTitle() << ") plots variable ";
787 }
788 else {
789 os << indent << "RooPlot " << GetName() << " (" << GetTitle() << ") has no associated plot variable" << endl ;
790 }
791 os << indent << " Plot frame contains " << _items.size() << " object(s):" << endl;
792
793 if(verbose) {
794 Int_t i=0 ;
795 for(auto const& item : _items) {
796 TObject &obj = *item.first;
797 os << deeper << "[" << i++ << "] (Options=\"" << item.second << "\") ";
798 // Is this a printable object?
799 if(obj.IsA()->InheritsFrom(RooPrintable::Class())) {
800 auto po = dynamic_cast<RooPrintable&>(obj) ;
802 }
803 // is it a TNamed subclass?
804 else {
805 os << obj.ClassName() << "::" << obj.GetName() << endl;
806 }
807 }
808 }
809}
810
811
812
813////////////////////////////////////////////////////////////////////////////////
814/// Return the name of the object at slot 'idx' in this RooPlot.
815/// If the given index is out of range, return a null pointer
816
817const char* RooPlot::nameOf(Int_t idx) const
818{
819 TObject* obj = _items.at(idx).first;
820 if (!obj) {
821 coutE(InputArguments) << "RooPlot::nameOf(" << GetName() << ") index " << idx << " out of range" << endl ;
822 return 0 ;
823 }
824 return obj->GetName() ;
825}
826
827
828
829////////////////////////////////////////////////////////////////////////////////
830/// Return the name of the object at slot 'idx' in this RooPlot.
831/// If the given index is out of range, return a null pointer
832
834{
835 TObject* obj = _items.at(idx).first;
836 if (!obj) {
837 coutE(InputArguments) << "RooPlot::getObject(" << GetName() << ") index " << idx << " out of range" << endl ;
838 return 0 ;
839 }
840 return obj ;
841}
842
843
844
845////////////////////////////////////////////////////////////////////////////////
846/// Return a pointer to the line attributes of the named object in this plot,
847/// or zero if the named object does not exist or does not have line attributes.
848
850{
851 return dynamic_cast<TAttLine*>(findObject(name));
852}
853
854
855////////////////////////////////////////////////////////////////////////////////
856/// Return a pointer to the fill attributes of the named object in this plot,
857/// or zero if the named object does not exist or does not have fill attributes.
858
860{
861 return dynamic_cast<TAttFill*>(findObject(name));
862}
863
864
865////////////////////////////////////////////////////////////////////////////////
866/// Return a pointer to the marker attributes of the named object in this plot,
867/// or zero if the named object does not exist or does not have marker attributes.
868
870{
871 return dynamic_cast<TAttMarker*>(findObject(name));
872}
873
874
875////////////////////////////////////////////////////////////////////////////////
876/// Return a pointer to the text attributes of the named object in this plot,
877/// or zero if the named object does not exist or does not have text attributes.
878
880{
881 return dynamic_cast<TAttText*>(findObject(name));
882}
883
884
885
886////////////////////////////////////////////////////////////////////////////////
887/// Return a RooCurve pointer of the named object in this plot,
888/// or zero if the named object does not exist or is not a RooCurve
889
890RooCurve* RooPlot::getCurve(const char* name) const
891{
892 return dynamic_cast<RooCurve*>(findObject(name)) ;
893}
894
895
896////////////////////////////////////////////////////////////////////////////////
897/// Return a RooCurve pointer of the named object in this plot,
898/// or zero if the named object does not exist or is not a RooCurve
899
900RooHist* RooPlot::getHist(const char* name) const
901{
902 return dynamic_cast<RooHist*>(findObject(name)) ;
903}
904
905
906
907////////////////////////////////////////////////////////////////////////////////
908/// Remove object with given name, or last object added if no name is given.
909
910void RooPlot::remove(const char* name, bool deleteToo)
911{
912 if(name == nullptr) {
913 if(!_items.empty()) {
914 if(deleteToo) delete _items.back().first;
915 _items.pop_back();
916 } else {
917 coutE(InputArguments) << "RooPlot::remove(" << GetName() << ") ERROR: plot frame is empty, cannot remove last object" << endl ;
918 }
919 } else {
920 auto item = findItem(name);
921 if(item == _items.end()) {
922 coutE(InputArguments) << "RooPlot::remove(" << GetName() << ") ERROR: no object found with name " << name << endl ;
923 } else {
924 if(deleteToo) delete item->first;
925 _items.erase(item);
926 }
927 }
928}
929
930
931namespace {
932
933template<class Iter>
934void moveBefore(Iter before, Iter target) {
935 auto d = std::distance(before, target);
936 if(d > 0) std::rotate(before, target, target + 1);
937 else if(d < 0) std::rotate(target, target+1, before);
938}
939
940} // namespace
941
942
943////////////////////////////////////////////////////////////////////////////////
944/// Change the order in which our contained objects are drawn so that
945/// the target object is drawn just before the specified object.
946/// Returns false if either object does not exist.
947
948bool RooPlot::drawBefore(const char *before, const char *target)
949{
950 auto iterBefore = findItem(before);
951 auto iterTarget = findItem(target);
952 if(iterBefore == _items.end() || iterTarget == _items.end()) return false;
953 moveBefore(iterBefore, iterTarget);
954 return true;
955}
956
957
958////////////////////////////////////////////////////////////////////////////////
959/// Change the order in which our contained objects are drawn so that
960/// the target object is drawn just after the specified object.
961/// Returns false if either object does not exist.
962
963bool RooPlot::drawAfter(const char *after, const char *target)
964{
965 auto iterAfter = findItem(after);
966 auto iterTarget = findItem(target);
967 if(iterAfter == _items.end() || iterTarget == _items.end()) return false;
968 moveBefore(iterAfter + 1, iterTarget);
969 return true;
970}
971
972
973////////////////////////////////////////////////////////////////////////////////
974/// Find the named object in our list of items and return a pointer
975/// to it. Return zero and print a warning message if the named
976/// object cannot be found. If no name is supplied the last object
977/// added is returned.
978///
979/// Note that the returned pointer is to a
980/// TObject and so will generally need casting. Use the getAtt...()
981/// methods to change the drawing style attributes of a contained
982/// object directly.
983
984TObject *RooPlot::findObject(const char *name, const TClass* clas) const
985{
986 TObject *ret = nullptr;
987
988 for(auto const& item : _items) {
989 TObject &obj = *item.first;
990 if ((!name || name[0] == '\0' || !TString(name).CompareTo(obj.GetName()))
991 && (!clas || (obj.IsA()==clas))) {
992 ret = &obj ;
993 }
994 }
995
996 if (ret == nullptr) {
997 coutE(InputArguments) << "RooPlot::findObject(" << GetName() << ") cannot find object " << (name?name:"<last>") << endl ;
998 }
999 return ret ;
1000}
1001
1002
1003RooPlot::Items::iterator RooPlot::findItem(std::string const& name)
1004{
1005 return std::find_if(_items.begin(), _items.end(), [&name](auto const& item){
1006 return name == item.first->GetName();
1007 });
1008}
1009
1010RooPlot::Items::const_iterator RooPlot::findItem(std::string const& name) const
1011{
1012 return std::find_if(_items.begin(), _items.end(), [&name](auto const& item){
1013 return name == item.first->GetName();
1014 });
1015}
1016
1017
1018////////////////////////////////////////////////////////////////////////////////
1019/// Return the Draw() options registered for the named object. Return
1020/// an empty string if the named object cannot be found.
1021
1023{
1024 auto item = findItem(name);
1025 if(item == _items.end()) return "";
1026
1027 return DrawOpt{item->second.c_str()}.drawOptions;
1028}
1029
1030
1031////////////////////////////////////////////////////////////////////////////////
1032/// Register the specified drawing options for the named object.
1033/// Return false if the named object cannot be found.
1034
1035bool RooPlot::setDrawOptions(const char *name, TString options)
1036{
1037 auto item = findItem(name);
1038 if(item == _items.end()) return false;
1039
1040 DrawOpt opt(item->second.c_str()) ;
1041 strlcpy(opt.drawOptions,options,128) ;
1042 item->second = opt.rawOpt();
1043 return true;
1044}
1045
1046
1047////////////////////////////////////////////////////////////////////////////////
1048/// Returns true of object with given name is set to be invisible
1049
1050bool RooPlot::getInvisible(const char* name) const
1051{
1052 auto item = findItem(name);
1053 if(item == _items.end()) return false;
1054
1055 return DrawOpt{item->second.c_str()}.invisible ;
1056}
1057
1058
1059////////////////////////////////////////////////////////////////////////////////
1060/// If flag is true object with 'name' is set to be invisible
1061/// i.e. it is not drawn when Draw() is called
1062
1063void RooPlot::setInvisible(const char* name, bool flag)
1064{
1065 auto item = findItem(name);
1066 if(item != _items.end()) {
1067 DrawOpt opt;
1068 opt.initialize(item->second.c_str());
1069 opt.invisible = flag;
1070 item->second = opt.rawOpt();
1071 }
1072
1073}
1074
1075
1076////////////////////////////////////////////////////////////////////////////////
1077/// Set maximum value of Y axis
1078
1079void RooPlot::SetMaximum(double maximum)
1080{
1081 _hist->SetMaximum(maximum==-1111?_defYmax:maximum) ;
1082}
1083
1084
1085
1086////////////////////////////////////////////////////////////////////////////////
1087/// Set minimum value of Y axis
1088
1089void RooPlot::SetMinimum(double minimum)
1090{
1091 _hist->SetMinimum(minimum==-1111?_defYmin:minimum) ;
1092}
1093
1094
1095
1096////////////////////////////////////////////////////////////////////////////////
1097/// Calculate and return reduced chi-squared between a curve and a histogram.
1098///
1099/// \param[in] curvename Name of the curve or nullptr for last curve
1100/// \param[in] histname Name of the histogram to compare to or nullptr for last added histogram
1101/// \param[in] nFitParam If non-zero, reduce the number of degrees of freedom by this
1102/// number. This means that the curve was fitted to the data with nFitParam floating
1103/// parameters, which needs to be reflected in the calculation of \f$\chi^2 / \mathrm{ndf}\f$.
1104///
1105/// \return \f$ \chi^2 / \mathrm{ndf} \f$ between the plotted curve and the data.
1106///
1107/// \note The \f$ \chi^2 \f$ is calculated between a *plot of the original distribution* and the data.
1108/// It therefore has more rounding errors than directly calculating the \f$ \chi^2 \f$ from a PDF or
1109/// function. To do this, use RooChi2Var.
1110double RooPlot::chiSquare(const char* curvename, const char* histname, int nFitParam) const
1111{
1112
1113 // Find curve object
1114 RooCurve* curve = (RooCurve*) findObject(curvename,RooCurve::Class()) ;
1115 if (!curve) {
1116 coutE(InputArguments) << "RooPlot::chiSquare(" << GetName() << ") cannot find curve" << endl ;
1117 return -1. ;
1118 }
1119
1120 // Find histogram object
1121 RooHist* hist = (RooHist*) findObject(histname,RooHist::Class()) ;
1122 if (!hist) {
1123 coutE(InputArguments) << "RooPlot::chiSquare(" << GetName() << ") cannot find histogram" << endl ;
1124 return -1. ;
1125 }
1126
1127 return curve->chiSquare(*hist,nFitParam) ;
1128}
1129
1130
1131////////////////////////////////////////////////////////////////////////////////
1132/// Return a RooHist (derives from TGraphAsymErrors) containing the residuals of a histogram.
1133/// The plotting range of the graph is adapted to the plotting range of the current plot.
1134///
1135/// \param histname Name of the data histogram.
1136/// Passing an empty string or `nullptr` will create residuals of the last-plotted histogram.
1137/// \param curvename Name of the curve to compare to data.
1138/// Passing an empty string or `nullptr` will create residuals of the last-plotted curve.
1139/// \param normalize If true, the residuals are divided by the error
1140/// of the histogram, effectively returning a pull histogram.
1141/// \param useAverage If true, the histogram is compared with the curve averaged in each bin.
1142/// Otherwise, the curve is evaluated at the bin centres, which is not accurate for strongly curved distributions.
1143RooHist* RooPlot::residHist(const char* histname, const char* curvename, bool normalize, bool useAverage) const
1144{
1145 // Find curve objects (there might be multiple in the case of multi-range fits)
1146 std::vector<RooCurve *> curves;
1147
1148 for(auto const& item : _items) {
1149 TObject &obj = *item.first;
1150 if(obj.IsA() == RooCurve::Class()) {
1151 // If no curvename was passed, we take by default the last curve and all
1152 // other curves that have the same name
1153 if((!curvename || curvename[0] == '\0') || std::string(curvename) == obj.GetName()) {
1154 curvename = obj.GetName();
1155 curves.push_back(static_cast<RooCurve*>(&obj));
1156 }
1157 }
1158 }
1159
1160 if (curves.empty()) {
1161 coutE(InputArguments) << "RooPlot::residHist(" << GetName() << ") cannot find curve" << std::endl;
1162 return nullptr;
1163 }
1164
1165 // Find histogram object
1166 auto hist = static_cast<RooHist*>(findObject(histname,RooHist::Class()));
1167 if (!hist) {
1168 coutE(InputArguments) << "RooPlot::residHist(" << GetName() << ") cannot find histogram" << std::endl;
1169 return nullptr;
1170 }
1171
1172 auto residHist = hist->createEmptyResidHist(*curves.front(), normalize);
1173 for(RooCurve * curve : curves) {
1174 hist->fillResidHist(*residHist, *curve, normalize, useAverage);
1175 }
1178 residHist->GetHistogram()->GetYaxis()->SetTitle(normalize ? "(Data - curve) / #sigma_{data}" : "Data - curve");
1179 return residHist.release();
1180}
1181
1182
1183
1184////////////////////////////////////////////////////////////////////////////////
1185/// Initialize the DrawOpt helper class
1186
1187void RooPlot::DrawOpt::initialize(const char* inRawOpt)
1188{
1189 if (!inRawOpt) {
1190 drawOptions[0] = 0 ;
1191 invisible=false ;
1192 return ;
1193 }
1194 strlcpy(drawOptions,inRawOpt,128) ;
1195 strtok(drawOptions,":") ;
1196 const char* extraOpt = strtok(0,":") ;
1197 if (extraOpt) {
1198 invisible = (extraOpt[0]=='I') ;
1199 }
1200}
1201
1202
1203////////////////////////////////////////////////////////////////////////////////
1204/// Return the raw draw options
1205
1206const char* RooPlot::DrawOpt::rawOpt() const
1207{
1208 static char buf[128] ;
1209 strlcpy(buf,drawOptions,128) ;
1210 if (invisible) {
1211 strlcat(buf,":I",128) ;
1212 }
1213 return buf ;
1214}
1215
1216
1217
1218////////////////////////////////////////////////////////////////////////////////
1219/// Return the number of events that is associated with the range [xlo,xhi]
1220/// This method is only fully functional for ranges not equal to the full
1221/// range if the object that inserted the normalization data provided
1222/// a link to an external object that can calculate the event count in
1223/// in sub ranges. An error will be printed if this function is used
1224/// on sub-ranges while that information is not available
1225
1226double RooPlot::getFitRangeNEvt(double xlo, double xhi) const
1227{
1228 double scaleFactor = 1.0 ;
1229 if (_normObj) {
1230 scaleFactor = _normObj->getFitRangeNEvt(xlo,xhi)/_normObj->getFitRangeNEvt() ;
1231 } else {
1232 coutW(Plotting) << "RooPlot::getFitRangeNEvt(" << GetName() << ") WARNING: Unable to obtain event count in range "
1233 << xlo << " to " << xhi << ", substituting full event count" << endl ;
1234 }
1235 return getFitRangeNEvt()*scaleFactor ;
1236}
1237
1238
1239////////////////////////////////////////////////////////////////////////////////
1240/// Set the name of the RooPlot to 'name'
1241
1242void RooPlot::SetName(const char *name)
1243{
1244 if (_dir) _dir->GetList()->Remove(this);
1246 if (_dir) _dir->GetList()->Add(this);
1247}
1248
1249
1250////////////////////////////////////////////////////////////////////////////////
1251/// Set the name and title of the RooPlot to 'name' and 'title'
1252
1253void RooPlot::SetNameTitle(const char *name, const char* title)
1254{
1255 if (_dir) _dir->GetList()->Remove(this);
1256 TNamed::SetNameTitle(name,title) ;
1257 if (_dir) _dir->GetList()->Add(this);
1258}
1259
1260
1261////////////////////////////////////////////////////////////////////////////////
1262/// Set the title of the RooPlot to 'title'
1263
1264void RooPlot::SetTitle(const char* title)
1265{
1266 TNamed::SetTitle(title) ;
1267 _hist->SetTitle(title) ;
1268}
1269
1270
1271
1272////////////////////////////////////////////////////////////////////////////////
1273/// Define default print options, for a given print style
1274
1276{
1277 return kName|kArgs|kValue ;
1278}
1279
1280
1281
1282/// \see TH1::GetXaxis()
1283TAxis* RooPlot::GetXaxis() const { return _hist->GetXaxis() ; }
1284/// \see TH1::GetYaxis()
1285TAxis* RooPlot::GetYaxis() const { return _hist->GetYaxis() ; }
1286/// \see TH1::GetNbinsX()
1288/// \see TH1::GetNdivisions()
1290/// \see TH1::GetMinimum()
1291double RooPlot::GetMinimum(double minval) const { return _hist->GetMinimum(minval) ; }
1292/// \see TH1::GetMaximum()
1293double RooPlot::GetMaximum(double maxval) const { return _hist->GetMaximum(maxval) ; }
1294
1295
1296/// \see TH1::SetAxisColor()
1297void RooPlot::SetAxisColor(Color_t color, Option_t* axis) { _hist->SetAxisColor(color,axis) ; }
1298/// \see TH1::SetAxisRange()
1299void RooPlot::SetAxisRange(double xmin, double xmax, Option_t* axis) { _hist->SetAxisRange(xmin,xmax,axis) ; }
1300/// \see TH1::SetBarOffset()
1302/// \see TH1::SetBarWidth()
1304/// \see TH1::SetContour()
1305void RooPlot::SetContour(Int_t nlevels, const double* levels) { _hist->SetContour(nlevels,levels) ; }
1306/// \see TH1::SetContourLevel()
1308/// \see TH1::SetDrawOption()
1310/// \see TH1::SetFillAttributes()
1312/// \see TH1::SetFillColor()
1314/// \see TH1::SetFillStyle()
1316/// \see TH1::SetLabelColor()
1317void RooPlot::SetLabelColor(Color_t color, Option_t* axis) { _hist->SetLabelColor(color,axis) ; }
1318/// \see TH1::SetLabelFont()
1319void RooPlot::SetLabelFont(Style_t font, Option_t* axis) { _hist->SetLabelFont(font,axis) ; }
1320/// \see TH1::SetLabelOffset()
1322/// \see TH1::SetLabelSize()
1324/// \see TH1::SetLineAttributes()
1326/// \see TH1::SetLineColor()
1328/// \see TH1::SetLineStyle()
1330/// \see TH1::SetLineWidth()
1332/// \see TH1::SetMarkerAttributes()
1334/// \see TH1::SetMarkerColor()
1336/// \see TH1::SetMarkerSize()
1338/// \see TH1::SetMarkerStyle()
1340/// \see TH1::SetNdivisions()
1342/// \see TH1::SetOption()
1344/// Like TH1::SetStats(), but statistics boxes are *off* by default in RooFit.
1345void RooPlot::SetStats(bool stats) { _hist->SetStats(stats) ; }
1346/// \see TH1::SetTickLength()
1348/// \see TH1::SetTitleFont()
1349void RooPlot::SetTitleFont(Style_t font, Option_t* axis) { _hist->SetTitleFont(font,axis) ; }
1350/// \see TH1::SetTitleOffset()
1352/// \see TH1::SetTitleSize()
1354/// \see TH1::SetXTitle()
1355void RooPlot::SetXTitle(const char *title) { _hist->SetXTitle(title) ; }
1356/// \see TH1::SetYTitle()
1357void RooPlot::SetYTitle(const char *title) { _hist->SetYTitle(title) ; }
1358/// \see TH1::SetZTitle()
1359void RooPlot::SetZTitle(const char *title) { _hist->SetZTitle(title) ; }
1360
1361
1362
1363
1364////////////////////////////////////////////////////////////////////////////////
1365/// Plot RooPlot when double-clicked in browser
1366
1368{
1369 Draw();
1370 gPad->Update();
1371}
1372
1373
1374
1375
1376////////////////////////////////////////////////////////////////////////////////
1377
1379{
1380 // Custom streamer, needed for backward compatibility
1381
1382 if (R__b.IsReading()) {
1383 const bool oldAddDir = TH1::AddDirectoryStatus();
1384 TH1::AddDirectory(false);
1385
1386 // The default c'tor might have registered this with a TDirectory.
1387 // Streaming the TNamed will make this not retrievable anymore, so
1388 // unregister first.
1389 if (_dir)
1390 _dir->Remove(this);
1391
1392 UInt_t R__s, R__c;
1393 Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
1394 if (R__v > 1) {
1395 R__b.ReadClassBuffer(RooPlot::Class(),this,R__v,R__s,R__c);
1396 } else {
1397 // backward compatible streamer code here
1398 // Version 1 of RooPlot was deriving from TH1 and RooPrintable
1399 // Version 2 derives instead from TNamed and RooPrintable
1400 _hist = new TH1F();
1401 _hist->TH1::Streamer(R__b);
1402 SetName(_hist->GetName());
1405 {
1406 TList itemsList;
1407 itemsList.Streamer(R__b);
1409 }
1410 R__b >> _padFactor;
1411 R__b >> _plotVar;
1412 R__b >> _plotVarSet;
1413 R__b >> _normVars;
1414 R__b >> _normNumEvts;
1415 R__b >> _normBinWidth;
1416 R__b >> _defYmin;
1417 R__b >> _defYmax;
1418 R__b.CheckByteCount(R__s, R__c, RooPlot::IsA());
1419 }
1420
1421 TH1::AddDirectory(oldAddDir);
1422 if (_dir)
1423 _dir->Append(this);
1424
1425 } else {
1426 R__b.WriteClassBuffer(RooPlot::Class(),this);
1427 }
1428}
1429
1430////////////////////////////////////////////////////////////////////////////////
1431/// Build a legend that contains all objects that have been drawn on the plot.
1432std::unique_ptr<TLegend> RooPlot::BuildLegend() const {
1433 auto leg = std::make_unique<TLegend>(0.5, 0.7, 0.9, 0.9);
1434 leg->SetBorderSize(0);
1435 leg->SetFillStyle(0);
1436 for (std::size_t i=0; i < _items.size(); ++i) {
1437 leg->AddEntry(getObject(i));
1438 }
1439
1440 return leg;
1441}
1442
1443/// RooFit-internal function for backwards compatibility.
1445 for(TObject * obj : tlist) {
1446 items.emplace_back(obj, obj->GetOption());
1447 }
1448}
#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:348
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:2452
#define gPad
Definition: TVirtualPad.h:288
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
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 string.
Definition: RooAbsReal.cxx:230
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:221
void initialize(const char *_rawOpt)
Initialize the DrawOpt helper class.
Definition: RooPlot.cxx:1187
const char * rawOpt() const
Return the raw draw options.
Definition: RooPlot.cxx:1206
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:1242
void SetAxisColor(Color_t color=1, Option_t *axis="X")
Definition: RooPlot.cxx:1297
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:910
void SetDrawOption(Option_t *option="") override
Definition: RooPlot.cxx:1309
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:647
Items _items
A list of the items we contain.
Definition: RooPlot.h:236
void SetMarkerSize(Size_t msize=1)
Definition: RooPlot.cxx:1337
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:242
double _normNumEvts
Number of events in histogram (for normalization)
Definition: RooPlot.h:243
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:984
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:948
bool getInvisible(const char *name) const
Returns true of object with given name is set to be invisible.
Definition: RooPlot.cxx:1050
void SetTitle(const char *name) override
Set the title of the RooPlot to 'title'.
Definition: RooPlot.cxx:1264
RooArgSet * _normVars
Variables that PDF plots should be normalized over.
Definition: RooPlot.h:240
void addObject(TObject *obj, Option_t *drawOptions="", bool invisible=false)
Add a generic object to this plot.
Definition: RooPlot.cxx:410
void addTH1(TH1 *hist, Option_t *drawOptions="", bool invisible=false)
Add a TH1 histogram object to this plot.
Definition: RooPlot.cxx:429
double _padFactor
Scale our y-axis to _padFactor of our maximum contents.
Definition: RooPlot.h:237
void SetMarkerColor(Color_t tcolor=1)
Definition: RooPlot.cxx:1335
void printMultiline(std::ostream &os, Int_t content, bool verbose=false, TString indent="") const override
Frame detailed printing.
Definition: RooPlot.cxx:780
void SetXTitle(const char *title)
Definition: RooPlot.cxx:1355
void SetFillColor(Color_t fcolor)
Definition: RooPlot.cxx:1313
RooArgSet * _plotVarSet
A list owning the cloned tree nodes of the plotVarClone.
Definition: RooPlot.h:239
void SetNdivisions(Int_t n=510, Option_t *axis="X")
Definition: RooPlot.cxx:1341
TDirectory * _dir
! non-persistent
Definition: RooPlot.h:249
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:235
void SetMarkerStyle(Style_t mstyle=1)
Definition: RooPlot.cxx:1339
void printName(std::ostream &os) const override
Print frame name.
Definition: RooPlot.cxx:711
TString getDrawOptions(const char *name) const
Return the Draw() options registered for the named object.
Definition: RooPlot.cxx:1022
double _normBinWidth
Histogram bin width (for normalization)
Definition: RooPlot.h:244
void SetZTitle(const char *title)
Definition: RooPlot.cxx:1359
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:1063
void Streamer(TBuffer &) override
Stream an object of class TObject.
Definition: RooPlot.cxx:1378
void SetContour(Int_t nlevels, const double *levels=nullptr)
Definition: RooPlot.cxx:1305
void printClassName(std::ostream &os) const override
Print frame class name.
Definition: RooPlot.cxx:729
bool setDrawOptions(const char *name, TString options)
Register the specified drawing options for the named object.
Definition: RooPlot.cxx:1035
void SetStats(bool stats=true)
Like TH1::SetStats(), but statistics boxes are off by default in RooFit.
Definition: RooPlot.cxx:1345
double getFitRangeNEvt() const
Return the number of events in the fit range.
Definition: RooPlot.h:142
virtual void SetMinimum(double minimum=-1111)
Set minimum value of Y axis.
Definition: RooPlot.cxx:1089
std::vector< std::pair< TObject *, std::string > > Items
Definition: RooPlot.h:45
double GetMaximum(double maxval=FLT_MAX) const
Definition: RooPlot.cxx:1293
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:849
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:963
RooAbsRealLValue * _plotVar
The variable we are plotting.
Definition: RooPlot.h:238
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:1321
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:859
void printTitle(std::ostream &os) const override
Print frame title.
Definition: RooPlot.cxx:720
void SetLineWidth(Width_t lwidth)
Definition: RooPlot.cxx:1331
void SetTickLength(Float_t length=0.02, Option_t *axis="X")
Definition: RooPlot.cxx:1347
virtual Stat_t GetBinContent(Int_t) const
A plot object is a frame without any bin contents of its own so this method always returns zero.
Definition: RooPlot.cxx:378
void SetFillAttributes()
Definition: RooPlot.cxx:1311
void SetContourLevel(Int_t level, double value)
Definition: RooPlot.cxx:1307
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:1323
double chiSquare(int nFitParam=0) const
Shortcut for RooPlot::chiSquare(const char* pdfname, const char* histname, int nFitParam=nullptr)
Definition: RooPlot.h:177
Items::iterator findItem(std::string const &name)
Definition: RooPlot.cxx:1003
void SetOption(Option_t *option=" ")
Definition: RooPlot.cxx:1343
TObject * getObject(Int_t idx) const
Return the name of the object at slot 'idx' in this RooPlot.
Definition: RooPlot.cxx:833
virtual void SetMaximum(double maximum=-1111)
Set maximum value of Y axis.
Definition: RooPlot.cxx:1079
TAxis * GetYaxis() const
Definition: RooPlot.cxx:1285
void Draw(Option_t *options=nullptr) override
Draw this plot and all of the elements it contains.
Definition: RooPlot.cxx:679
void SetLabelFont(Style_t font=62, Option_t *axis="X")
Definition: RooPlot.cxx:1319
void Browse(TBrowser *b) override
Plot RooPlot when double-clicked in browser.
Definition: RooPlot.cxx:1367
double _defYmax
Default maximum for Yaxis (as calculated from contents)
Definition: RooPlot.h:247
void SetLineStyle(Style_t lstyle)
Definition: RooPlot.cxx:1329
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:869
void SetTitleFont(Style_t font=62, Option_t *axis="X")
Definition: RooPlot.cxx:1349
void SetAxisRange(double xmin, double xmax, Option_t *axis="X")
Definition: RooPlot.cxx:1299
TAxis * GetXaxis() const
Definition: RooPlot.cxx:1283
void SetLineColor(Color_t lcolor)
Definition: RooPlot.cxx:1327
void SetFillStyle(Style_t fstyle)
Definition: RooPlot.cxx:1315
const char * nameOf(Int_t idx) const
Return the name of the object at slot 'idx' in this RooPlot.
Definition: RooPlot.cxx:817
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:1143
RooPlot * emptyClone(const char *name)
Return empty clone of current RooPlot.
Definition: RooPlot.cxx:285
void SetMarkerAttributes()
Definition: RooPlot.cxx:1333
void SetNameTitle(const char *name, const char *title) override
Set the name and title of the RooPlot to 'name' and 'title'.
Definition: RooPlot.cxx:1253
void setPadFactor(double factor)
Definition: RooPlot.h:147
Int_t defaultPrintContents(Option_t *opt) const override
Define default print options, for a given print style.
Definition: RooPlot.cxx:1275
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:890
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:879
void SetLabelColor(Color_t color=1, Option_t *axis="X")
Definition: RooPlot.cxx:1317
TClass * IsA() const override
Definition: RooPlot.h:253
Int_t GetNbinsX() const
Definition: RooPlot.cxx:1287
static void fillItemsFromTList(Items &items, TList const &tlist)
RooFit-internal function for backwards compatibility.
Definition: RooPlot.cxx:1444
void SetLineAttributes()
Definition: RooPlot.cxx:1325
static bool _addDirStatus
static flag controlling AutoDirectoryAdd feature
Definition: RooPlot.h:251
void printValue(std::ostream &os) const override
Print frame arguments.
Definition: RooPlot.cxx:752
void SetYTitle(const char *title)
Definition: RooPlot.cxx:1357
double getPadFactor() const
Definition: RooPlot.h:146
void printArgs(std::ostream &os) const override
Interface for printing of object arguments.
Definition: RooPlot.cxx:738
std::unique_ptr< TLegend > BuildLegend() const
Build a legend that contains all objects that have been drawn on the plot.
Definition: RooPlot.cxx:1432
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:900
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:592
void SetTitleSize(Float_t size=0.02, Option_t *axis="X")
Definition: RooPlot.cxx:1353
double _defYmin
Default minimum for Yaxis (as calculated from contents)
Definition: RooPlot.h:246
static TClass * Class()
void SetBarOffset(Float_t offset=0.25)
Definition: RooPlot.cxx:1301
void SetBarWidth(Float_t width=0.5)
Definition: RooPlot.cxx:1303
Int_t GetNdivisions(Option_t *axis="X") const
Definition: RooPlot.cxx:1289
void addPlotable(RooPlotable *plotable, Option_t *drawOptions="", bool invisible=false, bool refreshNorm=false)
Add the specified plotable object to our plot.
Definition: RooPlot.cxx:558
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:1351
double GetMinimum(double minval=-FLT_MAX) const
Definition: RooPlot.cxx:1291
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:253
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:293
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:365
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:41
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:213
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
Definition: TDirectory.cxx:191
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:74
TH1F * GetHistogram() const
Returns a pointer to the histogram used to draw the axis Takes into account the two following cases.
Definition: TGraph.cxx:1402
1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:617
1-D histogram with a float per channel (see TH1 documentation)}
Definition: TH1.h:574
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:8804
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:358
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:412
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:8389
TAxis * GetXaxis()
Definition: TH1.h:319
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:8412
virtual Int_t GetNbinsX() const
Definition: TH1.h:295
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:397
TAxis * GetYaxis()
Definition: TH1.h:320
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:398
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:9089
virtual Double_t GetEntries() const
Return the current number of entries.
Definition: TH1.cxx:4419
virtual void SetZTitle(const char *title)
Definition: TH1.h:414
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:405
virtual void SetContour(Int_t nlevels, const Double_t *levels=nullptr)
Set the number and values of contour levels.
Definition: TH1.cxx:8350
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:413
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:8502
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:8887
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:359
virtual void SetStats(Bool_t stats=kTRUE)
Set statistics option on/off.
Definition: TH1.cxx:8857
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:37
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:363
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:130
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:449
virtual void SetDrawOption(Option_t *option="")
Set drawing option for object.
Definition: TObject.cxx:682
virtual TClass * IsA() const
Definition: TObject.h:230
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
Definition: TObject.cxx:197
Basic string class.
Definition: TString.h:136
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1155
const char * Data() const
Definition: TString.h:369
void ToUpper()
Change string to upper case.
Definition: TString.cxx:1168
TString & Append(const char *cs)
Definition: TString.h:564
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:2341
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
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
VecExpr< UnaryOp< Fabs< T >, VecExpr< A, T, D >, T >, T, D > fabs(const VecExpr< A, T, D > &rhs)
@ InputArguments
Definition: RooGlobalFunc.h:64
static constexpr double s
Definition: first.py:1
Definition: graph.py:1