Logo ROOT  
Reference Guide
ModelInspector.C File Reference

Detailed Description

RooStats Model Inspector

Usage: The usage is the same as the StandardXxxDemo.C macros. The macro expects a root file containing a workspace with a ModelConfig and a dataset

$ root
.L ModelInspector.C+
ModelInspector(fileName, workspaceName, modelConfigName, dataSetName);

Drag the sliders to adjust the parameters of the model. the min and max range of the sliders are used to define the upper & lower variation the pointer position of the slider is the central blue curve.

Click the FIT button to

To Do:

  • check boxes to specify which nuisance parameters used in making variation
  • a button to make the profile inspector plots
  • a check button to use MINOS errors
  • have fit button show the covariance matrix from the fit
  • a button to make the log likelihood plots
  • a dialog to open the desired file
  • ability to see the signal and background contributions?
#include "TGButton.h"
#include "TGLayout.h"
#include "TF1.h"
#include "TMath.h"
#include "TSystem.h"
#include "TCanvas.h"
#include "TGTextEntry.h"
#include "TGLabel.h"
#include "TGTripleSlider.h"
#include "RooWorkspace.h"
#include "TFile.h"
#include "RooArgSet.h"
#include "TList.h"
#include "RooAbsPdf.h"
#include "RooRealVar.h"
#include "RooPlot.h"
#include "TGButton.h"
#include <map>
#include "RooFitResult.h"
#include "TROOT.h"
#include <TApplication.h>
#include "RooCategory.h"
enum ETestCommandIdentifiers {
HId1,
HId2,
HId3,
HCId1,
HCId2,
HSId1
};
using namespace RooFit;
using namespace RooStats;
class ModelInspectorGUI : public TGMainFrame {
private:
TGLayoutHints *fLcan;
TF1 *fFitFcn;
RooPlot *fPlot;
TFile *fFile;
RooAbsData *fData;
RooFitResult *fFitRes;
TList fSliderList;
TList fFrameList;
vector<RooPlot *> fPlotList;
map<TGTripleHSlider *, const char *> fSliderMap;
map<TGTripleHSlider *, TGLabel *> fLabelMap;
TGButton *fFitButton;
TGTextButton *fExitButton;
// BB: a TGCanvas and a vertical frame are needed for using scrollbars
TGCanvas *fCan;
TGVerticalFrame *fVFrame;
TGHorizontalFrame *fHframe0, *fHframe1, *fHframe2;
TGLayoutHints *fBly, *fBfly1, *fBfly2, *fBfly3;
TGTripleHSlider *fHslider1;
TGTextBuffer *fTbh1, *fTbh2, *fTbh3;
TGCheckButton *fCheck1, *fCheck2;
public:
ModelInspectorGUI(RooWorkspace *, ModelConfig *, RooAbsData *);
virtual ~ModelInspectorGUI();
void CloseWindow();
void DoText(const char *text);
void DoSlider();
void DoSlider(const char *);
void DoFit();
void DoExit();
void HandleButtons();
ClassDef(ModelInspectorGUI, 0)
};
//______________________________________________________________________________
ModelInspectorGUI::ModelInspectorGUI(RooWorkspace *w, ModelConfig *mc, RooAbsData *data)
: TGMainFrame(gClient->GetRoot(), 100, 100)
{
fWS = w;
fMC = mc;
fData = data;
RooSimultaneous *simPdf = NULL;
Int_t numCats = 1;
if (strcmp(fMC->GetPdf()->ClassName(), "RooSimultaneous") == 0) {
cout << "Is a simultaneous PDF" << endl;
simPdf = (RooSimultaneous *)(fMC->GetPdf());
RooCategory *channelCat = (RooCategory *)(&simPdf->indexCat());
cout << " with " << channelCat->numTypes() << " categories" << endl;
numCats = channelCat->numTypes();
} else {
cout << "Is not a simultaneous PDF" << endl;
}
fFitRes = 0;
SetCleanup(kDeepCleanup);
// Create an embedded canvas and add to the main frame, centered in x and y
// and with 30 pixel margins all around
fCanvas = new TRootEmbeddedCanvas("Canvas", this, 600, 400);
fLcan = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10, 10, 10, 10);
AddFrame(fCanvas, fLcan);
fPlotList.resize(numCats);
if (numCats > 1) {
fCanvas->GetCanvas()->Divide(numCats);
for (int i = 0; i < numCats; ++i) {
fCanvas->GetCanvas()->cd(i + 1)->SetBorderMode(0);
fCanvas->GetCanvas()->cd(i + 1)->SetGrid();
}
}
fHframe0 = new TGHorizontalFrame(this, 0, 0, 0);
fCheck1 = new TGCheckButton(fHframe0, "&Constrained", HCId1);
fCheck2 = new TGCheckButton(fHframe0, "&Relative", HCId2);
fCheck1->SetState(kButtonUp);
fCheck2->SetState(kButtonUp);
fCheck1->SetToolTipText("Pointer position constrained to slider sides");
fCheck2->SetToolTipText("Pointer position relative to slider position");
fHframe0->Resize(200, 50);
fHframe2 = new TGHorizontalFrame(this, 0, 0, 0);
fFitButton = new TGTextButton(fHframe2, "Fit");
fFitButton->Connect("Clicked()", "ModelInspectorGUI", this, "DoFit()");
fExitButton = new TGTextButton(fHframe2, "Exit ");
fExitButton->Connect("Clicked()", "ModelInspectorGUI", this, "DoExit()");
fCheck1->Connect("Clicked()", "ModelInspectorGUI", this, "HandleButtons()");
fCheck2->Connect("Clicked()", "ModelInspectorGUI", this, "HandleButtons()");
fHframe2->Resize(100, 25);
//--- layout for buttons: top align, equally expand horizontally
fBly = new TGLayoutHints(kLHintsTop | kLHintsExpandX, 5, 5, 5, 5);
//--- layout for the frame: place at bottom, right aligned
fBfly1 = new TGLayoutHints(kLHintsTop | kLHintsCenterX, 5, 5, 5, 5);
fBfly2 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
fBfly3 = new TGLayoutHints(kLHintsTop | kLHintsRight, 5, 5, 5, 5);
fHframe2->AddFrame(fFitButton, fBfly2);
fHframe2->AddFrame(fExitButton, fBfly3);
AddFrame(fHframe0, fBly);
AddFrame(fHframe2, fBly);
// Loop over POI & NP, create slider
// need maps of NP->slider? or just slider->NP
RooArgSet parameters;
parameters.add(*fMC->GetParametersOfInterest());
parameters.add(*fMC->GetNuisanceParameters());
TIterator *it = parameters.createIterator();
RooRealVar *param = NULL;
// BB: This is the part needed in order to have scrollbars
fCan = new TGCanvas(this, 100, 100, kFixedSize);
fVFrame = new TGVerticalFrame(fCan->GetViewPort(), 10, 10);
fCan->SetContainer(fVFrame);
// And that't it!
// Obviously, the parent of other subframes is now fVFrame instead of "this"...
while ((param = (RooRealVar *)it->Next())) {
cout << "Adding Slider for " << param->GetName() << endl;
TGHorizontalFrame *hframek = new TGHorizontalFrame(fVFrame, 0, 0, 0);
TGLabel *hlabel =
new TGLabel(hframek, Form("%s = %.3f +%.3f", param->GetName(), param->getVal(), param->getError()));
TGTripleHSlider *hsliderk = new TGTripleHSlider(hframek, 190, kDoubleScaleBoth, HSId1, kHorizontalFrame,
GetDefaultFrameBackground(), kFALSE, kFALSE, kFALSE, kFALSE);
hsliderk->Connect("PointerPositionChanged()", "ModelInspectorGUI", this, "DoSlider()");
hsliderk->Connect("PositionChanged()", "ModelInspectorGUI", this, "DoSlider()");
hsliderk->SetRange(param->getMin(), param->getMax());
hframek->Resize(200, 25);
fSliderList.Add(hsliderk);
fFrameList.Add(hframek);
hsliderk->SetPosition(param->getVal() - param->getError(), param->getVal() + param->getError());
hsliderk->SetPointerPosition(param->getVal());
hframek->AddFrame(hlabel, fBly);
hframek->AddFrame(hsliderk, fBly);
fVFrame->AddFrame(hframek, fBly);
fSliderMap[hsliderk] = param->GetName();
fLabelMap[hsliderk] = hlabel;
}
// Set main frame name, map sub windows (buttons), initialize layout
// algorithm via Resize() and map main frame
SetWindowName("RooFit/RooStats Model Inspector");
MapSubwindows();
Resize(GetDefaultSize());
MapWindow();
DoSlider();
}
//______________________________________________________________________________
ModelInspectorGUI::~ModelInspectorGUI()
{
// Clean up
Cleanup();
}
//______________________________________________________________________________
void ModelInspectorGUI::CloseWindow()
{
// Called when window is closed via the window manager.
delete this;
}
//______________________________________________________________________________
void ModelInspectorGUI::DoText(const char * /*text*/)
{
// Handle text entry widgets.
Int_t id = te->WidgetId();
switch (id) {
case HId1: fHslider1->SetPosition(atof(fTbh1->GetString()), fHslider1->GetMaxPosition()); break;
case HId2: fHslider1->SetPointerPosition(atof(fTbh2->GetString())); break;
case HId3: fHslider1->SetPosition(fHslider1->GetMinPosition(), atof(fTbh1->GetString())); break;
default: break;
}
DoSlider();
}
//______________________________________________________________________________
void ModelInspectorGUI::DoFit()
{
fFitRes = fMC->GetPdf()->fitTo(*fData, Save());
map<TGTripleHSlider *, const char *>::iterator it;
;
it = fSliderMap.begin();
for (; it != fSliderMap.end(); ++it) {
RooRealVar *param = fWS->var(it->second);
param = (RooRealVar *)fFitRes->floatParsFinal().find(it->second);
it->first->SetPosition(param->getVal() - param->getError(), param->getVal() + param->getError());
it->first->SetPointerPosition(param->getVal());
}
DoSlider();
}
//______________________________________________________________________________
void ModelInspectorGUI::DoSlider(const char *text)
{
cout << "." << text << endl;
}
//______________________________________________________________________________
void ModelInspectorGUI::DoSlider()
{
// Handle slider widgets.
// char buf[32];
RooSimultaneous *simPdf = NULL;
Int_t numCats = 0;
if (strcmp(fMC->GetPdf()->ClassName(), "RooSimultaneous") == 0) {
simPdf = (RooSimultaneous *)(fMC->GetPdf());
RooCategory *channelCat = (RooCategory *)(&simPdf->indexCat());
numCats = channelCat->numTypes();
} else {
}
/////////////////////////////////////////////
if (!simPdf) {
/////////////////////////////////////////////
// if not SimPdf
/////////////////////////////////////////////
// pre loop
map<TGTripleHSlider *, const char *>::iterator it;
;
delete fPlot;
fPlot = ((RooRealVar *)fMC->GetObservables()->first())->frame();
fData->plotOn(fPlot);
double normCount;
// high loop
it = fSliderMap.begin();
for (; it != fSliderMap.end(); ++it) {
const char *name = it->second;
fWS->var(name)->setVal(it->first->GetMaxPosition());
RooRealVar *param = fWS->var(name);
fLabelMap[it->first]->SetText(Form("%s = %.3f [%.3f,%.3f]", param->GetName(), it->first->GetPointerPosition(),
it->first->GetMinPosition(), it->first->GetMaxPosition()));
}
normCount = fMC->GetPdf()->expectedEvents(*fMC->GetObservables());
fMC->GetPdf()->plotOn(fPlot, LineColor(kRed), Normalization(normCount, RooAbsReal::NumEvent));
// low loop
it = fSliderMap.begin();
for (; it != fSliderMap.end(); ++it) {
const char *name = it->second;
fWS->var(name)->setVal(it->first->GetMinPosition());
}
normCount = fMC->GetPdf()->expectedEvents(*fMC->GetObservables());
fMC->GetPdf()->plotOn(fPlot, LineColor(kGreen), Normalization(normCount, RooAbsReal::NumEvent));
// central oop
it = fSliderMap.begin();
for (; it != fSliderMap.end(); ++it) {
const char *name = it->second;
fWS->var(name)->setVal(it->first->GetPointerPosition());
}
normCount = fMC->GetPdf()->expectedEvents(*fMC->GetObservables());
fMC->GetPdf()->plotOn(fPlot, LineColor(kBlue), Normalization(normCount, RooAbsReal::NumEvent));
fPlot->Draw();
fCanvas->GetCanvas()->Modified();
fCanvas->GetCanvas()->Update();
////////////////////////////////////////////////////////////////////////////
} else {
////////////////////////////////////////////////////////////////////////////
// else (is simpdf)
////////////////////////////////////////////////////////////////////////////
RooCategory *channelCat = (RooCategory *)(&simPdf->indexCat());
// TIterator* iter = simPdf->indexCat().typeIterator() ;
TIterator *iter = channelCat->typeIterator();
RooCatType *tt = NULL;
Int_t frameIndex = 0;
while ((tt = (RooCatType *)iter->Next())) {
++frameIndex;
fCanvas->GetCanvas()->cd(frameIndex);
// pre loop
RooAbsPdf *pdftmp = simPdf->getPdf(tt->GetName());
RooArgSet *obstmp = pdftmp->getObservables(*fMC->GetObservables());
RooRealVar *obs = ((RooRealVar *)obstmp->first());
fPlot = fPlotList.at(frameIndex - 1);
if (fPlot)
delete fPlot;
fPlot = obs->frame();
fPlotList.at(frameIndex - 1) = fPlot;
fData->plotOn(fPlot, MarkerSize(1),
Cut(Form("%s==%s::%s", channelCat->GetName(), channelCat->GetName(), tt->GetName())),
map<TGTripleHSlider *, const char *>::iterator it;
;
double normCount;
// high loop
it = fSliderMap.begin();
for (; it != fSliderMap.end(); ++it) {
const char *name = it->second;
fWS->var(name)->setVal(it->first->GetMaxPosition());
RooRealVar *param = fWS->var(name);
fLabelMap[it->first]->SetText(Form("%s = %.3f [%.3f,%.3f]", param->GetName(),
it->first->GetPointerPosition(), it->first->GetMinPosition(),
it->first->GetMaxPosition()));
}
normCount = pdftmp->expectedEvents(*obs);
pdftmp->plotOn(fPlot, LineColor(kRed), LineWidth(2.), Normalization(normCount, RooAbsReal::NumEvent));
// low loop
it = fSliderMap.begin();
for (; it != fSliderMap.end(); ++it) {
const char *name = it->second;
fWS->var(name)->setVal(it->first->GetMinPosition());
RooRealVar *param = fWS->var(name);
fLabelMap[it->first]->SetText(Form("%s = %.3f [%.3f,%.3f]", param->GetName(),
it->first->GetPointerPosition(), it->first->GetMinPosition(),
it->first->GetMaxPosition()));
}
normCount = pdftmp->expectedEvents(*obs);
pdftmp->plotOn(fPlot, LineColor(kGreen), LineWidth(2.), Normalization(normCount, RooAbsReal::NumEvent));
// central loop
it = fSliderMap.begin();
for (; it != fSliderMap.end(); ++it) {
const char *name = it->second;
fWS->var(name)->setVal(it->first->GetPointerPosition());
RooRealVar *param = fWS->var(name);
fLabelMap[it->first]->SetText(Form("%s = %.3f [%.3f,%.3f]", param->GetName(),
it->first->GetPointerPosition(), it->first->GetMinPosition(),
it->first->GetMaxPosition()));
}
normCount = pdftmp->expectedEvents(*obs);
if (!fFitRes)
pdftmp->plotOn(fPlot, LineColor(kBlue), LineWidth(2.), Normalization(normCount, RooAbsReal::NumEvent));
else {
pdftmp->plotOn(fPlot, Normalization(normCount, RooAbsReal::NumEvent),
VisualizeError(*fFitRes, *fMC->GetNuisanceParameters()), FillColor(kYellow));
pdftmp->plotOn(fPlot, LineColor(kBlue), LineWidth(2.), Normalization(normCount, RooAbsReal::NumEvent));
fData->plotOn(fPlot, MarkerSize(1),
Cut(Form("%s==%s::%s", channelCat->GetName(), channelCat->GetName(), tt->GetName())),
}
fPlot->Draw();
}
fCanvas->GetCanvas()->Modified();
fCanvas->GetCanvas()->Update();
///////////////////////////////////////////
// end if(simPdf)
}
}
//______________________________________________________________________________
void ModelInspectorGUI::HandleButtons()
{
// Handle different buttons.
Int_t id = btn->WidgetId();
switch (id) {
case HCId1: fHslider1->SetConstrained(fCheck1->GetState()); break;
case HCId2: fHslider1->SetRelative(fCheck2->GetState()); break;
default: break;
}
}
void ModelInspectorGUI::DoExit()
{
printf("Exit application...");
}
void ModelInspector(const char *infile = "", const char *workspaceName = "combined",
const char *modelConfigName = "ModelConfig", const char *dataName = "obsData")
{
// -------------------------------------------------------
// First part is just to access a user-defined file
// or create the standard example file if it doesn't exist
const char *filename = "";
if (!strcmp(infile, "")) {
filename = "results/example_combined_GaussExample_model.root";
bool fileExist = !gSystem->AccessPathName(filename); // note opposite return code
// if file does not exists generate with histfactory
if (!fileExist) {
#ifdef _WIN32
cout << "HistFactory file cannot be generated on Windows - exit" << endl;
return;
#endif
// Normally this would be run on the command line
cout << "will run standard hist2workspace example" << endl;
gROOT->ProcessLine(".! prepareHistFactory .");
gROOT->ProcessLine(".! hist2workspace config/example.xml");
cout << "\n\n---------------------" << endl;
cout << "Done creating example input" << endl;
cout << "---------------------\n\n" << endl;
}
} else
filename = infile;
// Try to open the file
TFile *file = TFile::Open(filename);
// if input file was specified byt not found, quit
if (!file) {
cout << "StandardRooStatsDemoMacro: Input file " << filename << " is not found" << endl;
return;
}
// -------------------------------------------------------
// Tutorial starts here
// -------------------------------------------------------
// get the workspace out of the file
RooWorkspace *w = (RooWorkspace *)file->Get(workspaceName);
if (!w) {
cout << "workspace not found" << endl;
return;
}
// get the modelConfig out of the file
ModelConfig *mc = (ModelConfig *)w->obj(modelConfigName);
// get the modelConfig out of the file
RooAbsData *data = w->data(dataName);
// make sure ingredients are found
if (!data || !mc) {
w->Print();
cout << "data or ModelConfig was not found" << endl;
return;
}
new ModelInspectorGUI(w, mc, data);
}
  • Version 1, October 2011
    • based on tutorial macro by Bertrand Bellenot, Ilka Antcheva
  • Version 2, November 2011
    • fixes from Bertrand Bellenot for scrolling window for many parameters
Author
Kyle Cranmer

Definition in file ModelInspector.C.

RooWorkspace::data
RooAbsData * data(const char *name) const
Retrieve dataset (binned or unbinned) with given name. A null pointer is returned if not found.
Definition: RooWorkspace.cxx:1368
TGButton::SetToolTipText
virtual void SetToolTipText(const char *text, Long_t delayms=400)
Set tool tip text associated with this button.
Definition: TGButton.cxx:398
RooAbsRealLValue::frame
RooPlot * frame(const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none()) const
Create a new RooPlot on the heap with a drawing frame initialized for this object,...
Definition: RooAbsRealLValue.cxx:199
RooAbsReal::NumEvent
@ NumEvent
Definition: RooAbsReal.h:253
RooWorkspace.h
kLHintsCenterX
@ kLHintsCenterX
Definition: TGLayout.h:38
TGCheckButton::SetState
virtual void SetState(EButtonState state, Bool_t emit=kFALSE)
Set check button state.
Definition: TGButton.cxx:1203
tt
auto * tt
Definition: textangle.C:16
TGMainFrame
Definition: TGFrame.h:444
RooAbsCollection::first
RooAbsArg * first() const
Definition: RooAbsCollection.h:176
TGDoubleSlider::SetRange
virtual void SetRange(Float_t min, Float_t max)
Definition: TGDoubleSlider.h:116
RooSimultaneous::indexCat
const RooAbsCategoryLValue & indexCat() const
Definition: RooSimultaneous.h:80
RooAbsData
Definition: RooAbsData.h:46
RooAbsRealLValue::getMax
virtual Double_t getMax(const char *name=0) const
Get maximum of currently defined range.
Definition: RooAbsRealLValue.h:89
RooSimultaneous.h
TGSlider::GetMaxPosition
virtual Int_t GetMaxPosition() const
Definition: TGSlider.h:111
kGreen
@ kGreen
Definition: Rtypes.h:66
RooFit::DataError
RooCmdArg DataError(Int_t)
Definition: RooGlobalFunc.cxx:156
RooArgSet.h
kLHintsTop
@ kLHintsTop
Definition: TGLayout.h:40
TGLayout.h
Form
char * Form(const char *fmt,...)
RooFit::VisualizeError
RooCmdArg VisualizeError(const RooDataSet &paramData, Double_t Z=1)
Definition: RooGlobalFunc.cxx:70
kLHintsLeft
@ kLHintsLeft
Definition: TGLayout.h:37
TGLabel
Definition: TGLabel.h:32
TGSlider::GetMinPosition
virtual Int_t GetMinPosition() const
Definition: TGSlider.h:110
TVirtualPad::SetBorderMode
virtual void SetBorderMode(Short_t bordermode)=0
kButtonUp
@ kButtonUp
Definition: TGButton.h:59
RooAbsReal::getVal
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
TGTextButton
Definition: TGButton.h:142
TFile::Open
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
Definition: TFile.cxx:3946
gTQSender
R__EXTERN void * gTQSender
Definition: TQObject.h:44
RooFit::Normalization
RooCmdArg Normalization(Double_t scaleFactor)
Definition: RooGlobalFunc.cxx:51
RooMsgService::StreamConfig::removeTopic
void removeTopic(RooFit::MsgTopic oldTopic)
Definition: RooMsgService.h:118
RooMsgService::getStream
StreamConfig & getStream(Int_t id)
Definition: RooMsgService.h:152
TGTripleSlider.h
TList.h
RooArgSet::add
virtual Bool_t add(const RooAbsCollection &col, Bool_t silent=kFALSE)
Add a collection of arguments to this collection by calling add() for each element in the source coll...
Definition: RooArgSet.h:88
TPad::Divide
virtual void Divide(Int_t nx=1, Int_t ny=1, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0)
Automatic pad generation by division.
Definition: TPad.cxx:1166
TGHorizontalFrame
Definition: TGFrame.h:423
TCanvas.h
RooFit::FillColor
RooCmdArg FillColor(Color_t color)
Definition: RooGlobalFunc.cxx:59
TSystem::AccessPathName
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
Definition: TSystem.cxx:1294
RooFit::MsgLevel
MsgLevel
Verbosity level for RooMsgService::StreamConfig in RooMsgService.
Definition: RooGlobalFunc.h:65
TGSlider::SetPosition
virtual void SetPosition(Int_t pos)
Definition: TGSlider.h:105
RooFit::MarkerSize
RooCmdArg MarkerSize(Size_t size)
Definition: RooGlobalFunc.cxx:86
text
TText * text
Definition: entrylist_figure1.C:10
TFile.h
RooFit::NumIntegration
@ NumIntegration
Definition: RooGlobalFunc.h:69
RooAbsCategory::numTypes
Int_t numTypes(const char *=0) const
Return number of types defined (in range named rangeName if rangeName!=0)
Definition: RooAbsCategory.h:133
RooAbsPdf::plotOn
virtual RooPlot * plotOn(RooPlot *frame, const RooCmdArg &arg1=RooCmdArg::none(), const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none(), const RooCmdArg &arg9=RooCmdArg::none(), const RooCmdArg &arg10=RooCmdArg::none()) const
Helper calling plotOn(RooPlot*, RooLinkedList&) const.
Definition: RooAbsPdf.h:118
TIterator
Definition: TIterator.h:30
RooAbsRealLValue::getMin
virtual Double_t getMin(const char *name=0) const
Get miniminum of currently defined range.
Definition: RooAbsRealLValue.h:86
RooFitResult
Definition: RooFitResult.h:40
TGTextBuffer
Definition: TGTextBuffer.h:30
TROOT.h
TPad::Modified
void Modified(Bool_t flag=1)
Definition: TPad.h:414
gClient
#define gClient
Definition: TGClient.h:166
TApplication.h
TGCheckButton
Definition: TGButton.h:264
RooFit::WARNING
@ WARNING
Definition: RooGlobalFunc.h:65
RooFit::Cut
RooCmdArg Cut(const char *cutSpec)
Definition: RooGlobalFunc.cxx:80
RooRealVar::getError
Double_t getError() const
Definition: RooRealVar.h:64
TSystem.h
RooWorkspace::Print
void Print(Option_t *opts=0) const
Print contents of the workspace.
Definition: RooWorkspace.cxx:2194
TGWidget::WidgetId
Int_t WidgetId() const
Definition: TGWidget.h:80
ModelConfig.h
RooFit
Definition: RooCFunction1Binding.h:29
RooAbsPdf.h
TGVerticalFrame
Definition: TGFrame.h:412
TCanvas::cd
TVirtualPad * cd(Int_t subpadnumber=0)
Set current canvas & pad.
Definition: TCanvas.cxx:704
TGFrame::Resize
virtual void Resize(UInt_t w=0, UInt_t h=0)
Resize the frame.
Definition: TGFrame.cxx:590
TGTextEntry
Definition: TGTextEntry.h:39
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
kLHintsRight
@ kLHintsRight
Definition: TGLayout.h:39
RooPlot.h
RooAbsCollection::createIterator
TIterator * createIterator(Bool_t dir=kIterForward) const
TIterator-style iteration over contained elements.
Definition: RooAbsCollection.h:118
RooMsgService::setGlobalKillBelow
void setGlobalKillBelow(RooFit::MsgLevel level)
Definition: RooMsgService.h:160
TGLayoutHints
Definition: TGLayout.h:57
TGTripleHSlider
Definition: TGTripleSlider.h:101
RooWorkspace::obj
TObject * obj(const char *name) const
Return any type of object (RooAbsArg, RooAbsData or generic object) with given name)
Definition: RooWorkspace.cxx:2106
gApplication
R__EXTERN TApplication * gApplication
Definition: TApplication.h:166
RooPlot
Definition: RooPlot.h:44
kFixedSize
@ kFixedSize
Definition: GuiTypes.h:390
RooCategory.h
TApplication::Terminate
virtual void Terminate(Int_t status=0)
kLHintsExpandY
@ kLHintsExpandY
Definition: TGLayout.h:44
RooAbsCategory::typeIterator
TIterator * typeIterator() const
Definition: RooAbsCategory.cxx:653
RooRealVar.h
kRed
@ kRed
Definition: Rtypes.h:66
TFile
Definition: TFile.h:54
RooFitResult.h
TIterator::Next
virtual TObject * Next()=0
RooAbsReal::plotOn
virtual RooPlot * plotOn(RooPlot *frame, const RooCmdArg &arg1=RooCmdArg(), const RooCmdArg &arg2=RooCmdArg(), const RooCmdArg &arg3=RooCmdArg(), const RooCmdArg &arg4=RooCmdArg(), const RooCmdArg &arg5=RooCmdArg(), const RooCmdArg &arg6=RooCmdArg(), const RooCmdArg &arg7=RooCmdArg(), const RooCmdArg &arg8=RooCmdArg(), const RooCmdArg &arg9=RooCmdArg(), const RooCmdArg &arg10=RooCmdArg()) const
Plot (project) PDF on specified frame.
Definition: RooAbsReal.cxx:1714
TRootEmbeddedCanvas.h
kHorizontalFrame
@ kHorizontalFrame
Definition: GuiTypes.h:382
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
RooAbsData::None
@ None
Definition: RooAbsData.h:96
TGLabel.h
RooWorkspace
Definition: RooWorkspace.h:43
RooFit::LineColor
RooCmdArg LineColor(Color_t color)
Definition: RooGlobalFunc.cxx:56
TQObject::Connect
Bool_t Connect(const char *signal, const char *receiver_class, void *receiver, const char *slot)
Non-static method is used to connect from the signal of this object to the receiver slot.
Definition: TQObject.cxx:864
RooAbsArg::getObservables
RooArgSet * getObservables(const RooArgSet &set, Bool_t valueOnly=kTRUE) const
Return the observables of this pdf given a set of observables.
Definition: RooAbsArg.h:294
TF1.h
RooCategory
Definition: RooCategory.h:27
RooStats
Definition: Asimov.h:19
file
Definition: file.py:1
TGButton::GetState
virtual EButtonState GetState() const
Definition: TGButton.h:112
TGTextEntry.h
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:325
TGButton.h
TCanvas::Update
virtual void Update()
Update canvas pad buffers.
Definition: TCanvas.cxx:2500
name
char name[80]
Definition: TGX11.cxx:110
TVirtualPad::SetGrid
virtual void SetGrid(Int_t valuex=1, Int_t valuey=1)=0
kDeepCleanup
@ kDeepCleanup
Definition: TGFrame.h:51
RooSimultaneous::getPdf
RooAbsPdf * getPdf(const char *catName) const
Return the p.d.f associated with the given index category name.
Definition: RooSimultaneous.cxx:351
kBlue
@ kBlue
Definition: Rtypes.h:66
RooCatType
Definition: RooCatTypeLegacy.h:23
TRootEmbeddedCanvas::GetCanvas
TCanvas * GetCanvas() const
Definition: TRootEmbeddedCanvas.h:63
kLHintsExpandX
@ kLHintsExpandX
Definition: TGLayout.h:43
RooAbsPdf
Definition: RooAbsPdf.h:40
RooFit::LineWidth
RooCmdArg LineWidth(Width_t width)
Definition: RooGlobalFunc.cxx:58
TGTripleHSlider::SetPointerPosition
virtual void SetPointerPosition(Float_t pos)
Set pointer position in scaled (real) value.
Definition: TGTripleSlider.cxx:609
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:53
kDoubleScaleBoth
@ kDoubleScaleBoth
Definition: TGDoubleSlider.h:68
TGButton
Definition: TGButton.h:68
RooSimultaneous
Definition: RooSimultaneous.h:37
TF1
1-Dim function class
Definition: TF1.h:212
RooRealVar
Definition: RooRealVar.h:36
RooFit::Save
RooCmdArg Save(Bool_t flag=kTRUE)
Definition: RooGlobalFunc.cxx:187
TGCanvas
Definition: TGCanvas.h:202
RooStats::ModelConfig
Definition: ModelConfig.h:36
kYellow
@ kYellow
Definition: Rtypes.h:66
TGCompositeFrame::AddFrame
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=0)
Add frame to the composite frame using the specified layout hints.
Definition: TGFrame.cxx:1102
RooMsgService::instance
static RooMsgService & instance()
Return reference to singleton instance.
Definition: RooMsgService.cxx:363
RooMsgService::globalKillBelow
RooFit::MsgLevel globalKillBelow() const
Definition: RooMsgService.h:161
TGTextBuffer::GetString
const char * GetString() const
Definition: TGTextBuffer.h:53
TList
Definition: TList.h:44
TMath.h
RooArgSet
Definition: RooArgSet.h:28
TRootEmbeddedCanvas
Definition: TRootEmbeddedCanvas.h:32
TGDoubleSlider::SetPosition
virtual void SetPosition(Float_t min, Float_t max)
Definition: TGDoubleSlider.h:121
gROOT
#define gROOT
Definition: TROOT.h:406
int
RooAbsPdf::expectedEvents
virtual Double_t expectedEvents(const RooArgSet *nset) const
Return expected number of events from this p.d.f for use in extended likelihood calculations.
Definition: RooAbsPdf.cxx:3309