ModelInspector.C

Go to the documentation of this file.

/// \file
/// \ingroup tutorial_roostats
/// 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
///
/// ~~~{.cpp}
/// $ 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?
///
/// \macro_code
///
///  - 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
 
#include "TGButton.h"
#include "TRootEmbeddedCanvas.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 "RooStats/ModelConfig.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 "RooSimultaneous.h"
#include "RooCategory.h"
 
enum ETestCommandIdentifiers {
   HId1,
   HId2,
   HId3,
   HCId1,
   HCId2,
 
   HSId1
};
 
using namespace RooFit;
using namespace RooStats;
class ModelInspectorGUI : public TGMainFrame {
 
private:
   TRootEmbeddedCanvas *fCanvas;
   TGLayoutHints       *fLcan;
   TF1                 *fFitFcn;
  RooPlot* fPlot;
  RooWorkspace* fWS;
  TFile* fFile;
  ModelConfig* fMC;
  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)
{
 
  RooMsgService::instance().getStream(1).removeTopic(RooFit::NumIntegration);
  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);
   AddFrame(fCan, new TGLayoutHints(kLHintsExpandY | kLHintsExpandX));
   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.
 
   TGTextEntry *te = (TGTextEntry *) gTQSender;
   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;
 
      RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelow();
      RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING);
      fData->plotOn(fPlot,MarkerSize(1),Cut(Form("%s==%s::%s",channelCat->GetName(),channelCat->GetName(),tt->GetName())),DataError(RooAbsData::None));
      RooMsgService::instance().setGlobalKillBelow(msglevel);
 
 
      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)) ;
         msglevel = RooMsgService::instance().globalKillBelow();
         RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING);
         fData->plotOn(fPlot,MarkerSize(1),Cut(Form("%s==%s::%s",channelCat->GetName(),channelCat->GetName(),tt->GetName())),DataError(RooAbsData::None));
         RooMsgService::instance().setGlobalKillBelow(msglevel);
      }
      fPlot->Draw();
    }
    fCanvas->GetCanvas()->Modified();
    fCanvas->GetCanvas()->Update();
    ///////////////////////////////////////////
    // end if(simPdf)
  }
 
 
}
 
//______________________________________________________________________________
void ModelInspectorGUI::HandleButtons()
{
   // Handle different buttons.
 
   TGButton *btn = (TGButton *) gTQSender;
   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...");
   gApplication->Terminate(0);
}
 
 
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);
}