void BuildAPdf() {
// Build the pdf
AxisCollection ax;
ax.AddAxis(PdfAxis("energy", 0, 3, 100));
ax.AddAxis(PdfAxis("radius", 0, 1, 100));
ax.AddAxis(PdfAxis("psd", 0, 1, 100));
ax.AddAxis(PdfAxis("psd2", 0, 1, 100));
BinnedPdf pdf(ax);
std::vector<size_t> indicies;
indicies.push_back(0);
indicies.push_back(1);
indicies.push_back(2);
indicies.push_back(3);
pdf.SetDataRep(DataRepresentation(indicies));
// Get the data
ROOTHandle rHandle(fileName, treeName);
unsigned nEntries = rHandle.GetNEntries();
std::cout << nEntries << " Entries to fill" << std::endl;
// Fill the Pdf
for(size_t i = 0; i < nEntries; i++) {
pdf.Fill(rHandle.GetEntry(i));
}
return;
}
#include <catch.hpp>
#include <PdfMapping.h>
#include <BinnedPdf.h>
TEST_CASE("Check Initialisation of 3x3 -> 3x3"){
AxisCollection ax;
ax.AddAxis(PdfAxis("axis 1", 2.3, 4.5, 90));
ax.AddAxis(PdfAxis("axis 2", 1.3, 4.7, 11));
PdfMapping map;
REQUIRE(map.GetNBins() == 0);
map.SetAxes(ax);
REQUIRE(map.GetNBins() == 90 * 11);
std::vector<double> initalVals;
for(size_t i = 0; i < map.GetNBins(); i++)
for(size_t j = 0; j < map.GetNBins(); j++)
initalVals.push_back(map.GetComponent(i, j));
// should all be initialised to zero
REQUIRE(initalVals == std::vector<double>((90*11) * (90 * 11), 0));
}
TEST_CASE("Identity Matrix Multiplication on 100 long vector"){
AxisCollection axes;
axes.AddAxis(PdfAxis("", 0, 100, 100));
BinnedPdf binnedPdf(axes);
for(size_t i = 0; i < 100; i++)
#include <catch.hpp>
#include <FakePdfGenerator.h>
#include <Gaussian.h>
#include <PdfConverter.h>
#include <cmath>
TEST_CASE("Recover a 1D gaussian"){
Gaussian gaus(0, 10);
AxisCollection axes;
axes.AddAxis(PdfAxis("test", -100, 100, 200));
BinnedPdf inPdf = PdfConverter::ToBinnedPdf(gaus, axes);
FakePdfGenerator pdfGen;
pdfGen.SetRates(std::vector<double> (1, 1000000));
pdfGen.SetPdfs(std::vector<BinnedPdf> (1, inPdf));
BinnedPdf outPdf = pdfGen.ExpectedRatesPdf();
REQUIRE(outPdf.Integral() == 1000000);
outPdf.Normalise();
double outMean = outPdf.Means().at(0);
double inMean = inPdf.Means().at(0);
REQUIRE(std::abs(outMean) < 0.01);
}
#include <catch.hpp>
#include <BinnedPdfManager.h>
#include <PdfConverter.h>
#include <Gaussian.h>
#include <iostream>
TEST_CASE("Three pdfs no systematics"){
Gaussian gaus1(0, 1);
Gaussian gaus2(2, 3);
Gaussian gaus3(4, 5);
AxisCollection axes;
axes.AddAxis(PdfAxis("axis1", -40, 40 , 200));
BinnedPdf pdf1 = PdfConverter::ToBinnedPdf(gaus1, axes);
BinnedPdf pdf2 = PdfConverter::ToBinnedPdf(gaus2, axes);
BinnedPdf pdf3 = PdfConverter::ToBinnedPdf(gaus3, axes);
pdf1.SetDataRep(0);
pdf2.SetDataRep(0);
pdf3.SetDataRep(0);
double prob1 = pdf1.GetBinContent(0);
double prob2 = pdf2.GetBinContent(0);
double prob3 = pdf3.GetBinContent(0);
BinnedPdfManager pdfMan;
pdfMan.AddPdf(pdf1);
pdfMan.AddPdf(pdf2);
pdfMan.AddPdf(pdf3);
pdfMan.SetNormalisations(std::vector<double>(3, 1));
int main(){
////////////////////
// 1. Set Up PDFs //
////////////////////
// Set up binning
AxisCollection axes;
axes.AddAxis(PdfAxis("energy", 2, 3, 10, "Energy"));
// Only interested in first bit of data ntuple
DataRepresentation dataRep(0);
// Set up pdf with these bins in this observable
BinnedPdf bgPdf(axes); bgPdf.SetDataRep(dataRep);
BinnedPdf signalPdf(axes); signalPdf.SetDataRep(dataRep);
std::cout << "Initialised Pdfs" << std::endl;
/////////////////////////////////////
// 2. Fill with data and normalise //
/////////////////////////////////////
ROOTNtuple bgMC("filename.root", "treename");
ROOTNtuple signalMC("filename.root", "treename");
for(size_t i = 0; i < 10; i++){
bgPdf.Fill(bgMC.GetEntry(i));
}
for(size_t i = 0; i < 10; i++){
signalPdf.Fill(signalMC.GetEntry(i));
}
bgPdf.Normalise();
signalPdf.Normalise();
std::cout << "Filled pdfs " << std::endl;
////////////////////////////
// 3. Set Up LH function //
////////////////////////////
BinnedNLLH lhFunction;
lhFunction.SetDataSet(&signalMC); // initialise withe the data set
lhFunction.AddPdf(bgPdf);
lhFunction.AddPdf(signalPdf);
std::cout << "Built LH function " << std::endl;
// Set up the optimisation
GridSearch gSearch(&lhFunction);
std::vector<double> minima(2, 0);
std::vector<double> maxima(2, 100);
std::vector<double> stepsizes(2, 1);
gSearch.SetMaxima(maxima);
gSearch.SetMinima(minima);
gSearch.SetStepSizes(stepsizes);
////////////
// 4. Fit //
////////////
gSearch.Optimise();
std::vector<double> fit = gSearch.GetFitResult().GetBestFit();
std::cout << "Best Fit: " << std::endl;
for(size_t i = 0; i < fit.size(); i++)
std::cout << fit.at(i) << "\t";
std::cout << std::endl;
return 0;
}
#include <catch.hpp>
#include <BinnedPdf.h>
#include <EventData.h>
TEST_CASE("Filling a 2x2 PDF"){
AxisCollection ax;
ax.AddAxis(PdfAxis("axis1", 0, 10 , 100));
ax.AddAxis(PdfAxis("axis2", -12, 34 , 100));
BinnedPdf pdf(ax);
SECTION("Intial Binning Correct"){
REQUIRE(pdf.GetNBins() == 100 * 100);
}
SECTION("Filling with weights and a vector of indicies"){
for(size_t i = 0; i < 100; i++){
std::vector<double> vals;
vals.push_back(i);
vals.push_back(i+1);
pdf.Fill(vals, 0.36);
}
REQUIRE(pdf.Integral() == Approx(100 * 0.36));
SECTION("Then Normalise"){
pdf.Normalise();
REQUIRE(pdf.Integral() == 1);
}
