void BayesUnfoldingExample641()
{
#ifdef __CINT__ // Avoid CINT badness
Printf("Please compile this script (root BayesUnfoldingExample641.C+) "
"or use ROOT 6.");
gSystem->Exit(0);
#endif
if (!gROOT->IsBatch())
{
Printf("Several canvases coming...adding -b flag.");
gROOT->SetBatch();
}
gStyle->SetOptStat(0);
gStyle->SetPaintTextFormat(".2f");
if (gSystem->Getenv("TMPDIR"))
gSystem->SetBuildDir(gSystem->Getenv("TMPDIR"));
TRandom3 ran;
TStopwatch watch; // Watch starts here. A call to Start() would reset it.
TObjArray *cList = new TObjArray(); // List of drawn canvases --> PDF file
// Set up the problem
double bins[Nt+1] = {0};
for (int j=0; j<=Nt; j++)
bins[j] = 500*TMath::Exp(0.15*j);
TestProblem testprob = AtlasDiJetMass(Nt, Nr, bins, bins,
apar, bpar, nevts, evtWeight);
TH2D *hM = testprob.Response;
TH1D *hT = testprob.xTruth;
TH1D *hTmc = testprob.xTruthEst;
TH1D *hMt = testprob.xIni;
TH1D *hD = testprob.bNoisy;
TH1D *heff = testprob.eff;
SetHistProps(hT,kRed+2,kNone,kRed+2);
SetHistProps(hTmc,kRed,kNone,kRed);
SetHistProps(hD,kBlack,kNone,kBlack,kFullCircle,1.5);
TMatrixD M = MatrixUtils::Hist2Matrix(hM);
TVectorD T = MatrixUtils::Hist2Vec(hT); // \hat{T}
TVectorD Tmc = MatrixUtils::Hist2Vec(hTmc); // \tilde{T}
TVectorD D = MatrixUtils::Hist2Vec(hD);
TVectorD eff = MatrixUtils::Hist2Vec(heff);
TVectorD Pt = MatrixUtils::ElemDiv(MatrixUtils::Hist2Vec(hMt), eff); // P(t)
TMatrixD Prt = MatrixUtils::DivRowsByVector(M, Pt); // P(r|t)
// Compute initial sampling volume and do MCMC sampling
TGraphAsymmErrors *box = HyperBox(hTmc);
SetGraphProps(box, kGreen+2, kNone, kSpring, kFullSquare, 1.0);
// Likelihood functor
LogPoissonLikeFn llfunc(Prt, D);
// Curvature regularization.
// Note that this is not directly penalizing curvature of the solution.
// Instead it smooths the solution divided by the trial spectrum.
std::vector<double> regpars;
regpars.push_back(alpha); // Regularization strength
for (int i=0; i<box->GetN(); i++)
regpars.push_back(box->GetY()[i]);
CurvatureRegFn regfunc(regpars);
TTree *tmcmc = SampleMH(nMcmcSamples, 1e4, 0.01, box, llfunc, regfunc);
// Create marginal prob. distributions from MCMC
std::cout << Form("Marginalizing parameters from Markov chain...")
<< std::flush;
TH1D *hMCMC[Nt];
for (int t=0; t<Nt; t++)
{
double tlo = box->GetY()[t] - box->GetEYlow()[t];
double thi = box->GetY()[t] + box->GetEYhigh()[t];
hMCMC[t] = new TH1D(Form("hMCMC%d",t),"",nMcmcBins, tlo, thi);
hMCMC[t]->SetTitle(Form("MCMC - point %d;"
"entries;"
"Marginal posterior probability",t));
// Marginalize with unit weight when using MCMC, weight by
// likelihood if sampling was uniform.
tmcmc->Draw(Form("T%d >> hMCMC%d",t,t), "", "goff");
hMCMC[t]->Scale(1./hMCMC[t]->Integral(1, nMcmcBins));
SetHistProps(hMCMC[t], kBlack, kYellow, kBlack, kFullCircle, 1.0);
hMCMC[t]->GetYaxis()->SetTitleOffset(1.5);
}
Printf("Done marginalizing MCMC.");
// Now compute reduced sampling volume, and do uniform sampling
TGraphAsymmErrors *rbox = ReducedSamplingVolume(hMCMC, box);
SetGraphProps(rbox, kBlack, kNone, kNone, kFullSquare, 1.0);
TH1D *hFlat[Nt];
if (doUniformSampling)
{
TTree *tflat = SampleUniform(nFlatSamples, D, Prt, rbox);
std::cout << Form("Marginalizing parameters from uniform volume...")
<< std::flush;
for (int t=0; t<Nt; t++)
{
double tlo = rbox->GetY()[t] - rbox->GetEYlow()[t];
double thi = rbox->GetY()[t] + rbox->GetEYhigh()[t];
hFlat[t] = new TH1D(Form("hFlat%d",t),"",nFlatBins, tlo, thi);
hFlat[t]->SetTitle(Form("Uniform sampling - point %d;"
"dijet mass (GeV/c^{2});"
"Marginal posterior probability",t));
tflat->Draw(Form("T%d >> hFlat%d",t,t), "L", "goff");
hFlat[t]->Scale(1./hFlat[t]->Integral(1,nFlatBins));
SetHistProps(hFlat[t], kBlack, kOrange, kBlack, kFullCircle, 1.0);
}
Printf("Done marginalizing uniform volume.");
}
// Unfolded spectrum from MCMC
TGraphErrors *unf1 = new TGraphErrors();
SetGraphProps(unf1, kBlue, kNone, kBlue, kOpenSquare, 1.5);
unf1->SetLineWidth(2);
for (int t=0; t<Nt; t++)
{
MaxDensityInterval mdi = GetMDI(hMCMC[t], 0.68);
unf1->SetPoint(t, hD->GetBinCenter(t+1), mdi.u);
unf1->SetPointError(t, 0.48*hD->GetBinWidth(t+1), mdi.du);
}
// Unfolded spectrum from uniform sampling after volume reduction
TGraphErrors *unf2 = 0;
if (doUniformSampling)
{
unf2 = new TGraphErrors();
SetGraphProps(unf2, kRed, kNone, kRed, kOpenSquare, 1.5);
unf2->SetLineWidth(2);
for (int t=0; t<Nt; t++)
{
MaxDensityInterval mdi = GetMDI(hFlat[t], 0.68);
unf2->SetPoint(t, hD->GetBinCenter(t+1), mdi.u);
unf2->SetPointError(t, 0.47*hD->GetBinWidth(t+1), mdi.du);
}
}
Printf("Drawing results...");
DrawObject(hM, "colz", "matrix", cList, 550, 500);
gPad->SetLogx(); gPad->SetLogy(); gPad->SetLogz();
gPad->SetRightMargin(0.15);
DrawObject(heff, "", "efficiency", cList);
// Draw marginal dists. from MCMC
for (int t=0; t<Nt; t++)
{
DrawObject(hMCMC[t], "", Form("post_%d", t), cList);
gPad->SetLeftMargin(0.15);
if (doUniformSampling)
{
hFlat[t]->Scale(1./hFlat[t]->Integral(1, nFlatBins,"width"));
hFlat[t]->Draw("same");
}
double ymin = hMCMC[t]->GetMinimum();
double ymax = hMCMC[t]->GetMaximum();
double yDraw = 0.25*(ymax-ymin);
DataPoint(hD, hMCMC[t], t, 0.75*yDraw)->Draw("ep same");
TruePoint(hT, hMCMC[t], t, yDraw)->Draw("p same");
MD68Point(hMCMC[t], yDraw)->Draw("ep same");
}
// Result!
hT->GetYaxis()->SetRangeUser(0.002, 101*nevts*evtWeight);
DrawObject(hT, "ep", "result", cList);
gPad->SetLogy();
box->Draw("e5 same");
if (doUniformSampling || drawReducedVolume)
rbox->Draw("e5 same");
hT->Draw("same");
hD->Draw("ep same");
unf1->Draw("ep same");
if (unf2)
unf2->Draw("ep same");
if (printPDFs)
{
PrintPDFs(cList, "pdfs"); // Print individuals into ./pdfs dir
PrintPDF(cList, "pdfs/mcmc_unfold_example"); // Multipage PDF
}
Printf("All done.");
watch.Stop();
watch.Print();
return;
}
void snv_register_printf_funcs (register_callback_function *regfunc)
{
spec_entry *ent = regfunc ('P', printf_generic, NULL);
ent->type = PA_STRING;
ent->user = pig_latin;
}
int vm(Pu *L)
{
int ret = 0;
for (;;)
{
PuType tp = TOKEN.type;
if (tp == FINISH)
{
ret = 0;
break;
}
if (L->isyield)
{
ret = -2;
break;
}
if (L->isquit)
{
ret = -1;
break;
}
switch (tp)
{
case WHILE:
whilet(L, &TOKEN);
break;
case IF:
ift(L, &TOKEN);
break;
case OP:
procop(L);
break;
case GOTO:
gotot(L);
break;
case FUNCTION:
regfunc(L);
break;
case RETURN:{
NEXT_TOKEN;
L->isreturn = true;
const __pu_value *expresult = exp(L);
if (!expresult || expresult->type() == UNKNOWN)
{
QUIT_SCRIPT;
break;
}
L->return_value = *expresult;
ret = 1;
goto END_VM;}
case INCLUDE:
NEXT_TOKEN;
NEXT_TOKEN;
break;
case ELSE:
case ELIF:
case BREAK:
case CONTINUE:
case END:
ret = 1;
goto END_VM;
default:
exp(L);
break;
}
}
END_VM:
DO_GC;
return ret;
}
