// @(#)root/roostats:$Id$
// Authors: Kevin Belasco        17/06/2009
// Authors: Kyle Cranmer         17/06/2009
/*************************************************************************
 * Project: RooStats                                                     *
 * Package: RooFit/RooStats                                              *
 *************************************************************************
 * Copyright (C) 1995-2008, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//_________________________________________________
/*
BEGIN_HTML
<p>
This class provides simple and straightforward utilities to plot a MCMCInterval
object.  Basic use only requires a few lines once you have an MCMCInterval*:
</p>
<p>
MCMCIntervalPlot plot(*interval);
plot.Draw();
</p>
<p>
The standard Draw() function will currently draw the confidence interval
range with bars if 1-D and a contour if 2-D.  The MCMC posterior will also be
plotted for the 1-D case.
</p>
END_HTML
*/
//_________________________________________________

#ifndef ROOSTATS_MCMCIntervalPlot
#include "RooStats/MCMCIntervalPlot.h"
#endif
#include <iostream>
#ifndef ROOT_TROOT
#include "TROOT.h"
#endif
#ifndef ROOT_TMath
#include "TMath.h"
#endif
#ifndef ROOT_TLine
#include "TLine.h"
#endif
#ifndef ROOT_TObjArray
#include "TObjArray.h"
#endif
#ifndef ROOT_TList
#include "TList.h"
#endif
#ifndef ROOT_TGraph
#include "TGraph.h"
#endif
#ifndef ROOT_TPad
#include "TPad.h"
#endif
#ifndef ROO_REAL_VAR
#include "RooRealVar.h"
#endif
#ifndef ROO_PLOT
#include "RooPlot.h"
#endif
#ifndef ROOT_TH2
#include "TH2.h"
#endif
#ifndef ROOT_TH1F
#include "TH1F.h"
#endif
#ifndef ROO_ARG_LIST
#include "RooArgList.h"
#endif
#ifndef ROOT_TAxis
#include "TAxis.h"
#endif
#ifndef ROO_GLOBAL_FUNC
#include "RooGlobalFunc.h"
#endif

// Extra draw commands
//static const char* POSTERIOR_HIST = "posterior_hist";
//static const char* POSTERIOR_KEYS_PDF = "posterior_keys_pdf";
//static const char* POSTERIOR_KEYS_PRODUCT = "posterior_keys_product";
//static const char* HIST_INTERVAL = "hist_interval";
//static const char* KEYS_PDF_INTERVAL = "keys_pdf_interval";
//static const char* TAIL_FRACTION_INTERVAL = "tail_fraction_interval";
//static const char* OPTION_SEP = ":";

ClassImp(RooStats::MCMCIntervalPlot);

using namespace std;
using namespace RooStats;

MCMCIntervalPlot::MCMCIntervalPlot()
{
   fInterval = NULL;
   fParameters = NULL;
   fPosteriorHist = NULL;
   fPosteriorKeysPdf = NULL;
   fPosteriorKeysProduct = NULL;
   fDimension = 0;
   fLineColor = kBlack;
   fShadeColor = kGray;
   fLineWidth = 1;
   //fContourColor = kBlack;
   fShowBurnIn = kTRUE;
   fWalk = NULL;
   fBurnIn = NULL;
   fFirst = NULL;
   fParamGraph = NULL;
   fNLLGraph = NULL;
   fNLLHist = NULL;
   fWeightHist = NULL;
   fPosteriorHistHistCopy = NULL;
   fPosteriorHistTFCopy = NULL;
}

MCMCIntervalPlot::MCMCIntervalPlot(MCMCInterval& interval)
{
   SetMCMCInterval(interval);
   fPosteriorHist = NULL;
   fPosteriorKeysPdf = NULL;
   fPosteriorKeysProduct = NULL;
   fLineColor = kBlack;
   fShadeColor = kGray;
   fLineWidth = 1;
   //fContourColor = kBlack;
   fShowBurnIn = kTRUE;
   fWalk = NULL;
   fBurnIn = NULL;
   fFirst = NULL;
   fParamGraph = NULL;
   fNLLGraph = NULL;
   fNLLHist = NULL;
   fWeightHist = NULL;
   fPosteriorHistHistCopy = NULL;
   fPosteriorHistTFCopy = NULL;
}

MCMCIntervalPlot::~MCMCIntervalPlot()
{
   delete fParameters;
   // kbelasco: why does deleting fPosteriorHist remove the graphics
   // but deleting TGraphs doesn't?
   //delete fPosteriorHist;
   // can we delete fNLLHist and fWeightHist?
   //delete fNLLHist;
   //delete fWeightHist;

   // kbelasco: should we delete fPosteriorKeysPdf and fPosteriorKeysProduct?
   delete fPosteriorKeysPdf;
   delete fPosteriorKeysProduct;

   delete fWalk;
   delete fBurnIn;
   delete fFirst;
   delete fParamGraph;
   delete fNLLGraph;
}

void MCMCIntervalPlot::SetMCMCInterval(MCMCInterval& interval)
{
   fInterval = &interval;
   fDimension = fInterval->GetDimension();
   fParameters = fInterval->GetParameters();
}

void MCMCIntervalPlot::Draw(const Option_t* options)
{
   DrawInterval(options);
}

void MCMCIntervalPlot::DrawPosterior(const Option_t* options)
{
   if (fInterval->GetUseKeys())
      DrawPosteriorKeysPdf(options);
   else
      DrawPosteriorHist(options);
}

void* MCMCIntervalPlot::DrawPosteriorHist(const Option_t* /*options*/,
      const char* title, Bool_t scale)
{
   if (fPosteriorHist == NULL)
      fPosteriorHist = fInterval->GetPosteriorHist();

   if (fPosteriorHist == NULL) {
      coutE(InputArguments) << "MCMCIntervalPlot::DrawPosteriorHist: "
         << "Couldn't get posterior histogram." << endl;
      return NULL;
   }

   // kbelasco: annoying hack because histogram drawing fails when it sees
   // an unrecognized option like POSTERIOR_HIST, etc.
   //const Option_t* myOpt = NULL;

   //TString tmpOpt(options);
   //if (tmpOpt.Contains("same"))
   //   myOpt = "same";

   // scale so highest bin has height 1
   if (scale)
      fPosteriorHist->Scale(1/fPosteriorHist->GetBinContent(
               fPosteriorHist->GetMaximumBin()));

   TString ourTitle(GetTitle());
   if (ourTitle.CompareTo("") == 0) {
      if (title)
         fPosteriorHist->SetTitle(title);
   } else
      fPosteriorHist->SetTitle(GetTitle());

   //fPosteriorHist->Draw(myOpt);

   return (void*)fPosteriorHist;
}

void* MCMCIntervalPlot::DrawPosteriorKeysPdf(const Option_t* options)
{
   if (fPosteriorKeysPdf == NULL)
      fPosteriorKeysPdf = fInterval->GetPosteriorKeysPdf();

   if (fPosteriorKeysPdf == NULL) {
      coutE(InputArguments) << "MCMCIntervalPlot::DrawPosteriorKeysPdf: "
         << "Couldn't get posterior Keys PDF." << endl;
      return NULL;
   }

   TString title(GetTitle());
   Bool_t isEmpty = (title.CompareTo("") == 0);

   if (fDimension == 1) {
      RooRealVar* v = (RooRealVar*)fParameters->first();
      RooPlot* frame = v->frame();
      if (frame == NULL) { 
         coutE(InputArguments) << "MCMCIntervalPlot::DrawPosteriorKeysPdf: "
                               << "Invalid parameter" << endl;
         return NULL;
      }
      if (isEmpty)
         frame->SetTitle(Form("Posterior Keys PDF for %s", v->GetName()));
      else
         frame->SetTitle(GetTitle());
      //fPosteriorKeysPdf->plotOn(frame);
      //fPosteriorKeysPdf->plotOn(frame,
      //      RooFit::Normalization(1, RooAbsReal::Raw));
      //frame->Draw(options);
      return (void*)frame;
   } else if (fDimension == 2) {
      RooArgList* axes = fInterval->GetAxes();
      RooRealVar* xVar = (RooRealVar*)axes->at(0);
      RooRealVar* yVar = (RooRealVar*)axes->at(1);
      TH2F* keysHist = (TH2F*)fPosteriorKeysPdf->createHistogram(
            "keysPlot2D", *xVar, RooFit::YVar(*yVar), RooFit::Scaling(kFALSE));
      if (isEmpty)
         keysHist->SetTitle(
               Form("MCMC histogram of posterior Keys PDF for %s, %s",
                  axes->at(0)->GetName(), axes->at(1)->GetName()));
      else
         keysHist->SetTitle(GetTitle());

      keysHist->Draw(options);
      delete axes;
      return NULL;
   }
   return NULL;
}

void MCMCIntervalPlot::DrawInterval(const Option_t* options)
{
   switch (fInterval->GetIntervalType()) {
      case MCMCInterval::kShortest:
         DrawShortestInterval(options);
         break;
      case MCMCInterval::kTailFraction:
         DrawTailFractionInterval(options);
         break;
      default:
         coutE(InputArguments) << "MCMCIntervalPlot::DrawInterval(): " <<
            "Interval type not supported" << endl;
         break;
   }
}

void MCMCIntervalPlot::DrawShortestInterval(const Option_t* options)
{
   if (fInterval->GetUseKeys())
      DrawKeysPdfInterval(options);
   else
      DrawHistInterval(options);
}

void MCMCIntervalPlot::DrawKeysPdfInterval(const Option_t* options)
{
   TString title(GetTitle());
   Bool_t isEmpty = (title.CompareTo("") == 0);

   if (fDimension == 1) {
      // Draw the posterior keys PDF as well so the user can see where the
      // limit bars line up
      // fDimension == 1, so we know we will receive a RooPlot
      RooPlot* frame = (RooPlot*)DrawPosteriorKeysPdf(options);

      //Double_t height = 1;
      //Double_t height = 2.0 * fInterval->GetKeysPdfCutoff();
      Double_t height = fInterval->GetKeysMax();

      RooRealVar* p = (RooRealVar*)fParameters->first();
      Double_t ul = fInterval->UpperLimitByKeys(*p);
      Double_t ll = fInterval->LowerLimitByKeys(*p);

      if (frame != NULL && fPosteriorKeysPdf != NULL) {
         // draw shading in interval
         if (isEmpty)
            frame->SetTitle(NULL);
         else
            frame->SetTitle(GetTitle());
         frame->GetYaxis()->SetTitle(Form("Posterior for parameter %s",
                  p->GetName()));
         fPosteriorKeysPdf->plotOn(frame,
               RooFit::Normalization(1, RooAbsReal::Raw),
               RooFit::Range(ll, ul, kFALSE),
               RooFit::VLines(),
               RooFit::DrawOption("F"),
               RooFit::MoveToBack(),
               RooFit::FillColor(fShadeColor));

         // hack - this is drawn twice now:
         // once by DrawPosteriorKeysPdf (which also configures things and sets
         // the title), and once again here so the shading shows up behind.
         fPosteriorKeysPdf->plotOn(frame,
               RooFit::Normalization(1, RooAbsReal::Raw));
      }
      if (frame) {
	frame->Draw(options);
      }

      TLine* llLine = new TLine(ll, 0, ll, height);
      TLine* ulLine = new TLine(ul, 0, ul, height);
      llLine->SetLineColor(fLineColor);
      ulLine->SetLineColor(fLineColor);
      llLine->SetLineWidth(fLineWidth);
      ulLine->SetLineWidth(fLineWidth);
      llLine->Draw(options);
      ulLine->Draw(options);
   } else if (fDimension == 2) {
      if (fPosteriorKeysPdf == NULL)
         fPosteriorKeysPdf = fInterval->GetPosteriorKeysPdf();

      if (fPosteriorKeysPdf == NULL) {
         coutE(InputArguments) << "MCMCIntervalPlot::DrawKeysPdfInterval: "
            << "Couldn't get posterior Keys PDF." << endl;
         return;
      }

      RooArgList* axes = fInterval->GetAxes();
      RooRealVar* xVar = (RooRealVar*)axes->at(0);
      RooRealVar* yVar = (RooRealVar*)axes->at(1);
      TH2F* contHist = (TH2F*)fPosteriorKeysPdf->createHistogram(
          "keysContour2D", *xVar, RooFit::YVar(*yVar), RooFit::Scaling(kFALSE));
      //if (isEmpty)
      //   contHist->SetTitle(Form("MCMC Keys conf. interval for %s, %s",
      //            axes->at(0)->GetName(), axes->at(1)->GetName()));
      //else
      //   contHist->SetTitle(GetTitle());
      if (!isEmpty)
         contHist->SetTitle(GetTitle());
      else
         contHist->SetTitle(NULL);

      contHist->SetStats(kFALSE);

      TString tmpOpt(options);
      if (!tmpOpt.Contains("CONT2")) tmpOpt.Append("CONT2");

      Double_t cutoff = fInterval->GetKeysPdfCutoff();
      contHist->SetContour(1, &cutoff);
      contHist->SetLineColor(fLineColor);
      contHist->SetLineWidth(fLineWidth);
      contHist->Draw(tmpOpt.Data());
      delete axes;
   } else {
      coutE(InputArguments) << "MCMCIntervalPlot::DrawKeysPdfInterval: "
         << " Sorry: " << fDimension << "-D plots not currently supported" << endl;
   }
}

void MCMCIntervalPlot::DrawHistInterval(const Option_t* options)
{
   TString title(GetTitle());
   Bool_t isEmpty = (title.CompareTo("") == 0);

   if (fDimension == 1) {
      // draw lower and upper limits
      RooRealVar* p = (RooRealVar*)fParameters->first();
      Double_t ul = fInterval->UpperLimitByHist(*p);
      Double_t ll = fInterval->LowerLimitByHist(*p);

      // Draw the posterior histogram as well so the user can see where the
      // limit bars line up
      // fDimension == 1, so we know will get a TH1F*
      TH1F* hist = (TH1F*)DrawPosteriorHist(options, NULL, false);
      if (hist == NULL) return;
      if (isEmpty)
         hist->SetTitle(NULL);
      else
         hist->SetTitle(GetTitle());
      hist->GetYaxis()->SetTitle(Form("Posterior for parameter %s",
               p->GetName()));
      hist->SetStats(kFALSE);
      TH1F* copy = (TH1F*)hist->Clone(Form("%s_copy", hist->GetTitle()));
      Double_t histCutoff = fInterval->GetHistCutoff();

      Int_t i;
      Int_t nBins = copy->GetNbinsX();
      Double_t height;
      for (i = 1; i <= nBins; i++) {
         // remove bins with height < cutoff
         height = copy->GetBinContent(i);
         if (height < histCutoff)
            copy->SetBinContent(i, 0);
      }

      hist->Scale(1/hist->GetBinContent(hist->GetMaximumBin()));
      copy->Scale(1/copy->GetBinContent(hist->GetMaximumBin()));

      copy->SetFillStyle(1001);
      copy->SetFillColor(fShadeColor);
      hist->Draw(options);
      copy->Draw("same");

      fPosteriorHistHistCopy = copy;

      TLine* llLine = new TLine(ll, 0, ll, 1);
      TLine* ulLine = new TLine(ul, 0, ul, 1);
      llLine->SetLineColor(fLineColor);
      ulLine->SetLineColor(fLineColor);
      llLine->SetLineWidth(fLineWidth);
      ulLine->SetLineWidth(fLineWidth);
      llLine->Draw(options);
      ulLine->Draw(options);

   } else if (fDimension == 2) {
      if (fPosteriorHist == NULL)
         fPosteriorHist = fInterval->GetPosteriorHist();

      if (fPosteriorHist == NULL) {
         coutE(InputArguments) << "MCMCIntervalPlot::DrawHistInterval: "
            << "Couldn't get posterior histogram." << endl;
         return;
      }

      RooArgList* axes = fInterval->GetAxes();
      //if (isEmpty)
      //   fPosteriorHist->SetTitle(
      //         Form("MCMC histogram conf. interval for %s, %s",
      //            axes->at(0)->GetName(), axes->at(1)->GetName()));
      //else
      //   fPosteriorHist->SetTitle(GetTitle());
      if (!isEmpty)
         fPosteriorHist->SetTitle(GetTitle());
      else
         fPosteriorHist->SetTitle(NULL);
      delete axes;

      fPosteriorHist->SetStats(kFALSE);

      TString tmpOpt(options);
      if (!tmpOpt.Contains("CONT2")) tmpOpt.Append("CONT2");

      Double_t cutoff = fInterval->GetHistCutoff();
      fPosteriorHist->SetContour(1, &cutoff);
      fPosteriorHist->SetLineColor(fLineColor);
      fPosteriorHist->SetLineWidth(fLineWidth);
      fPosteriorHist->Draw(tmpOpt.Data());
   } else {
      coutE(InputArguments) << "MCMCIntervalPlot::DrawHistInterval: "
         << " Sorry: " << fDimension << "-D plots not currently supported" << endl;
   }
}

void MCMCIntervalPlot::DrawTailFractionInterval(const Option_t* options)
{
   TString title(GetTitle());
   Bool_t isEmpty = (title.CompareTo("") == 0);

   if (fDimension == 1) {
      // Draw the posterior histogram as well so the user can see where the
      // limit bars line up
      RooRealVar* p = (RooRealVar*)fParameters->first();
      Double_t ul = fInterval->UpperLimitTailFraction(*p);
      Double_t ll = fInterval->LowerLimitTailFraction(*p);

      TH1F* hist = (TH1F*)DrawPosteriorHist(options, NULL, false);
      if (hist == NULL) return;
      if (isEmpty)
         hist->SetTitle(NULL);
      else
         hist->SetTitle(GetTitle());
      hist->GetYaxis()->SetTitle(Form("Posterior for parameter %s",
               p->GetName()));
      hist->SetStats(kFALSE);
      TH1F* copy = (TH1F*)hist->Clone(Form("%s_copy", hist->GetTitle()));

      Int_t i;
      Int_t nBins = copy->GetNbinsX();
      Double_t center;
      for (i = 1; i <= nBins; i++) {
         // remove bins outside interval
         center = copy->GetBinCenter(i);
         if (center < ll || center > ul)
            copy->SetBinContent(i, 0);
      }

      hist->Scale(1/hist->GetBinContent(hist->GetMaximumBin()));
      copy->Scale(1/copy->GetBinContent(hist->GetMaximumBin()));

      copy->SetFillStyle(1001);
      copy->SetFillColor(fShadeColor);
      hist->Draw(options);
      copy->Draw("same");

      // draw lower and upper limits
      TLine* llLine = new TLine(ll, 0, ll, 1);
      TLine* ulLine = new TLine(ul, 0, ul, 1);
      llLine->SetLineColor(fLineColor);
      ulLine->SetLineColor(fLineColor);
      llLine->SetLineWidth(fLineWidth);
      ulLine->SetLineWidth(fLineWidth);
      llLine->Draw(options);
      ulLine->Draw(options);
   } else {
      coutE(InputArguments) << "MCMCIntervalPlot::DrawTailFractionInterval: "
         << " Sorry: " << fDimension << "-D plots not currently supported"
         << endl;
   }
}

void* MCMCIntervalPlot::DrawPosteriorKeysProduct(const Option_t* options)
{
   if (fPosteriorKeysProduct == NULL)
      fPosteriorKeysProduct = fInterval->GetPosteriorKeysProduct();

   if (fPosteriorKeysProduct == NULL) {
      coutE(InputArguments) << "MCMCIntervalPlot::DrawPosteriorKeysProduct: "
         << "Couldn't get posterior Keys product." << endl;
      return NULL;
   }

   RooArgList* axes = fInterval->GetAxes();

   TString title(GetTitle());
   Bool_t isEmpty = (title.CompareTo("") == 0);

   if (fDimension == 1) {
      RooPlot* frame = ((RooRealVar*)fParameters->first())->frame();
      if (!frame) return NULL;
      if (isEmpty)
         frame->SetTitle(Form("Posterior Keys PDF * Heaviside product for %s",
                  axes->at(0)->GetName()));
      else
         frame->SetTitle(GetTitle());
      //fPosteriorKeysProduct->plotOn(frame);
      fPosteriorKeysProduct->plotOn(frame,
            RooFit::Normalization(1, RooAbsReal::Raw));
      frame->Draw(options);
      return (void*)frame;
   } else if (fDimension == 2) {
      RooRealVar* xVar = (RooRealVar*)axes->at(0);
      RooRealVar* yVar = (RooRealVar*)axes->at(1);
      TH2F* productHist = (TH2F*)fPosteriorKeysProduct->createHistogram(
            "prodPlot2D", *xVar, RooFit::YVar(*yVar), RooFit::Scaling(kFALSE));
      if (isEmpty)
         productHist->SetTitle(
               Form("MCMC Posterior Keys Product Hist. for %s, %s",
                  axes->at(0)->GetName(), axes->at(1)->GetName()));
      else
         productHist->SetTitle(GetTitle());
      productHist->Draw(options);
      return NULL;
   }
   delete axes;
   return NULL;
}

void MCMCIntervalPlot::DrawChainScatter(RooRealVar& xVar, RooRealVar& yVar)
{
   const MarkovChain* markovChain = fInterval->GetChain();

   Int_t size = markovChain->Size();
   Int_t burnInSteps;
   if (fShowBurnIn)
      burnInSteps = fInterval->GetNumBurnInSteps();
   else
      burnInSteps = 0;

   Double_t* x = new Double_t[size - burnInSteps];
   Double_t* y = new Double_t[size - burnInSteps];
   Double_t* burnInX = NULL;
   Double_t* burnInY = NULL;
   if (burnInSteps > 0) {
      burnInX = new Double_t[burnInSteps];
      burnInY = new Double_t[burnInSteps];
   }
   Double_t firstX;
   Double_t firstY;

   for (Int_t i = burnInSteps; i < size; i++) {
      x[i - burnInSteps] = markovChain->Get(i)->getRealValue(xVar.GetName());
      y[i - burnInSteps] = markovChain->Get(i)->getRealValue(yVar.GetName());
   }

   for (Int_t i = 0; i < burnInSteps; i++) {
      burnInX[i] = markovChain->Get(i)->getRealValue(xVar.GetName());
      burnInY[i] = markovChain->Get(i)->getRealValue(yVar.GetName());
   }

   firstX = markovChain->Get(0)->getRealValue(xVar.GetName());
   firstY = markovChain->Get(0)->getRealValue(yVar.GetName());

   TString title(GetTitle());
   Bool_t isEmpty = (title.CompareTo("") == 0);

   TGraph* walk = new TGraph(size - burnInSteps, x, y);
   if (isEmpty)
      walk->SetTitle(Form("2-D Scatter Plot of Markov chain for %s, %s",
               xVar.GetName(), yVar.GetName()));
   else
      walk->SetTitle(GetTitle());
   // kbelasco: figure out how to set TGraph variable ranges
   walk->GetXaxis()->Set(xVar.numBins(), xVar.getMin(), xVar.getMax());
   walk->GetXaxis()->SetTitle(xVar.GetName());
   walk->GetYaxis()->Set(yVar.numBins(), yVar.getMin(), yVar.getMax());
   walk->GetYaxis()->SetTitle(yVar.GetName());
   walk->SetLineColor(kGray);
   walk->SetMarkerStyle(6);
   walk->SetMarkerColor(kViolet);
   walk->Draw("A,L,P,same");

   TGraph* burnIn = NULL;
   if (burnInX != NULL && burnInY != NULL) {
      burnIn = new TGraph(burnInSteps - 1, burnInX, burnInY);
      burnIn->SetLineColor(kPink);
      burnIn->SetMarkerStyle(6);
      burnIn->SetMarkerColor(kPink);
      burnIn->Draw("L,P,same");
   }

   TGraph* first = new TGraph(1, &firstX, &firstY);
   first->SetLineColor(kGreen);
   first->SetMarkerStyle(3);
   first->SetMarkerSize(2);
   first->SetMarkerColor(kGreen);
   first->Draw("L,P,same");

   //walkCanvas->Update();
   delete [] x;
   delete [] y;
   if (burnInX != NULL) delete [] burnInX;
   if (burnInY != NULL) delete [] burnInY;
   //delete walk;
   //delete burnIn;
   //delete first;
}

void MCMCIntervalPlot::DrawParameterVsTime(RooRealVar& param)
{
   const MarkovChain* markovChain = fInterval->GetChain();
   Int_t size = markovChain->Size();
   Int_t numEntries = 2 * size;
   Double_t* value = new Double_t[numEntries];
   Double_t* time = new Double_t[numEntries];
   Double_t val;
   Int_t weight;
   Int_t t = 0;
   for (Int_t i = 0; i < size; i++) {
      val = markovChain->Get(i)->getRealValue(param.GetName());
      weight = (Int_t)markovChain->Weight();
      value[2*i] = val;
      value[2*i + 1] = val;
      time[2*i] = t;
      t += weight;
      time[2*i + 1] = t;
   }

   TString title(GetTitle());
   Bool_t isEmpty = (title.CompareTo("") == 0);

   TGraph* paramGraph = new TGraph(numEntries, time, value);
   if (isEmpty)
      paramGraph->SetTitle(Form("%s vs. time in Markov chain",param.GetName()));
   else
      paramGraph->SetTitle(GetTitle());
   paramGraph->GetXaxis()->SetTitle("Time (discrete steps)");
   paramGraph->GetYaxis()->SetTitle(param.GetName());
   //paramGraph->SetLineColor(fLineColor);
   paramGraph->Draw("A,L,same");
   delete [] value; 
   delete [] time; 
   //gPad->Update();
}

void MCMCIntervalPlot::DrawNLLVsTime()
{
   const MarkovChain* markovChain = fInterval->GetChain();
   Int_t size = markovChain->Size();
   Int_t numEntries = 2 * size;
   Double_t* nllValue = new Double_t[numEntries];
   Double_t* time = new Double_t[numEntries];
   Double_t nll;
   Int_t weight;
   Int_t t = 0;
   for (Int_t i = 0; i < size; i++) {
      nll = markovChain->NLL(i);
      weight = (Int_t)markovChain->Weight();
      nllValue[2*i] = nll;
      nllValue[2*i + 1] = nll;
      time[2*i] = t;
      t += weight;
      time[2*i + 1] = t;
   }

   TString title(GetTitle());
   Bool_t isEmpty = (title.CompareTo("") == 0);

   TGraph* nllGraph = new TGraph(numEntries, time, nllValue);
   if (isEmpty)
      nllGraph->SetTitle("NLL value vs. time in Markov chain");
   else
      nllGraph->SetTitle(GetTitle());
   nllGraph->GetXaxis()->SetTitle("Time (discrete steps)");
   nllGraph->GetYaxis()->SetTitle("NLL (-log(likelihood))");
   //nllGraph->SetLineColor(fLineColor);
   nllGraph->Draw("A,L,same");
   //gPad->Update();
   delete [] nllValue; 
   delete [] time; 
}

void MCMCIntervalPlot::DrawNLLHist(const Option_t* options)
{
   if (fNLLHist == NULL) {
      const MarkovChain* markovChain = fInterval->GetChain();
      // find the max NLL value
      Double_t maxNLL = 0;
      Int_t size = markovChain->Size();
      for (Int_t i = 0; i < size; i++)
         if (markovChain->NLL(i) > maxNLL)
            maxNLL = markovChain->NLL(i);
      RooRealVar* nllVar = fInterval->GetNLLVar();
      fNLLHist = new TH1F("mcmc_nll_hist", "MCMC NLL Histogram",
            nllVar->getBins(), 0, maxNLL);
      TString title(GetTitle());
      Bool_t isEmpty = (title.CompareTo("") == 0);
      if (!isEmpty)
         fNLLHist->SetTitle(GetTitle());
      fNLLHist->GetXaxis()->SetTitle("-log(likelihood)");
      for (Int_t i = 0; i < size; i++)
         fNLLHist->Fill(markovChain->NLL(i), markovChain->Weight());
   }
   fNLLHist->Draw(options);
}

void MCMCIntervalPlot::DrawWeightHist(const Option_t* options)
{
   if (fWeightHist == NULL) {
      const MarkovChain* markovChain = fInterval->GetChain();
      // find the max weight value
      Double_t maxWeight = 0;
      Int_t size = markovChain->Size();
      for (Int_t i = 0; i < size; i++)
         if (markovChain->Weight(i) > maxWeight)
            maxWeight = markovChain->Weight(i);
      fWeightHist = new TH1F("mcmc_weight_hist", "MCMC Weight Histogram",
            (Int_t)(maxWeight + 1), 0, maxWeight * 1.02);
      for (Int_t i = 0; i < size; i++)
         fWeightHist->Fill(markovChain->Weight(i));
   }
   fWeightHist->Draw(options);
}

/*
/////////////////////////////////////////////////////////////////////
  // 3-d plot of the parameter points
  dataCanvas->cd(2);
  // also plot the points in the markov chain
  RooDataSet* markovChainData = ((MCMCInterval*)mcmcint)->GetChainAsDataSet();

  TTree& chain =  ((RooTreeDataStore*) markovChainData->store())->tree();
  chain.SetMarkerStyle(6);
  chain.SetMarkerColor(kRed);
  chain.Draw("s:ratioSigEff:ratioBkgEff","","box"); // 3-d box proporional to posterior

  // the points used in the profile construction
  TTree& parameterScan =  ((RooTreeDataStore*) fc.GetPointsToScan()->store())->tree();
  parameterScan.SetMarkerStyle(24);
  parameterScan.Draw("s:ratioSigEff:ratioBkgEff","","same");

  chain.SetMarkerStyle(6);
  chain.SetMarkerColor(kRed);
  //chain.Draw("s:ratioSigEff:ratioBkgEff", "_MarkovChain_local_nll","box");
  //chain.Draw("_MarkovChain_local_nll");
////////////////////////////////////////////////////////////////////
*/
 MCMCIntervalPlot.cxx:1
 MCMCIntervalPlot.cxx:2
 MCMCIntervalPlot.cxx:3
 MCMCIntervalPlot.cxx:4
 MCMCIntervalPlot.cxx:5
 MCMCIntervalPlot.cxx:6
 MCMCIntervalPlot.cxx:7
 MCMCIntervalPlot.cxx:8
 MCMCIntervalPlot.cxx:9
 MCMCIntervalPlot.cxx:10
 MCMCIntervalPlot.cxx:11
 MCMCIntervalPlot.cxx:12
 MCMCIntervalPlot.cxx:13
 MCMCIntervalPlot.cxx:14
 MCMCIntervalPlot.cxx:15
 MCMCIntervalPlot.cxx:16
 MCMCIntervalPlot.cxx:17
 MCMCIntervalPlot.cxx:18
 MCMCIntervalPlot.cxx:19
 MCMCIntervalPlot.cxx:20
 MCMCIntervalPlot.cxx:21
 MCMCIntervalPlot.cxx:22
 MCMCIntervalPlot.cxx:23
 MCMCIntervalPlot.cxx:24
 MCMCIntervalPlot.cxx:25
 MCMCIntervalPlot.cxx:26
 MCMCIntervalPlot.cxx:27
 MCMCIntervalPlot.cxx:28
 MCMCIntervalPlot.cxx:29
 MCMCIntervalPlot.cxx:30
 MCMCIntervalPlot.cxx:31
 MCMCIntervalPlot.cxx:32
 MCMCIntervalPlot.cxx:33
 MCMCIntervalPlot.cxx:34
 MCMCIntervalPlot.cxx:35
 MCMCIntervalPlot.cxx:36
 MCMCIntervalPlot.cxx:37
 MCMCIntervalPlot.cxx:38
 MCMCIntervalPlot.cxx:39
 MCMCIntervalPlot.cxx:40
 MCMCIntervalPlot.cxx:41
 MCMCIntervalPlot.cxx:42
 MCMCIntervalPlot.cxx:43
 MCMCIntervalPlot.cxx:44
 MCMCIntervalPlot.cxx:45
 MCMCIntervalPlot.cxx:46
 MCMCIntervalPlot.cxx:47
 MCMCIntervalPlot.cxx:48
 MCMCIntervalPlot.cxx:49
 MCMCIntervalPlot.cxx:50
 MCMCIntervalPlot.cxx:51
 MCMCIntervalPlot.cxx:52
 MCMCIntervalPlot.cxx:53
 MCMCIntervalPlot.cxx:54
 MCMCIntervalPlot.cxx:55
 MCMCIntervalPlot.cxx:56
 MCMCIntervalPlot.cxx:57
 MCMCIntervalPlot.cxx:58
 MCMCIntervalPlot.cxx:59
 MCMCIntervalPlot.cxx:60
 MCMCIntervalPlot.cxx:61
 MCMCIntervalPlot.cxx:62
 MCMCIntervalPlot.cxx:63
 MCMCIntervalPlot.cxx:64
 MCMCIntervalPlot.cxx:65
 MCMCIntervalPlot.cxx:66
 MCMCIntervalPlot.cxx:67
 MCMCIntervalPlot.cxx:68
 MCMCIntervalPlot.cxx:69
 MCMCIntervalPlot.cxx:70
 MCMCIntervalPlot.cxx:71
 MCMCIntervalPlot.cxx:72
 MCMCIntervalPlot.cxx:73
 MCMCIntervalPlot.cxx:74
 MCMCIntervalPlot.cxx:75
 MCMCIntervalPlot.cxx:76
 MCMCIntervalPlot.cxx:77
 MCMCIntervalPlot.cxx:78
 MCMCIntervalPlot.cxx:79
 MCMCIntervalPlot.cxx:80
 MCMCIntervalPlot.cxx:81
 MCMCIntervalPlot.cxx:82
 MCMCIntervalPlot.cxx:83
 MCMCIntervalPlot.cxx:84
 MCMCIntervalPlot.cxx:85
 MCMCIntervalPlot.cxx:86
 MCMCIntervalPlot.cxx:87
 MCMCIntervalPlot.cxx:88
 MCMCIntervalPlot.cxx:89
 MCMCIntervalPlot.cxx:90
 MCMCIntervalPlot.cxx:91
 MCMCIntervalPlot.cxx:92
 MCMCIntervalPlot.cxx:93
 MCMCIntervalPlot.cxx:94
 MCMCIntervalPlot.cxx:95
 MCMCIntervalPlot.cxx:96
 MCMCIntervalPlot.cxx:97
 MCMCIntervalPlot.cxx:98
 MCMCIntervalPlot.cxx:99
 MCMCIntervalPlot.cxx:100
 MCMCIntervalPlot.cxx:101
 MCMCIntervalPlot.cxx:102
 MCMCIntervalPlot.cxx:103
 MCMCIntervalPlot.cxx:104
 MCMCIntervalPlot.cxx:105
 MCMCIntervalPlot.cxx:106
 MCMCIntervalPlot.cxx:107
 MCMCIntervalPlot.cxx:108
 MCMCIntervalPlot.cxx:109
 MCMCIntervalPlot.cxx:110
 MCMCIntervalPlot.cxx:111
 MCMCIntervalPlot.cxx:112
 MCMCIntervalPlot.cxx:113
 MCMCIntervalPlot.cxx:114
 MCMCIntervalPlot.cxx:115
 MCMCIntervalPlot.cxx:116
 MCMCIntervalPlot.cxx:117
 MCMCIntervalPlot.cxx:118
 MCMCIntervalPlot.cxx:119
 MCMCIntervalPlot.cxx:120
 MCMCIntervalPlot.cxx:121
 MCMCIntervalPlot.cxx:122
 MCMCIntervalPlot.cxx:123
 MCMCIntervalPlot.cxx:124
 MCMCIntervalPlot.cxx:125
 MCMCIntervalPlot.cxx:126
 MCMCIntervalPlot.cxx:127
 MCMCIntervalPlot.cxx:128
 MCMCIntervalPlot.cxx:129
 MCMCIntervalPlot.cxx:130
 MCMCIntervalPlot.cxx:131
 MCMCIntervalPlot.cxx:132
 MCMCIntervalPlot.cxx:133
 MCMCIntervalPlot.cxx:134
 MCMCIntervalPlot.cxx:135
 MCMCIntervalPlot.cxx:136
 MCMCIntervalPlot.cxx:137
 MCMCIntervalPlot.cxx:138
 MCMCIntervalPlot.cxx:139
 MCMCIntervalPlot.cxx:140
 MCMCIntervalPlot.cxx:141
 MCMCIntervalPlot.cxx:142
 MCMCIntervalPlot.cxx:143
 MCMCIntervalPlot.cxx:144
 MCMCIntervalPlot.cxx:145
 MCMCIntervalPlot.cxx:146
 MCMCIntervalPlot.cxx:147
 MCMCIntervalPlot.cxx:148
 MCMCIntervalPlot.cxx:149
 MCMCIntervalPlot.cxx:150
 MCMCIntervalPlot.cxx:151
 MCMCIntervalPlot.cxx:152
 MCMCIntervalPlot.cxx:153
 MCMCIntervalPlot.cxx:154
 MCMCIntervalPlot.cxx:155
 MCMCIntervalPlot.cxx:156
 MCMCIntervalPlot.cxx:157
 MCMCIntervalPlot.cxx:158
 MCMCIntervalPlot.cxx:159
 MCMCIntervalPlot.cxx:160
 MCMCIntervalPlot.cxx:161
 MCMCIntervalPlot.cxx:162
 MCMCIntervalPlot.cxx:163
 MCMCIntervalPlot.cxx:164
 MCMCIntervalPlot.cxx:165
 MCMCIntervalPlot.cxx:166
 MCMCIntervalPlot.cxx:167
 MCMCIntervalPlot.cxx:168
 MCMCIntervalPlot.cxx:169
 MCMCIntervalPlot.cxx:170
 MCMCIntervalPlot.cxx:171
 MCMCIntervalPlot.cxx:172
 MCMCIntervalPlot.cxx:173
 MCMCIntervalPlot.cxx:174
 MCMCIntervalPlot.cxx:175
 MCMCIntervalPlot.cxx:176
 MCMCIntervalPlot.cxx:177
 MCMCIntervalPlot.cxx:178
 MCMCIntervalPlot.cxx:179
 MCMCIntervalPlot.cxx:180
 MCMCIntervalPlot.cxx:181
 MCMCIntervalPlot.cxx:182
 MCMCIntervalPlot.cxx:183
 MCMCIntervalPlot.cxx:184
 MCMCIntervalPlot.cxx:185
 MCMCIntervalPlot.cxx:186
 MCMCIntervalPlot.cxx:187
 MCMCIntervalPlot.cxx:188
 MCMCIntervalPlot.cxx:189
 MCMCIntervalPlot.cxx:190
 MCMCIntervalPlot.cxx:191
 MCMCIntervalPlot.cxx:192
 MCMCIntervalPlot.cxx:193
 MCMCIntervalPlot.cxx:194
 MCMCIntervalPlot.cxx:195
 MCMCIntervalPlot.cxx:196
 MCMCIntervalPlot.cxx:197
 MCMCIntervalPlot.cxx:198
 MCMCIntervalPlot.cxx:199
 MCMCIntervalPlot.cxx:200
 MCMCIntervalPlot.cxx:201
 MCMCIntervalPlot.cxx:202
 MCMCIntervalPlot.cxx:203
 MCMCIntervalPlot.cxx:204
 MCMCIntervalPlot.cxx:205
 MCMCIntervalPlot.cxx:206
 MCMCIntervalPlot.cxx:207
 MCMCIntervalPlot.cxx:208
 MCMCIntervalPlot.cxx:209
 MCMCIntervalPlot.cxx:210
 MCMCIntervalPlot.cxx:211
 MCMCIntervalPlot.cxx:212
 MCMCIntervalPlot.cxx:213
 MCMCIntervalPlot.cxx:214
 MCMCIntervalPlot.cxx:215
 MCMCIntervalPlot.cxx:216
 MCMCIntervalPlot.cxx:217
 MCMCIntervalPlot.cxx:218
 MCMCIntervalPlot.cxx:219
 MCMCIntervalPlot.cxx:220
 MCMCIntervalPlot.cxx:221
 MCMCIntervalPlot.cxx:222
 MCMCIntervalPlot.cxx:223
 MCMCIntervalPlot.cxx:224
 MCMCIntervalPlot.cxx:225
 MCMCIntervalPlot.cxx:226
 MCMCIntervalPlot.cxx:227
 MCMCIntervalPlot.cxx:228
 MCMCIntervalPlot.cxx:229
 MCMCIntervalPlot.cxx:230
 MCMCIntervalPlot.cxx:231
 MCMCIntervalPlot.cxx:232
 MCMCIntervalPlot.cxx:233
 MCMCIntervalPlot.cxx:234
 MCMCIntervalPlot.cxx:235
 MCMCIntervalPlot.cxx:236
 MCMCIntervalPlot.cxx:237
 MCMCIntervalPlot.cxx:238
 MCMCIntervalPlot.cxx:239
 MCMCIntervalPlot.cxx:240
 MCMCIntervalPlot.cxx:241
 MCMCIntervalPlot.cxx:242
 MCMCIntervalPlot.cxx:243
 MCMCIntervalPlot.cxx:244
 MCMCIntervalPlot.cxx:245
 MCMCIntervalPlot.cxx:246
 MCMCIntervalPlot.cxx:247
 MCMCIntervalPlot.cxx:248
 MCMCIntervalPlot.cxx:249
 MCMCIntervalPlot.cxx:250
 MCMCIntervalPlot.cxx:251
 MCMCIntervalPlot.cxx:252
 MCMCIntervalPlot.cxx:253
 MCMCIntervalPlot.cxx:254
 MCMCIntervalPlot.cxx:255
 MCMCIntervalPlot.cxx:256
 MCMCIntervalPlot.cxx:257
 MCMCIntervalPlot.cxx:258
 MCMCIntervalPlot.cxx:259
 MCMCIntervalPlot.cxx:260
 MCMCIntervalPlot.cxx:261
 MCMCIntervalPlot.cxx:262
 MCMCIntervalPlot.cxx:263
 MCMCIntervalPlot.cxx:264
 MCMCIntervalPlot.cxx:265
 MCMCIntervalPlot.cxx:266
 MCMCIntervalPlot.cxx:267
 MCMCIntervalPlot.cxx:268
 MCMCIntervalPlot.cxx:269
 MCMCIntervalPlot.cxx:270
 MCMCIntervalPlot.cxx:271
 MCMCIntervalPlot.cxx:272
 MCMCIntervalPlot.cxx:273
 MCMCIntervalPlot.cxx:274
 MCMCIntervalPlot.cxx:275
 MCMCIntervalPlot.cxx:276
 MCMCIntervalPlot.cxx:277
 MCMCIntervalPlot.cxx:278
 MCMCIntervalPlot.cxx:279
 MCMCIntervalPlot.cxx:280
 MCMCIntervalPlot.cxx:281
 MCMCIntervalPlot.cxx:282
 MCMCIntervalPlot.cxx:283
 MCMCIntervalPlot.cxx:284
 MCMCIntervalPlot.cxx:285
 MCMCIntervalPlot.cxx:286
 MCMCIntervalPlot.cxx:287
 MCMCIntervalPlot.cxx:288
 MCMCIntervalPlot.cxx:289
 MCMCIntervalPlot.cxx:290
 MCMCIntervalPlot.cxx:291
 MCMCIntervalPlot.cxx:292
 MCMCIntervalPlot.cxx:293
 MCMCIntervalPlot.cxx:294
 MCMCIntervalPlot.cxx:295
 MCMCIntervalPlot.cxx:296
 MCMCIntervalPlot.cxx:297
 MCMCIntervalPlot.cxx:298
 MCMCIntervalPlot.cxx:299
 MCMCIntervalPlot.cxx:300
 MCMCIntervalPlot.cxx:301
 MCMCIntervalPlot.cxx:302
 MCMCIntervalPlot.cxx:303
 MCMCIntervalPlot.cxx:304
 MCMCIntervalPlot.cxx:305
 MCMCIntervalPlot.cxx:306
 MCMCIntervalPlot.cxx:307
 MCMCIntervalPlot.cxx:308
 MCMCIntervalPlot.cxx:309
 MCMCIntervalPlot.cxx:310
 MCMCIntervalPlot.cxx:311
 MCMCIntervalPlot.cxx:312
 MCMCIntervalPlot.cxx:313
 MCMCIntervalPlot.cxx:314
 MCMCIntervalPlot.cxx:315
 MCMCIntervalPlot.cxx:316
 MCMCIntervalPlot.cxx:317
 MCMCIntervalPlot.cxx:318
 MCMCIntervalPlot.cxx:319
 MCMCIntervalPlot.cxx:320
 MCMCIntervalPlot.cxx:321
 MCMCIntervalPlot.cxx:322
 MCMCIntervalPlot.cxx:323
 MCMCIntervalPlot.cxx:324
 MCMCIntervalPlot.cxx:325
 MCMCIntervalPlot.cxx:326
 MCMCIntervalPlot.cxx:327
 MCMCIntervalPlot.cxx:328
 MCMCIntervalPlot.cxx:329
 MCMCIntervalPlot.cxx:330
 MCMCIntervalPlot.cxx:331
 MCMCIntervalPlot.cxx:332
 MCMCIntervalPlot.cxx:333
 MCMCIntervalPlot.cxx:334
 MCMCIntervalPlot.cxx:335
 MCMCIntervalPlot.cxx:336
 MCMCIntervalPlot.cxx:337
 MCMCIntervalPlot.cxx:338
 MCMCIntervalPlot.cxx:339
 MCMCIntervalPlot.cxx:340
 MCMCIntervalPlot.cxx:341
 MCMCIntervalPlot.cxx:342
 MCMCIntervalPlot.cxx:343
 MCMCIntervalPlot.cxx:344
 MCMCIntervalPlot.cxx:345
 MCMCIntervalPlot.cxx:346
 MCMCIntervalPlot.cxx:347
 MCMCIntervalPlot.cxx:348
 MCMCIntervalPlot.cxx:349
 MCMCIntervalPlot.cxx:350
 MCMCIntervalPlot.cxx:351
 MCMCIntervalPlot.cxx:352
 MCMCIntervalPlot.cxx:353
 MCMCIntervalPlot.cxx:354
 MCMCIntervalPlot.cxx:355
 MCMCIntervalPlot.cxx:356
 MCMCIntervalPlot.cxx:357
 MCMCIntervalPlot.cxx:358
 MCMCIntervalPlot.cxx:359
 MCMCIntervalPlot.cxx:360
 MCMCIntervalPlot.cxx:361
 MCMCIntervalPlot.cxx:362
 MCMCIntervalPlot.cxx:363
 MCMCIntervalPlot.cxx:364
 MCMCIntervalPlot.cxx:365
 MCMCIntervalPlot.cxx:366
 MCMCIntervalPlot.cxx:367
 MCMCIntervalPlot.cxx:368
 MCMCIntervalPlot.cxx:369
 MCMCIntervalPlot.cxx:370
 MCMCIntervalPlot.cxx:371
 MCMCIntervalPlot.cxx:372
 MCMCIntervalPlot.cxx:373
 MCMCIntervalPlot.cxx:374
 MCMCIntervalPlot.cxx:375
 MCMCIntervalPlot.cxx:376
 MCMCIntervalPlot.cxx:377
 MCMCIntervalPlot.cxx:378
 MCMCIntervalPlot.cxx:379
 MCMCIntervalPlot.cxx:380
 MCMCIntervalPlot.cxx:381
 MCMCIntervalPlot.cxx:382
 MCMCIntervalPlot.cxx:383
 MCMCIntervalPlot.cxx:384
 MCMCIntervalPlot.cxx:385
 MCMCIntervalPlot.cxx:386
 MCMCIntervalPlot.cxx:387
 MCMCIntervalPlot.cxx:388
 MCMCIntervalPlot.cxx:389
 MCMCIntervalPlot.cxx:390
 MCMCIntervalPlot.cxx:391
 MCMCIntervalPlot.cxx:392
 MCMCIntervalPlot.cxx:393
 MCMCIntervalPlot.cxx:394
 MCMCIntervalPlot.cxx:395
 MCMCIntervalPlot.cxx:396
 MCMCIntervalPlot.cxx:397
 MCMCIntervalPlot.cxx:398
 MCMCIntervalPlot.cxx:399
 MCMCIntervalPlot.cxx:400
 MCMCIntervalPlot.cxx:401
 MCMCIntervalPlot.cxx:402
 MCMCIntervalPlot.cxx:403
 MCMCIntervalPlot.cxx:404
 MCMCIntervalPlot.cxx:405
 MCMCIntervalPlot.cxx:406
 MCMCIntervalPlot.cxx:407
 MCMCIntervalPlot.cxx:408
 MCMCIntervalPlot.cxx:409
 MCMCIntervalPlot.cxx:410
 MCMCIntervalPlot.cxx:411
 MCMCIntervalPlot.cxx:412
 MCMCIntervalPlot.cxx:413
 MCMCIntervalPlot.cxx:414
 MCMCIntervalPlot.cxx:415
 MCMCIntervalPlot.cxx:416
 MCMCIntervalPlot.cxx:417
 MCMCIntervalPlot.cxx:418
 MCMCIntervalPlot.cxx:419
 MCMCIntervalPlot.cxx:420
 MCMCIntervalPlot.cxx:421
 MCMCIntervalPlot.cxx:422
 MCMCIntervalPlot.cxx:423
 MCMCIntervalPlot.cxx:424
 MCMCIntervalPlot.cxx:425
 MCMCIntervalPlot.cxx:426
 MCMCIntervalPlot.cxx:427
 MCMCIntervalPlot.cxx:428
 MCMCIntervalPlot.cxx:429
 MCMCIntervalPlot.cxx:430
 MCMCIntervalPlot.cxx:431
 MCMCIntervalPlot.cxx:432
 MCMCIntervalPlot.cxx:433
 MCMCIntervalPlot.cxx:434
 MCMCIntervalPlot.cxx:435
 MCMCIntervalPlot.cxx:436
 MCMCIntervalPlot.cxx:437
 MCMCIntervalPlot.cxx:438
 MCMCIntervalPlot.cxx:439
 MCMCIntervalPlot.cxx:440
 MCMCIntervalPlot.cxx:441
 MCMCIntervalPlot.cxx:442
 MCMCIntervalPlot.cxx:443
 MCMCIntervalPlot.cxx:444
 MCMCIntervalPlot.cxx:445
 MCMCIntervalPlot.cxx:446
 MCMCIntervalPlot.cxx:447
 MCMCIntervalPlot.cxx:448
 MCMCIntervalPlot.cxx:449
 MCMCIntervalPlot.cxx:450
 MCMCIntervalPlot.cxx:451
 MCMCIntervalPlot.cxx:452
 MCMCIntervalPlot.cxx:453
 MCMCIntervalPlot.cxx:454
 MCMCIntervalPlot.cxx:455
 MCMCIntervalPlot.cxx:456
 MCMCIntervalPlot.cxx:457
 MCMCIntervalPlot.cxx:458
 MCMCIntervalPlot.cxx:459
 MCMCIntervalPlot.cxx:460
 MCMCIntervalPlot.cxx:461
 MCMCIntervalPlot.cxx:462
 MCMCIntervalPlot.cxx:463
 MCMCIntervalPlot.cxx:464
 MCMCIntervalPlot.cxx:465
 MCMCIntervalPlot.cxx:466
 MCMCIntervalPlot.cxx:467
 MCMCIntervalPlot.cxx:468
 MCMCIntervalPlot.cxx:469
 MCMCIntervalPlot.cxx:470
 MCMCIntervalPlot.cxx:471
 MCMCIntervalPlot.cxx:472
 MCMCIntervalPlot.cxx:473
 MCMCIntervalPlot.cxx:474
 MCMCIntervalPlot.cxx:475
 MCMCIntervalPlot.cxx:476
 MCMCIntervalPlot.cxx:477
 MCMCIntervalPlot.cxx:478
 MCMCIntervalPlot.cxx:479
 MCMCIntervalPlot.cxx:480
 MCMCIntervalPlot.cxx:481
 MCMCIntervalPlot.cxx:482
 MCMCIntervalPlot.cxx:483
 MCMCIntervalPlot.cxx:484
 MCMCIntervalPlot.cxx:485
 MCMCIntervalPlot.cxx:486
 MCMCIntervalPlot.cxx:487
 MCMCIntervalPlot.cxx:488
 MCMCIntervalPlot.cxx:489
 MCMCIntervalPlot.cxx:490
 MCMCIntervalPlot.cxx:491
 MCMCIntervalPlot.cxx:492
 MCMCIntervalPlot.cxx:493
 MCMCIntervalPlot.cxx:494
 MCMCIntervalPlot.cxx:495
 MCMCIntervalPlot.cxx:496
 MCMCIntervalPlot.cxx:497
 MCMCIntervalPlot.cxx:498
 MCMCIntervalPlot.cxx:499
 MCMCIntervalPlot.cxx:500
 MCMCIntervalPlot.cxx:501
 MCMCIntervalPlot.cxx:502
 MCMCIntervalPlot.cxx:503
 MCMCIntervalPlot.cxx:504
 MCMCIntervalPlot.cxx:505
 MCMCIntervalPlot.cxx:506
 MCMCIntervalPlot.cxx:507
 MCMCIntervalPlot.cxx:508
 MCMCIntervalPlot.cxx:509
 MCMCIntervalPlot.cxx:510
 MCMCIntervalPlot.cxx:511
 MCMCIntervalPlot.cxx:512
 MCMCIntervalPlot.cxx:513
 MCMCIntervalPlot.cxx:514
 MCMCIntervalPlot.cxx:515
 MCMCIntervalPlot.cxx:516
 MCMCIntervalPlot.cxx:517
 MCMCIntervalPlot.cxx:518
 MCMCIntervalPlot.cxx:519
 MCMCIntervalPlot.cxx:520
 MCMCIntervalPlot.cxx:521
 MCMCIntervalPlot.cxx:522
 MCMCIntervalPlot.cxx:523
 MCMCIntervalPlot.cxx:524
 MCMCIntervalPlot.cxx:525
 MCMCIntervalPlot.cxx:526
 MCMCIntervalPlot.cxx:527
 MCMCIntervalPlot.cxx:528
 MCMCIntervalPlot.cxx:529
 MCMCIntervalPlot.cxx:530
 MCMCIntervalPlot.cxx:531
 MCMCIntervalPlot.cxx:532
 MCMCIntervalPlot.cxx:533
 MCMCIntervalPlot.cxx:534
 MCMCIntervalPlot.cxx:535
 MCMCIntervalPlot.cxx:536
 MCMCIntervalPlot.cxx:537
 MCMCIntervalPlot.cxx:538
 MCMCIntervalPlot.cxx:539
 MCMCIntervalPlot.cxx:540
 MCMCIntervalPlot.cxx:541
 MCMCIntervalPlot.cxx:542
 MCMCIntervalPlot.cxx:543
 MCMCIntervalPlot.cxx:544
 MCMCIntervalPlot.cxx:545
 MCMCIntervalPlot.cxx:546
 MCMCIntervalPlot.cxx:547
 MCMCIntervalPlot.cxx:548
 MCMCIntervalPlot.cxx:549
 MCMCIntervalPlot.cxx:550
 MCMCIntervalPlot.cxx:551
 MCMCIntervalPlot.cxx:552
 MCMCIntervalPlot.cxx:553
 MCMCIntervalPlot.cxx:554
 MCMCIntervalPlot.cxx:555
 MCMCIntervalPlot.cxx:556
 MCMCIntervalPlot.cxx:557
 MCMCIntervalPlot.cxx:558
 MCMCIntervalPlot.cxx:559
 MCMCIntervalPlot.cxx:560
 MCMCIntervalPlot.cxx:561
 MCMCIntervalPlot.cxx:562
 MCMCIntervalPlot.cxx:563
 MCMCIntervalPlot.cxx:564
 MCMCIntervalPlot.cxx:565
 MCMCIntervalPlot.cxx:566
 MCMCIntervalPlot.cxx:567
 MCMCIntervalPlot.cxx:568
 MCMCIntervalPlot.cxx:569
 MCMCIntervalPlot.cxx:570
 MCMCIntervalPlot.cxx:571
 MCMCIntervalPlot.cxx:572
 MCMCIntervalPlot.cxx:573
 MCMCIntervalPlot.cxx:574
 MCMCIntervalPlot.cxx:575
 MCMCIntervalPlot.cxx:576
 MCMCIntervalPlot.cxx:577
 MCMCIntervalPlot.cxx:578
 MCMCIntervalPlot.cxx:579
 MCMCIntervalPlot.cxx:580
 MCMCIntervalPlot.cxx:581
 MCMCIntervalPlot.cxx:582
 MCMCIntervalPlot.cxx:583
 MCMCIntervalPlot.cxx:584
 MCMCIntervalPlot.cxx:585
 MCMCIntervalPlot.cxx:586
 MCMCIntervalPlot.cxx:587
 MCMCIntervalPlot.cxx:588
 MCMCIntervalPlot.cxx:589
 MCMCIntervalPlot.cxx:590
 MCMCIntervalPlot.cxx:591
 MCMCIntervalPlot.cxx:592
 MCMCIntervalPlot.cxx:593
 MCMCIntervalPlot.cxx:594
 MCMCIntervalPlot.cxx:595
 MCMCIntervalPlot.cxx:596
 MCMCIntervalPlot.cxx:597
 MCMCIntervalPlot.cxx:598
 MCMCIntervalPlot.cxx:599
 MCMCIntervalPlot.cxx:600
 MCMCIntervalPlot.cxx:601
 MCMCIntervalPlot.cxx:602
 MCMCIntervalPlot.cxx:603
 MCMCIntervalPlot.cxx:604
 MCMCIntervalPlot.cxx:605
 MCMCIntervalPlot.cxx:606
 MCMCIntervalPlot.cxx:607
 MCMCIntervalPlot.cxx:608
 MCMCIntervalPlot.cxx:609
 MCMCIntervalPlot.cxx:610
 MCMCIntervalPlot.cxx:611
 MCMCIntervalPlot.cxx:612
 MCMCIntervalPlot.cxx:613
 MCMCIntervalPlot.cxx:614
 MCMCIntervalPlot.cxx:615
 MCMCIntervalPlot.cxx:616
 MCMCIntervalPlot.cxx:617
 MCMCIntervalPlot.cxx:618
 MCMCIntervalPlot.cxx:619
 MCMCIntervalPlot.cxx:620
 MCMCIntervalPlot.cxx:621
 MCMCIntervalPlot.cxx:622
 MCMCIntervalPlot.cxx:623
 MCMCIntervalPlot.cxx:624
 MCMCIntervalPlot.cxx:625
 MCMCIntervalPlot.cxx:626
 MCMCIntervalPlot.cxx:627
 MCMCIntervalPlot.cxx:628
 MCMCIntervalPlot.cxx:629
 MCMCIntervalPlot.cxx:630
 MCMCIntervalPlot.cxx:631
 MCMCIntervalPlot.cxx:632
 MCMCIntervalPlot.cxx:633
 MCMCIntervalPlot.cxx:634
 MCMCIntervalPlot.cxx:635
 MCMCIntervalPlot.cxx:636
 MCMCIntervalPlot.cxx:637
 MCMCIntervalPlot.cxx:638
 MCMCIntervalPlot.cxx:639
 MCMCIntervalPlot.cxx:640
 MCMCIntervalPlot.cxx:641
 MCMCIntervalPlot.cxx:642
 MCMCIntervalPlot.cxx:643
 MCMCIntervalPlot.cxx:644
 MCMCIntervalPlot.cxx:645
 MCMCIntervalPlot.cxx:646
 MCMCIntervalPlot.cxx:647
 MCMCIntervalPlot.cxx:648
 MCMCIntervalPlot.cxx:649
 MCMCIntervalPlot.cxx:650
 MCMCIntervalPlot.cxx:651
 MCMCIntervalPlot.cxx:652
 MCMCIntervalPlot.cxx:653
 MCMCIntervalPlot.cxx:654
 MCMCIntervalPlot.cxx:655
 MCMCIntervalPlot.cxx:656
 MCMCIntervalPlot.cxx:657
 MCMCIntervalPlot.cxx:658
 MCMCIntervalPlot.cxx:659
 MCMCIntervalPlot.cxx:660
 MCMCIntervalPlot.cxx:661
 MCMCIntervalPlot.cxx:662
 MCMCIntervalPlot.cxx:663
 MCMCIntervalPlot.cxx:664
 MCMCIntervalPlot.cxx:665
 MCMCIntervalPlot.cxx:666
 MCMCIntervalPlot.cxx:667
 MCMCIntervalPlot.cxx:668
 MCMCIntervalPlot.cxx:669
 MCMCIntervalPlot.cxx:670
 MCMCIntervalPlot.cxx:671
 MCMCIntervalPlot.cxx:672
 MCMCIntervalPlot.cxx:673
 MCMCIntervalPlot.cxx:674
 MCMCIntervalPlot.cxx:675
 MCMCIntervalPlot.cxx:676
 MCMCIntervalPlot.cxx:677
 MCMCIntervalPlot.cxx:678
 MCMCIntervalPlot.cxx:679
 MCMCIntervalPlot.cxx:680
 MCMCIntervalPlot.cxx:681
 MCMCIntervalPlot.cxx:682
 MCMCIntervalPlot.cxx:683
 MCMCIntervalPlot.cxx:684
 MCMCIntervalPlot.cxx:685
 MCMCIntervalPlot.cxx:686
 MCMCIntervalPlot.cxx:687
 MCMCIntervalPlot.cxx:688
 MCMCIntervalPlot.cxx:689
 MCMCIntervalPlot.cxx:690
 MCMCIntervalPlot.cxx:691
 MCMCIntervalPlot.cxx:692
 MCMCIntervalPlot.cxx:693
 MCMCIntervalPlot.cxx:694
 MCMCIntervalPlot.cxx:695
 MCMCIntervalPlot.cxx:696
 MCMCIntervalPlot.cxx:697
 MCMCIntervalPlot.cxx:698
 MCMCIntervalPlot.cxx:699
 MCMCIntervalPlot.cxx:700
 MCMCIntervalPlot.cxx:701
 MCMCIntervalPlot.cxx:702
 MCMCIntervalPlot.cxx:703
 MCMCIntervalPlot.cxx:704
 MCMCIntervalPlot.cxx:705
 MCMCIntervalPlot.cxx:706
 MCMCIntervalPlot.cxx:707
 MCMCIntervalPlot.cxx:708
 MCMCIntervalPlot.cxx:709
 MCMCIntervalPlot.cxx:710
 MCMCIntervalPlot.cxx:711
 MCMCIntervalPlot.cxx:712
 MCMCIntervalPlot.cxx:713
 MCMCIntervalPlot.cxx:714
 MCMCIntervalPlot.cxx:715
 MCMCIntervalPlot.cxx:716
 MCMCIntervalPlot.cxx:717
 MCMCIntervalPlot.cxx:718
 MCMCIntervalPlot.cxx:719
 MCMCIntervalPlot.cxx:720
 MCMCIntervalPlot.cxx:721
 MCMCIntervalPlot.cxx:722
 MCMCIntervalPlot.cxx:723
 MCMCIntervalPlot.cxx:724
 MCMCIntervalPlot.cxx:725
 MCMCIntervalPlot.cxx:726
 MCMCIntervalPlot.cxx:727
 MCMCIntervalPlot.cxx:728
 MCMCIntervalPlot.cxx:729
 MCMCIntervalPlot.cxx:730
 MCMCIntervalPlot.cxx:731
 MCMCIntervalPlot.cxx:732
 MCMCIntervalPlot.cxx:733
 MCMCIntervalPlot.cxx:734
 MCMCIntervalPlot.cxx:735
 MCMCIntervalPlot.cxx:736
 MCMCIntervalPlot.cxx:737
 MCMCIntervalPlot.cxx:738
 MCMCIntervalPlot.cxx:739
 MCMCIntervalPlot.cxx:740
 MCMCIntervalPlot.cxx:741
 MCMCIntervalPlot.cxx:742
 MCMCIntervalPlot.cxx:743
 MCMCIntervalPlot.cxx:744
 MCMCIntervalPlot.cxx:745
 MCMCIntervalPlot.cxx:746
 MCMCIntervalPlot.cxx:747
 MCMCIntervalPlot.cxx:748
 MCMCIntervalPlot.cxx:749
 MCMCIntervalPlot.cxx:750
 MCMCIntervalPlot.cxx:751
 MCMCIntervalPlot.cxx:752
 MCMCIntervalPlot.cxx:753
 MCMCIntervalPlot.cxx:754
 MCMCIntervalPlot.cxx:755
 MCMCIntervalPlot.cxx:756
 MCMCIntervalPlot.cxx:757
 MCMCIntervalPlot.cxx:758
 MCMCIntervalPlot.cxx:759
 MCMCIntervalPlot.cxx:760
 MCMCIntervalPlot.cxx:761
 MCMCIntervalPlot.cxx:762
 MCMCIntervalPlot.cxx:763
 MCMCIntervalPlot.cxx:764
 MCMCIntervalPlot.cxx:765
 MCMCIntervalPlot.cxx:766
 MCMCIntervalPlot.cxx:767
 MCMCIntervalPlot.cxx:768
 MCMCIntervalPlot.cxx:769
 MCMCIntervalPlot.cxx:770
 MCMCIntervalPlot.cxx:771
 MCMCIntervalPlot.cxx:772
 MCMCIntervalPlot.cxx:773
 MCMCIntervalPlot.cxx:774
 MCMCIntervalPlot.cxx:775
 MCMCIntervalPlot.cxx:776
 MCMCIntervalPlot.cxx:777
 MCMCIntervalPlot.cxx:778
 MCMCIntervalPlot.cxx:779
 MCMCIntervalPlot.cxx:780
 MCMCIntervalPlot.cxx:781
 MCMCIntervalPlot.cxx:782
 MCMCIntervalPlot.cxx:783
 MCMCIntervalPlot.cxx:784
 MCMCIntervalPlot.cxx:785
 MCMCIntervalPlot.cxx:786
 MCMCIntervalPlot.cxx:787
 MCMCIntervalPlot.cxx:788
 MCMCIntervalPlot.cxx:789
 MCMCIntervalPlot.cxx:790
 MCMCIntervalPlot.cxx:791
 MCMCIntervalPlot.cxx:792
 MCMCIntervalPlot.cxx:793
 MCMCIntervalPlot.cxx:794
 MCMCIntervalPlot.cxx:795
 MCMCIntervalPlot.cxx:796
 MCMCIntervalPlot.cxx:797
 MCMCIntervalPlot.cxx:798
 MCMCIntervalPlot.cxx:799
 MCMCIntervalPlot.cxx:800
 MCMCIntervalPlot.cxx:801
 MCMCIntervalPlot.cxx:802
 MCMCIntervalPlot.cxx:803
 MCMCIntervalPlot.cxx:804
 MCMCIntervalPlot.cxx:805
 MCMCIntervalPlot.cxx:806