From cb35243f81a3576135bbdce9a3fc7afb0173ed13 Mon Sep 17 00:00:00 2001 From: Cornelius-G Date: Tue, 24 Oct 2023 13:59:05 +0200 Subject: [PATCH 1/9] copy updates --- .gitignore | 1 + Project.toml | 7 + examples/cholesky.jl | 112 +++++ examples/curve_fit/curve_fit.jl | 50 +++ examples/curve_fit/inputs.jl | 62 +++ examples/curve_fit/optimize.py | 39 ++ examples/curve_fit/runEFTfitter.jl | 46 +++ examples/limits/plotting.jl | 111 +++++ examples/limits/runLimits.jl | 97 +++++ examples/limits/testing_limits.jl | 179 ++++++++ examples/limits/tutorial_inputs.jl | 176 ++++++++ examples/tutorial/functions.jl | 116 ++++++ examples/tutorial/ram_sampler.jl | 113 +++++ examples/tutorial/runTutorial.jl | 196 ++++++++- examples/tutorial/tutorial_inputs.jl | 6 + src/EFTfitter.jl | 6 + src/EFTfitterDensity.jl | 272 ++++++++---- src/EFTfitterDensity_old.jl | 499 +++++++++++++++++++++++ src/EFTfitterModel.jl | 71 +++- src/datatypes.jl | 124 ++++-- src/plotting/plot_observables.jl | 6 +- src/utils.jl | 51 ++- test/runtests.jl | 1 + test/test_datatypes.jl | 12 +- test/test_inputs/test_basic_inputs.jl | 8 +- test/test_inputs/test_likelihood.jl | 102 +++++ test/test_inputs/test_nuisance_inputs.jl | 16 +- 27 files changed, 2306 insertions(+), 173 deletions(-) create mode 100644 examples/cholesky.jl create mode 100644 examples/curve_fit/curve_fit.jl create mode 100644 examples/curve_fit/inputs.jl create mode 100644 examples/curve_fit/optimize.py create mode 100644 examples/curve_fit/runEFTfitter.jl create mode 100644 examples/limits/plotting.jl create mode 100644 examples/limits/runLimits.jl create mode 100644 examples/limits/testing_limits.jl create mode 100644 examples/limits/tutorial_inputs.jl create mode 100644 examples/tutorial/functions.jl create mode 100644 examples/tutorial/ram_sampler.jl create mode 100644 src/EFTfitterDensity_old.jl create mode 100644 test/test_inputs/test_likelihood.jl diff --git a/.gitignore b/.gitignore index 1238c24..6f5e21a 100755 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ .vscode Manifest.toml +*.pdf diff --git a/Project.toml b/Project.toml index 735e56c..15620de 100644 --- a/Project.toml +++ b/Project.toml @@ -4,16 +4,23 @@ authors = ["Cornelius Grunwald"] version = "0.1.2" [deps] +ArraysOfArrays = "65a8f2f4-9b39-5baf-92e2-a9cc46fdf018" BAT = "c0cd4b16-88b7-57fa-983b-ab80aecada7e" +BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" DensityInterface = "b429d917-457f-4dbc-8f4c-0cc954292b1d" Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" NamedTupleTools = "d9ec5142-1e00-5aa0-9d6a-321866360f50" Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" Requires = "ae029012-a4dd-5104-9daa-d747884805df" +RobustAdaptiveMetropolisSampler = "2f96e190-b8a6-11e9-0b3d-5fbd22c21613" Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46" +SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" ValueShapes = "136a8f8c-c49b-4edb-8b98-f3d64d48be8f" [compat] diff --git a/examples/cholesky.jl b/examples/cholesky.jl new file mode 100644 index 0000000..e7b9d40 --- /dev/null +++ b/examples/cholesky.jl @@ -0,0 +1,112 @@ +using LinearAlgebra + +function generate_covariance_matrix(size::Int) + # Generate a random square matrix of size x size + A = rand(size, size) + + # Construct the covariance matrix by multiplying A with its transpose + covariance_matrix = A * A' + + return covariance_matrix +end + + + + +function cholesky_product(M, x) + L = cholesky(M).L + z = L' * x + return dot(z, z) +end + +function cholesky_product2(L, x) + z = L * x + return dot(z, z) +end + +function my_product(M, x) + z = M * x + return dot(x, z) + +end + + + + +using BenchmarkTools + + +d = 2000 + +M = generate_covariance_matrix(d) +x = rand(d) + +@btime my_product(M, x) + +L = cholesky(M).L'; +@btime cholesky_product2(L, x) + + +# For Model Uncertainties +using BenchmarkTools +using LinearAlgebra + +using LinearAlgebra + +# Define the lower Cholesky factor L and matrix A +L = [3.0 0.0 0.0; 2.0 1.0 0.0; 1.0 2.0 2.0] +A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0] + +# Compute M = L * L' +M = L * L' + +# Solve the linear system L * X = A +X = L \ A + +# Calculate the inverse of M + A using the Woodbury matrix identity +inv_MplusA = M \ (A * M \ I) + +# Print the result +println(inv_MplusA) + + + + +M + A +@btime inv(M + A) + + +# For Model Uncertainties +using LinearAlgebra + +function inverse_sum(M_inv, D) + n = size(M_inv, 1) # Assuming M_inv and D are square matrices of the same size + + # Calculate the intermediate matrices + A = inv(M_inv * D + I(n)) + B = M_inv * D * A + C = M_inv - B * M_inv + + return C +end + + +# Define the matrices M, D, and M_inv +d = 500 +L = rand(d) +M = L*L' # Example symmetric positive definite matrix +D = Diagonal(rand(d)) # Example diagonal matrix +M_inv = inv(M) # Inverse of M + +# Calculate the inverse of M + D using M_inv +@btime inverse_sum(M_inv, D) + +@btime inv($(M + D)) + + +using WoodburyMatrices + +W = Woodbury(M, I(d), D, I(d)) + +Wi = inv(W) +Matrix(Wi) \ No newline at end of file diff --git a/examples/curve_fit/curve_fit.jl b/examples/curve_fit/curve_fit.jl new file mode 100644 index 0000000..b83131f --- /dev/null +++ b/examples/curve_fit/curve_fit.jl @@ -0,0 +1,50 @@ +using Random +using Plots + +# generate mock data +Random.seed!(45) +N = 20 + +f(x) = 1.1 + 0.2*x + 4.3*x^2 + 0.4*x^3 + 0.2*x^4 + 0.6*x^5 +x=-10:0.1:10 + +x_data = rand(x, N) +ys = f.(x_data) +y_data = [y + rand(Normal(0, 15)) for y in ys] + +for xi in x_data + print(xi, ",") +end + +for yi in y_data + print(yi, ",") +end + + + +plot(x, f.(x), label="Truth") +plot!(x_data, y_data, st=:scatter, label="Data") + + +# using the Julia package "LsqFit.jl" +using LsqFit +@. fit_func(x, p) = p[1] + p[2]*x + p[3]*x^2 + p[4]*x^3 + p[5]*x^4 + p[6]*x^5 + +p0 = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5] # initial guess + +# Fitting the model to the data using nonlinear least-squares optimization +fit = curve_fit(fit_func, x_data, y_data, p0) + + + + +best_fit = fit.param # Retrieving the best-fit parameter values for the model +sigma = stderror(fit) # Calculating the standard error of the fit +margin_of_error = margin_error(fit, 0.05) # Calculating the margin of error for the fit at a 95% confidence level +confidence_inter = confidence_interval(fit, 0.05) # Calculating the confidence interval for the fit at a 95% confidence level + +plot(x, f.(x), label="Truth") +plot!(x_data, y_data, st=:scatter, label="Data") +plot!(x, fit_func(x, best_fit), label="Fit") + +sqrt(20)^ \ No newline at end of file diff --git a/examples/curve_fit/inputs.jl b/examples/curve_fit/inputs.jl new file mode 100644 index 0000000..244ec62 --- /dev/null +++ b/examples/curve_fit/inputs.jl @@ -0,0 +1,62 @@ +# EFTfitter.jl - Curve Fit Example + +using Random + +# generate mock data +Random.seed!(45) +N = 20 + +f(x) = 1.1 + 0.2*x + 4.3*x^2 + 0.4*x^3 + 0.2*x^4 + 0.6*x^5 +x=-10:0.1:10 + +x_data = rand(x, N) +ys = f.(x_data) +y_data = [y + rand(Normal(0, 15)) for y in ys] + + + +# ============= Parameters =============================================# +parameters = BAT.NamedTupleDist( + p = [-20..40, -20..10, -10..10, -10..10, -5..5, -2..2], + #p = fill(-1..1, 6), +) + + +# ============= Observables ============================================# +function observable(params, x) + return params.p[1] + params.p[2]*x + params.p[3]*x^2 + params.p[4]*x^3 + params.p[5]*x^4 + params.p[6]*x^5 +end + +g(x) = params -> observable(params, x) + +obs_array = Function[g(x) for x in x_data] + +#unc_array = fill(1e-5, length(y_data)) +unc_array = sqrt.(abs.(y_data)) + +# ============= Measurements ===========================================# +using LinearAlgebra +cov_matrix = Matrix(I, N, N) + +cor, unc = cov_to_cor(cov_matrix) + +unc = unc .* sqrt(180) + + +measurements = ( + MeasDist = MeasurementDistribution(obs_array, y_data, uncertainties = (unc1 = unc,)), +) + + +# ============= Correlations ===========================================# +correlations = ( + unc1 = NoCorrelation(active=true), +) + +#corr_matrix = to_correlation_matrix(measurements, +# (:Meas1, :Meas2, 0.1), +#) + + +# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl + diff --git a/examples/curve_fit/optimize.py b/examples/curve_fit/optimize.py new file mode 100644 index 0000000..60182b5 --- /dev/null +++ b/examples/curve_fit/optimize.py @@ -0,0 +1,39 @@ +import numpy as np +from scipy.optimize import curve_fit +from matplotlib import pyplot as plt + + +x = np.array([-6.5,-9.3,7.9,-8.9,9.7,5.5,5.5,2.5,-8.7,1.0,1.4,1.9,7.6,3.8,-8.5,-7.0,-2.8,0.9,1.3,4.2,]) +y = np.array([437.903955201858,1537.749199238419,1231.9258895641094,1323.9224677984573,2527.6637713963096,399.57818043731953,362.4963567699898,56.85153464909146,1202.774601731368,25.205508693430282,17.192572423872164,1.914974838495624,1086.4978390611982,134.2200703399384,1107.3595441415214,561.0614957587213,49.062840977188266,20.906407232145973,9.70889789068209,144.96530373831723]) + +# Test function with coefficients as parameters +def test(x, a, b, c, d, e): + return a + b*x + c*x**2 + d*x**3 + e*x**4 + +# curve_fit() function takes the test-function +# x-data and y-data as argument and returns +# the coefficients a and b in param and +# the estimated covariance of param in param_cov +param, param_cov = curve_fit(test, x, y) + + +print("Sine function coefficients:") +print(param) + +print("Covariance of coefficients:") +print(param_cov) + +np.sqrt(np.diag(param_cov)) + + +# ans stores the new y-data according to +# the coefficients given by curve-fit() function +ans = (param[0]*(np.sin(param[1]*x))) + +'''Below 4 lines can be un-commented for plotting results +using matplotlib as shown in the first example. ''' + +# plt.plot(x, y, 'o', color ='red', label ="data") +# plt.plot(x, ans, '--', color ='blue', label ="optimized data") +# plt.legend() +# plt.show() diff --git a/examples/curve_fit/runEFTfitter.jl b/examples/curve_fit/runEFTfitter.jl new file mode 100644 index 0000000..ea48d05 --- /dev/null +++ b/examples/curve_fit/runEFTfitter.jl @@ -0,0 +1,46 @@ +# EFTfitter.jl - Empty Template +using EFTfitter +using BAT # for sampling +using IntervalSets # for specifying the prior +using Distributions # for specifying the prior +using Plots # for plotting + +# include definitions of observables, measurements, +# uncertainties and correlations from the inputs file: +include("inputs.jl") +include("../tutorial/ram_sampler.jl") + +# create an `EFTfitterModel` object: +model = EFTfitterModel(parameters, measurements, correlations) +# create posterior distribution: +posterior = PosteriorMeasure(model); +get_total_covariance(model) + + +# sample the posterior distribution with BAT.jl: +algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4, strict=false) +algorithm = RAMSampler(nchains=4, nsteps=8*10^5, nburnin=4*10^5) + +samples = bat_sample(posterior, algorithm).result; + +findmode = bat_findmode(posterior) +findmode.result + +findmode.info +# create and display a `SampledDensity` object for a quick overview of results: +sd = SampledDensity(posterior, samples) +print(sd) +bat_report(sd) + +cov(samples) + +# plot the posterior distribution: +p = plot(samples) +savefig(p, "plot.pdf") + +# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl + +sqrt(180) + +d = 6 +0.5*(2*pi)^(d/2) diff --git a/examples/limits/plotting.jl b/examples/limits/plotting.jl new file mode 100644 index 0000000..4bf2f5b --- /dev/null +++ b/examples/limits/plotting.jl @@ -0,0 +1,111 @@ +# EFTfitter.jl - Plotting Tutorial +# EFTfitter includes several recipes for plotting its datatypes +# using [Plots.jl](http://docs.juliaplots.org/latest/) +using EFTfitter +using BAT +using IntervalSets +using Distributions +using Plots + +# we use the inputs from the basic tutorial: +include("tutorial_inputs.jl") +model = EFTfitterModel(parameters, measurements, correlations) + +posterior = PosteriorMeasure(model) +algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) +samples = bat_sample(posterior, algorithm).result; + +# Note: All plots generated with the following plot recipes can be customized using the +# [series attributes](http://docs.juliaplots.org/latest/generated/attributes_series/), +# [axis attributes](http://docs.juliaplots.org/latest/generated/attributes_axis/), +# [subplot attributes](http://docs.juliaplots.org/latest/generated/attributes_subplot/) and +# [plot attributes](http://docs.juliaplots.org/latest/generated/attributes_plot/) + + +# ---------- Plotting Observables ------------------------- + +# Plotting an `Observable` object: +plot(Observable(xsec1), (C1=0, C2=-1:0.01:1)) + +# When plotting an `Observable` from the `EFTfitterModel`, it can be accessed in different ways: +plot(get_observables(model).xsec1, (C1=0, C2=-1:0.01:1)) + +plot(get_measurements(model).Meas1.observable, (C1=0, C2=-1:0.01:1)) + + +# If the model has many parameters, it can be convenient to pass the paramter that should be +# plotted together with as a `NamedTuple` with default values for all parameters. +default_parameters = (C1=1, C2=0) +plot(get_observables(model).xsec1, (C2=-1:0.01:1,), default_parameters) + +# The second argument in this function overwrites the corresponding default parameters, +# so it is also possible to pass multiple parameters: +plot(get_observables(model).xsec1, (C2=-1:0.01:1, C1=2.3), default_parameters) + +# All observables of a model can easily be plotted in one plot: +p = plot() +for meas in get_measurements(model) + p=plot!(meas.observable, (C1=0, C2=-1:0.01:1), ylabel="prediction") +end +p + +# When plotting observables, the default title contains the values of the fixed# parameters. In case the title is too long for one line, linebreaks can be inserted# using the keyword `titlewidth`. e.g.: +plot(get_observables(model).xsec1, (C1=-10:0.01:10, C2=0, C3=100, C4=200), titlewidth=13) + +# ---------- Plotting Measurements ------------------------- + +# `Measurement` objects can be plotted on top of the observables as a horizontal line with an uncertainty band: +plot(get_measurements(model).Meas1.observable, (C1=0, C2=-0.2:0.01:0.2)) +plot!(measurements.Meas1) + + +# However, when plotting the measurements of the `EFTfitterModel`, the following syntax +# is preferred as it supports showing the names of the measurments in the legend: +plot(get_measurements(model).Meas1.observable, (C1=0, C2=-0.2:0.01:0.2)) +plot!(get_measurements(model), :Meas1) + +# The uncertainty typed to be plotted can be specified: +plot(get_measurements(model).Meas1.observable, (C1=0, C2=-0.2:0.01:0.2)) +plot!(get_measurements(model), :Meas1, uncertainties=(:stat, :another_unc)) + +# When mutliple types of uncertainties are given, the sum of the squares is used as the total uncertainty. +# By default, all uncertainties included in the `EFTfitterModel` are used. + +# ---------- Plotting MeasurementDistributions ------------------------- +# `MeasurementDistribution`s can be plotted for fixed parameters: +plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) +plot!(get_measurement_distributions(model), :MeasDist) + +# alternative plotting style for measurement distributions: +plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) +plot!(get_measurement_distributions(model), :MeasDist, st=:scatter) + +# Also for `MeasurementDistribution`s the uncertainty types to be plotted can be specified. +# The names of the bins can be customized using the `bin_names` keyword. +plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) +plot!(get_measurement_distributions(model), :MeasDist, st=:scatter, uncertainties=(:stat,), bin_names=("First bin", "Second bin")) + + +# ---------- Plotting 1D Intervals ------------------------- +# Default plot of the smallest 1D intervals containing 90% posterior probability: +plot(samples, 0.9) + +# Default settings for keywords: +plot(samples, 0.9, + parameter_names = get_parameter_names(maybe_shaped_samples), # Array of String with the names of the parameters + y_positions = collect(1:length(parameter_names))*-1, # y-positions of the interval lines + y_offset = 0, # offest on the y-axis, helpful when plotting multiple samples on top of each other + bins = 200, # number of bins for calculating smallest intervals + atol = 0,) # merge intervals that are seperated less then atol (especially helpful when using a high number of bins) + +# helpful keyword arguments: +# msc = markerstrokecolor: color of the interval lines +# msw = markerstrokewidth: linewidth +# ms = markersize: size of caps + +# Customized 1D interval plot: +p = plot(samples, 0.9, bins = 400, atol=0.01, y_offset=-0.1, label = "Samples A") +p = plot!(samples, 0.9, bins = 100, atol=0.05, y_offset=0.1, msw = 5, ms=8, msc=:red, label = "Samples B") + +# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl + diff --git a/examples/limits/runLimits.jl b/examples/limits/runLimits.jl new file mode 100644 index 0000000..b764651 --- /dev/null +++ b/examples/limits/runLimits.jl @@ -0,0 +1,97 @@ +# EFTfitter.jl - Tutorial +# This tutorial introduces the basic functionalities of EFTfitter.jl using a generic example. +# More functionalities of EFTfitter.jl, like handling nuisance correlations +# or ranking measurements and uncertainties, are shown in the +# [advanced tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/advanced_tutorial/). + +# Here, we create the `EFTfitterModel` from our inputs and run the actual analysis. + +# First, we need to setup EFTfitter, BAT and some other Julia packages: +using EFTfitter +using BAT # for sampling +using IntervalSets # for specifying the prior +using Distributions # for specifying the prior +using Plots # for plotting + +# We include the definitions of observables, measurements, +# uncertainties and correlations from our `tutorial_inputs.jl` file: +include("tutorial_inputs.jl") + +# We can then build the `EFTfitterModel` which combines all our inputs into +# one object that is then used to perform the analysis on. +model = EFTfitterModelWithLimits(parameters, measurements, correlations, limits) + +# To sample the posterior distribution, we specify that our `EFTfitterModel` +# should be used and then setup BAT.jl to sample the EFTfitter likelihood. +posterior = PosteriorMeasure(model) + +algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) +samples = bat_sample(posterior, algorithm).result; +# For further information on settings & algorithms when sampling with BAT.jl +# see the BAT.jl [tutorial](https://bat.github.io/BAT.jl/dev/tutorial/#Parameter-Space-Exploration-via-MCMC) +# and [documentation](https://bat.github.io/BAT.jl/dev/stable_api/#BAT.bat_sample). + +# We can then inspect the results of the sampling using BAT.jl's `SampledDensity`, +# giving a summary of the sampling and the results of the model parameters. +sd = SampledDensity(posterior, samples) +display(sd) + +# Information about the smallest 1d intervals containing p% proability can be +# obtained using the `get_smallest_interval_edges` function: +intervals_1d_C1 = get_smallest_interval_edges(samples, :C1, 0.9, bins=200, atol=0.1) +println("lower interval edges: $(intervals_1d_C1.lower)") +println("upper interval edges: $(intervals_1d_C1.upper)") + +# The keyword `atol` controls the absolute tolerance for which intervals are joined +# together when they are seperated less than this value. This is particularly useful +# when a large number of bins is used. + +# Of course, plotting the resulting posterior distributions is also simple +# using Plots.jl and the BAT.jl plotting recipes: +p = plot(samples) +savefig(p, "plot.pdf") + +# For information on how to customize plots of the samples, please see the BAT.jl +# [plotting documentation](https://bat.github.io/BAT.jl/dev/plotting/) and +# [examples](https://github.com/bat/BAT.jl/blob/master/examples/dev-internal/plotting_examples.jl). + +p = plot(samples, 0.9) +savefig(p, "plot_1d.pdf") + +# For customizing the plots of the 1D intervals, also see the EFTfitter +# [plotting documentation](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/plotting/) +# and [tutorial](https://github.com/tudo-physik-e4/EFTfitter.jl/blob/main/examples/tutorial/plotting.jl). + +# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl + + +using SpecialFunctions + +μ = 0.0 +p = 0.9 +q = 8.5 + +function Normal_from_limit(best_fit_value, limit, confidence_level) + μ = best_fit_value + p = confidence_level + q = limit + + σ = (q - μ)/(sqrt(2)*erfinv(2*p-1)) + + return Normal(μ, σ) +end + +function Exponential_from_limit(limit, confidence_level) + p = confidence_level + q = limit + + λ = -1/q * log(1-p) + + return Exponential(1/λ) +end + + +quantile(Normal_from_limit(μ, q, p), p) +quantile(Exponential_from_limit(q, p), p) + + diff --git a/examples/limits/testing_limits.jl b/examples/limits/testing_limits.jl new file mode 100644 index 0000000..f409fa8 --- /dev/null +++ b/examples/limits/testing_limits.jl @@ -0,0 +1,179 @@ +using BAT +using EFTfitter +using Distributions +using DensityInterface +using Plots +gr(size=(1000,800), thickness_scaling=2) + + + +# Counting experiment (Poisson distribution) +# Expected Background: b = 3.4 +# Observed: N=3 +# What is 95% upper limit on s? + + +likelihood = logfuncdensity(params -> begin + s = params.s + b = params.b + n = 0#3 + + return logpdf.(Poisson(s+b), n)#logpdf(Normal(1.9, 1.6), s)#logpdf.(Poisson(s+b), n) + +end) + +prior = BAT.NamedTupleDist( + s = Uniform(0, 12), + b = 0#3.4, #truncated(Normal(3.4, 2.), 0.01, Inf) +) + +posterior = PosteriorMeasure(likelihood, prior); + +samples, chains = bat_sample(posterior, MCMCSampling(mcalg = MetropolisHastings(), nsteps = 4*10^6)); + +plot(samples, intervals=[0.9], bins=500) + +interval_edges = get_smallest_interval_edges(samples, :s, 0.9, bins=500) + +upper_limit = interval_edges.upper[1] + +using SpecialFunctions +function Normal_from_limit(best_fit_value, limit, confidence_level) + μ = best_fit_value + p = confidence_level + q = limit + + σ = (q - μ)/(sqrt(2)*erfinv(p)) + + return Normal(μ, σ) +end + +function Exponential_from_limit(limit, confidence_level) + p = confidence_level + q = limit + + λ = -1/q * log(1-p) + + return Exponential(1/λ) +end + +exponential_dist = Exponential_from_limit(upper_limit, 0.9) +normal_dist = Normal_from_limit(-10, upper_limit, 0.9) + +x = 0:0.1:12 +plot(samples, :s, intervals=[0.9], bins=500, label="Posterior") +plot!(x, pdf.(exponential_dist, x), lw=4, lc=1, label="Exponential from limit", legend=true) +plot!(x, 20*pdf.(normal_dist, x), lw=4, lc=2, label="Normal from limit", legend=true) + + +g(x) = (x+3.4)^3/6 * exp(-(x+3.4)) + +g(x) = exp(-(x)) +plot!(x, 1.8*g.(x), lw=4, lc="black", label="Poisson", legend=true) + + +g(x; μ=0, N=0) = (x+μ)^N * exp(-(x+μ)) + +x = 0:0.05:6 +plot(x, g.(x, μ=2, N=4)) + +#------------------------------------------------------------ +using DelimitedFiles + +data_file = "C:\\Users\\Cornelius\\Projects\\plot2.csv" + +data = readdlm(data_file, ';', Float64) + +idxs = sortperm(data[:,1]) +points_x = data[:, 1][idxs] +points_y = 1 .- data[:, 2][idxs] +points_y2 = data[:, 2][idxs] + +x = 0.22:0.01:5.6 +x1 = 0.22:0.01:2 +x2 = 2.01:0.01:5.8 + +plot(points_x, points_y, st=:scatter, ms=2) + +using Interpolations +itp = interpolate((points_x,), points_y, Gridded(Linear())) + +plot!(x, itp.(x1), lw=2) + + +dx = only.(Interpolations.gradient.(Ref(itp), x)) + +plot!(x, dx, lw=2) + +poi(N) = x-> x^N/factorial(N)*exp(-x) + +plot(points_x, points_y2, st=:scatter, msw=0, ms=2) +#plot!(x1, 2*poi(0).(x1)) +a=0.64 +a2 = 2.2 +plot!(x1, 0.35 .+ a.*exp.(-a*x1)) +plot!(x2, -0.05 .+ a2.*exp.(-a*x2)) + +f1(x; a=0.64) = 1-(0.35 .+ a.*exp.(-a*x)) +f2(x; a=2.2) = 1-(-0.05 .+ a.*exp.(-a*x)) + +plot(points_x, points_y, st=:scatter, ms=2, msw=0) +plot!(x1, f1.(x1), lw=2) +plot!(x2, f2.(x2), lw=2) + + + +#--------------------------------------- +n = 47 +plot(points_x[1:n], points_y[1:n], st=:scatter, msw=0, ms=2) +plot!(points_x[n:end], points_y[n:end], st=:scatter, msw=0, ms=2, color=2) + +@. ffq(x, p) = p[1]*x^2 + p[2]*x + p[3] + p[4]*x^3 + p[5]*x^4 + + +p0 = ones(5) +fit = curve_fit(ffq, points_x[1:n], points_y[1:n], p0) +p1 = fit.param +plot!(x1, ffq(x1, p1), lw=3) + + +fit = curve_fit(ffq, points_x[n:end], points_y[n:end], p0) +p2 = fit.param +plot!(x2, ffq(x2, p2), lw=3) + + +ffq(p) = x -> ffq(x, p) + +using ForwardDiff +plot!(x1, ForwardDiff.derivative.(ffq(p1), x1)) +plot!(x2, ForwardDiff.derivative.(ffq(p2), x2)) + +plot!(x2, pdf.(Normal(2, 1.6), x2)) + + + + + + + + + + + + + +using StatsFuns + +plot(points_x, points_y, st=:scatter, msw=0, ms=2) + + +using LsqFit + +@. model2(x, p) = p[3]*StatsFuns.nchisqpdf(x, p[1], p[2]) + +p0 = [0.05, 1, 0.1] # Initial guesses for the two parameters of the model +# Fitting the model to the data using nonlinear least-squares optimization +fit = curve_fit(model2, points_x[1:20], points_y[1:20], p0) +fit.param + +plot!(x1, model2(x1, fit.param)) \ No newline at end of file diff --git a/examples/limits/tutorial_inputs.jl b/examples/limits/tutorial_inputs.jl new file mode 100644 index 0000000..9e3860e --- /dev/null +++ b/examples/limits/tutorial_inputs.jl @@ -0,0 +1,176 @@ +# EFTfitter.jl - Tutorial +# This tutorial introduces the basic functionalities of EFTfitter.jl using a generic example. +# More functionalities of EFTfitter.jl, like handling nuisance correlations +# or ranking measurements and uncertainties, are shown in the +# [advanced tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/advanced_tutorial/). + + +# We start by defining all neccesary inputs to create an +# [`EFTfitterModel`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.EFTfitterModel). + +# ============= Parameters =============================================# +# We specify the parameters our model depends on and choose a prior for each of the parameters. +# The prior has to be specified in form of a [BAT.jl prior](https://bat.github.io/BAT.jl/dev/tutorial/#Prior-Definition). + +# For our example, we consider two parameters with the names `C1` and `C2`. +# For `C1` we choose a uniform (flat) prior in the range (-3, 3). +# For `C2` we choose a gaussian prior with μ=0 and σ=0.5. +parameters = BAT.NamedTupleDist( + C1 = -3..3, # short for: Uniform(-3, 3) + C2 = Normal(0, 0.5) # Normal distribution +) + +# A parameter can be fixed (and therefore excluded from the fit) by setting its +# prior to a certain value, e.g.: `C2 = 0`. +# Also see [here](https://bat.github.io/BAT.jl/dev/tutorial/#Prior-Definition) +# for more information on priors in the BAT.jl documentation. + +# ============= Observables =============================================# +# We now proceed to implement `Functions` that specify how the predicted values +# of the observables depend on the model parameters. +# For each observable, we need to provide a `Function` that returns the predicted +# value of the observable for certain values of the model parameters. In our example, +# we consider two observables (e.g. cross sections) by defining the two functions `xsec1` and `xsec2`. + +# Note: The functions for the observables may only have the model parameters as +# their only argument. You can, however define a function that only depends on +# the parameters and that internally calls a more complex function and passes the +# corresponding arguments. In this example, the function `xsec2` calls the +# function `myfunc` and passes further arguments (`coeffs`). + +function xsec1(params) + c = [20.12, 5.56, 325.556] + return c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 +end + +function xsec2(params) + coeffs = [2.12, 4.3, 12.6] + return myfunc(params, coeffs) +end + +function myfunc(params, c) + return c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 +end + +# If your observable is a distribution, you can define a vector of functions +# with one function for each bin of the distribution. +# (You could also treat each bin as a separate observable as shown above.) + +function diff_xsec_bin1(params) + coeffs = [2.2, 5.5, 6.6] + return myfunc(params, coeffs) +end + +function diff_xsec_bin2(params) + coeffs = [3.3, 4.8, 7.6] + return myfunc(params, coeffs) +end + +function diff_xsec_bin3(params) + coeffs = [4.9, 5.6, 8.9] + return myfunc(params, coeffs) +end + +diff_xsec = [diff_xsec_bin1, diff_xsec_bin2, diff_xsec_bin3] + +# Note: Another way to define a vector of functions for the bins of distributions +# is shown [here](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/advanced_tutorial/#Creating-a-vector-of-functions-for-distributions-1) +# in the [advanced tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/advanced_tutorial/). +# This can be particularly useful when the predictions for the individual bins +# have a similar functional relation and only differ in terms of some coefficients, +# as it is the case here in this example. + +# ============= Measurements =============================================# +# We can now enter measurements of the observables. +# This is done by defining a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) +# consisting of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) +# and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution) objects. + +# A `Measurement` consists of the observable, the measured numerical value and +# numerical values for the (multiple types of) uncertainties. +# The observable can be passed to the `Measurement` either as an [`Observable`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Observable) +# object or as a `Function`. When using the latter, the observable is assumed to be unconstrained. +# The uncertainties are passed as a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types). +# Each measurement has to provide uncertainty values for all of the (active) uncertainty +# types (see next section on `Correlations`). For a `MeasurementDistribution`, +# the corresponding inputs have to be passed as `Vectors`, where each element +# represents one bin of the distribution. + +# A `Measurement` can be excluded from the model by setting the switch `active=false`. +# For a `MeasurementDistribution`, the keyword `active` accepts `true` or `false` +# to (de)activate the whole distribution or a vector of booleans for (de)activating only certain bins. + +measurements = ( + Meas1 = Measurement(xsec1, 21.6, uncertainties = (stat=0.8, syst=1.8, another_unc=2.3), + active=true), # `active = false`: exclude measurement from fit (default: active = true) + + Meas2 = Measurement(Observable(xsec2, min=0), 1.9, + uncertainties = (stat=0.6, syst=0.9, another_unc=1.1), active=true), + + MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4], + uncertainties = (stat = [0.7, 1.1, 1.2], syst= [0.7, 0.8, 1.3], another_unc = [1.0, 1.2, 1.9]), + active=[true, false, true]), # `active = false`: exclude all bins from fit, `active = [true, true, false]`: exclude only third bin from fit +) + +limits = ( + UL1 = GaussianUpperLimit(xsec1, 0.01, 5.0, 0.9), +) + +# Further information on the constructors see the API documentation of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) +# and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution). + +# Note: When using only one measurement or only one type of uncertainties, +# make sure to insert a comma, like: `uncertainties = (stat = 0.5,)` so that +# Julia can parse the [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) correctly! + + +# ============= Correlations =============================================# +# The correlations between the uncertainties of the measurements need to be provided +# for each of the uncertainty types. We can pass them by defining a `NamedTuple` +# of [`Correlation`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Correlation) +# objects that contain the corresponding correlation matrices. +# The correlation matrix for each type of uncertainty needs to have a size +# of ``N \times N``, where ``N`` is the number of measurements, counting each bin of a distribution. +# When a certain type of uncertainty should not be considered, it can be deactivated +# by setting `active = false`. This means that the uncertainty values given in the +# corresponding `Measurement` and `MeasurementDistribution` objects will not be used. + +# When assuming the uncertainties of all measurements are uncorrelated, you can +# use the `NoCorrelation` object for easily passing an identity matrix of the correct size. + +# When using a large number of measurements, entering the correlation matrix becomes +# quite impractical, especially if you want to add further measurements later. +# With the function `to_correlation_matrix`, it is possible to enter a correlation +# matrix by simply specifying the names of the measurements that should be correlated +# and the value of the corresponding correlation coefficient. +# When using a `MeasurementDistribution`, the inter-bin correlations can also be +# entered by passing a matrix. By appending `_binX` to the name of a `MeasurementDistribution`, +# the Xth bin of the distribution can be accessed. +# Note: This function is evaluated from top to bottom, so if you overwrite a +# specific correlation value, the last value entered will be used. + +dist_corr = [1.0 0.5 0.0; + 0.5 1.0 0.0; + 0.0 0.0 1.0] + +another_corr_matrix = to_correlation_matrix(measurements, + (:Meas1, :Meas2, 0.4), # correlate measurements :Meas1 and :Meas2 with a correlation coefficient of 0.4 + (:Meas1, :MeasDist, 0.1), # correlate all bins of :MeasDist with :Meas1 with 0.1 + (:MeasDist, :MeasDist, dist_corr), # correlate the bins of :MeasDist according to the matrix dist_corr + (:MeasDist_bin2, :MeasDist_bin3, 0.3), # correlate bin2 of :MeasDist with bin3 with 0.3 (overwrites the corresponding element set in the previous line, but ignored in fit since MeasDist_bin2 is inactive) +) + +correlations = ( + stat = NoCorrelation(active=true), # will use the identity matrix of the correct size + + syst = Correlation([1.0 0.5 0.3 0.2 0.2; + 0.5 1.0 0.2 0.2 0.2; + 0.3 0.2 1.0 0.2 0.2; + 0.2 0.2 0.2 1.0 0.2; + 0.2 0.2 0.2 0.2 1.0], active=false), # `active = false`: ignore all uncertainty values and correlations for this type of uncertainty + + another_unc = Correlation(another_corr_matrix, active=true) +) + +# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl + diff --git a/examples/tutorial/functions.jl b/examples/tutorial/functions.jl new file mode 100644 index 0000000..2d3b0ca --- /dev/null +++ b/examples/tutorial/functions.jl @@ -0,0 +1,116 @@ +using BenchmarkTools + +struct Prediction + pred::Float64 + unc::Float64 +end + +Prediction(a::Float64) = Prediction(a, 0.) +Prediction(a::Tuple{Float64, Float64}) = Prediction(a[1], a[2]) +Prediction(a::Prediction) = a + +observable1(params) = rand() +observable2(params) = (rand(), rand()) + +functions_vector_1 = fill(observable1, 100) +functions_vector_2 = fill(observable2, 100) +functions_vector_12 = vcat(fill(observable1, 50), fill(observable2, 50)) + + +# using tuple: +to_tuple(f) = x -> (f(x), 0.) +functions_vector_12_tuple = vcat(fill(to_tuple(observable1), 50), fill(observable2, 50)) + + +# using Prediction struct: +observable1_p(params) = Prediction(rand()) +observable2_p(params) = Prediction(rand(), rand()) + +functions_vector_2_p = fill(observable2_p, 100) +functions_vector_12_p = vcat(fill(observable1_p, 50), fill(observable2_p, 50)) + + +function eval_functions_a(f_vec, params) + res = [f(params) for f in f_vec] + return res +end + +function eval_functions_a2(f_vec, params) + res::Vector{Tuple{Float64, Float64}} = [f(params) for f in f_vec] + return res +end + + +function eval_functions_c(f_vec, params, preds, uncs) + for i in eachindex(f_vec) + res::Tuple{Float64, Float64} = f_vec[i](params) + preds[i] = res[1] + uncs[i] = res[2] + end + return preds, uncs +end + +function eval_functions_d(f_vec, params, preds, uncs) + for i in eachindex(f_vec) + res::Prediction = f_vec[i](params) + preds[i] = res.pred + uncs[i] = res.unc + end + #return preds, uncs +end + + +function eval_functions_f(f_vec, params) + ps = Float64[] + uncs = Float64[] + for i in eachindex(f_vec) + res::Prediction = f_vec[i](params) + push!(ps, res.pred) + push!(uncs, res.unc) + end + return ps, uncs +end + +function eval_functions_e(f_vec, params, preds, uncs) + for i in eachindex(f_vec) + res::Prediction = Prediction(f_vec[i](params)) + preds[i] = res.pred + uncs[i] = res.unc + end + return preds, uncs +end + +params = rand(3) + +# A: Current EFTfitter Implementation +@btime eval_functions_a(functions_vector_1, params) +@btime eval_functions_a(functions_vector_2, params) +@btime eval_functions_a(functions_vector_12, params) +@btime eval_functions_a(functions_vector_12_tuple, params) + +@code_llvm eval_functions_a(functions_vector_12, params) + +# B: + + +# C: Using preallocation +preds = zeros(100) +uncs = zeros(100) +@btime eval_functions_c(functions_vector_2, params, preds, uncs) +@btime eval_functions_c(functions_vector_12_tuple, params, preds, uncs) + + +# C: Using preallocation & Prediction Type +preds = zeros(100) +uncs = zeros(100) +@btime eval_functions_d(functions_vector_2_p, params, preds, uncs) +@btime eval_functions_d(functions_vector_12_p, params, preds, uncs) +@btime eval_functions_f(functions_vector_12_p, params) + + +@btime eval_functions_e(functions_vector_12, params, preds, uncs) + + +@code_warntype eval_functions_d(functions_vector_12_p, params, preds, uncs) + +typeof((1.,2.)) \ No newline at end of file diff --git a/examples/tutorial/ram_sampler.jl b/examples/tutorial/ram_sampler.jl new file mode 100644 index 0000000..5509f45 --- /dev/null +++ b/examples/tutorial/ram_sampler.jl @@ -0,0 +1,113 @@ +import BAT: AbstractSamplingAlgorithm, bat_sample_impl +using BAT: DensitySampleVector, AbstractRNG, AbstractMeasureOrDensity, MCMCSampleID, AnyMeasureOrDensity, ConvergenceTest, transform_and_unshape, bat_convergence +using Parameters +using ValueShapes +using ArraysOfArrays +using InverseFunctions + +# simple wrapper for the RAM sampler [1011.4381] using RobustAdaptiveMetropolisSampler.jl +using RobustAdaptiveMetropolisSampler + +export RAMSampler + +@with_kw struct RAMSampler{ + CT<:ConvergenceTest +} <: AbstractSamplingAlgorithm + trafo = PriorToGaussian() + nchains::Int = 4 + nsteps::Int = 10^5 + nburnin::Int = floor(Int,0.1*nsteps) # number of burnin steps to throw away per chain + convergence::CT = BrooksGelmanConvergence() + x0 = fill(nothing, nchains) + M0 = fill(1., nchains) + opt_α = fill(0.234, nchains) + γ=fill(2/3, nchains) + q=fill(Normal(), nchains) +end + + +function bat_sample_impl( + rng::AbstractRNG, + target::AnyMeasureOrDensity, + algorithm::RAMSampler +) + density_notrafo = convert(BAT.AbstractMeasureOrDensity, target) + density, trafo = transform_and_unshape(algorithm.trafo, density_notrafo) + shape = varshape(density) + + ram_vector = [] + @info "Start RAM sampling of $(algorithm.nchains) chains with $(Threads.nthreads()) threads." + + Threads.@threads for i in 1:algorithm.nchains + try + push!(ram_vector, generate_ram_samples(i, rng, density, algorithm; show_progress = ifelse(i==1, true, false))) + catch err + @info "RAM sampling failed for thread $(Threads.threadid())." + end + end + + samples, M, acceptance_rate = collect_samples(ram_vector) + + samples_trafo = shape.(reduce(vcat, samples)) + samples_notrafo = inverse(trafo).(samples_trafo) + + #converged = bat_convergence(samples_notrafo, algorithm.convergence).converged + #@info "RAM chains have$(ifelse(converged, "", " not")) converged" + + return (result = samples_notrafo, result_trafo = samples_trafo, trafo = trafo, M = M, acceptance_rate = acceptance_rate) + +end + + +function generate_ram_samples( + i::Integer, + rng::AbstractRNG, + target_density::Any, + algorithm::RAMSampler; + show_progress = false +) + n_tries = 0 + success = false + + ram_result_vec = [] + while !success && n_tries < 4000 + n_tries += 1 + try + x0 = any(isnothing.(algorithm.x0)) ? bat_initval(rng, target_density, InitFromTarget()).result : algorithm.x0[i] + M0 = algorithm.M0[i] + println("n_tries: ", n_tries) + + ram_result = RobustAdaptiveMetropolisSampler.RAM_sample(logdensityof(target_density), x0, M0, algorithm.nsteps; + opt_α=algorithm.opt_α[i], γ=algorithm.γ[i], q=algorithm.q[i], show_progress=show_progress, output_log_probability_x=true) + + success = true + push!(ram_result_vec, ram_result) + catch e + success = false + end + end + + ram_result = ram_result_vec[1] + nburnin = algorithm.nburnin + samples = nestedview(ram_result.chain')[nburnin+1:end] + logvals = ram_result.log_probabilities_x[nburnin+1:end] + + return (samples=samples, logvals=logvals, M=ram_result.M, acceptance_rate=ram_result.acceptance_rate) +end + + +function collect_samples(ram_vector) + M = getproperty.(ram_vector, :M) + acceptance_rate = getproperty.(ram_vector, :acceptance_rate) + samples_raw = getproperty.(ram_vector, :samples) + logvals_raw = getproperty.(ram_vector, :logvals) + samples = [] + + for i in 1:length(ram_vector) + n_samples = length(samples_raw[i]) + sample_id = fill(MCMCSampleID(i, 0, 0, 0), n_samples) + push!(samples, DensitySampleVector(samples_raw[i], logvals_raw[i], info=sample_id)) + end + + return (samples=samples, M=M, acceptance_rate=acceptance_rate) +end diff --git a/examples/tutorial/runTutorial.jl b/examples/tutorial/runTutorial.jl index 57c7f13..a0167dd 100644 --- a/examples/tutorial/runTutorial.jl +++ b/examples/tutorial/runTutorial.jl @@ -19,14 +19,132 @@ include("tutorial_inputs.jl") # We can then build the `EFTfitterModel` which combines all our inputs into # one object that is then used to perform the analysis on. -model = EFTfitterModel(parameters, measurements, correlations) + +using SparseArrays +using LinearAlgebra +f(x) = Symmetric(sparse(x)) + +model = EFTfitterModel(parameters, measurements, correlations, CovarianceType=f) +#run_speed_test(model) # To sample the posterior distribution, we specify that our `EFTfitterModel` # should be used and then setup BAT.jl to sample the EFTfitter likelihood. -posterior = PosteriorMeasure(model) -algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) -samples = bat_sample(posterior, algorithm).result; +parameters1 = BAT.NamedTupleDist( + p1 = -20..20, + p2 = -10..10, +) + +function testfunc1(params) + c = [20.12, 5.56, 325.556] + return c[1] * params.p1^2 + c[2] * params.p1 * params.p2 + c[3] * params.p2^2 +end + +measurements1 = ( + meas1 = Measurement(testfunc1, 111.1, + uncertainties = (unc1=10.1, unc2=12.2, unc3=13.3), active=true), + + meas2 = Measurement(Observable(testfunc1, min=0, max=1000), 222.2, + uncertainties = (unc1=20.1, unc2=20.2, unc3=23.3), active=false), + + meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 333.3, + uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), + + meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], + [10, 20, 30], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), + active = [true, false, true], bin_names=[Symbol("0_5"), Symbol("5_10"), Symbol("10_20")]) +) + +corr_matrix = to_correlation_matrix(measurements1, + (:meas1, :meas2, 0.12), # will be ignored later in EFTfitterModel + (:meas1, :meas3, 0.13), + (:meas1, :meas4_0_5, 0.141), + (:meas1, :meas4_5_10, 0.142), # will be ignored later in EFTfitterModel + (:meas1, :meas4_10_20, 0.143), # will be ignored later in EFTfitterModel + (:meas4_0_5, :meas4_5_10, 0.412), # will be ignored later in EFTfitterModel + (:meas4_0_5, :meas4_5_10, 0.413), + (:meas4_0_5, :meas4_0_5, 0.9) # will be ignored later in EFTfitterModel +) + +correlations1 = ( + unc1 = NoCorrelation(active=true), + + # wrong matrix size for number of measurements, will be ignored if active=false: + unc2 = Correlation([1.0 0.5 0.7; + 0.5 1.0 0.6; + 0.7 0.6 1.0], active=false), + + unc3 = Correlation(corr_matrix) +) + +nuisance_correlations = ( + ρ1 = NuisanceCorrelation(:unc1, :meas1, :meas3, 0..0.5), + ρ2 = NuisanceCorrelation(:unc1, :meas1, :meas2, truncated(Normal(0, 1), 0, 0.9)), +) + +model1 = EFTfitterModel(parameters1, measurements1, correlations1, limits=nothing, nuisances=nuisance_correlations, CovarianceType=Matrix) + + + + + +posterior = PosteriorMeasure(model1) +m = posterior.likelihood.density._d + +v2 = (p1 = 1.3646163105428428, p2 = 0.0669263861339656, ρ1=0.2, ρ2=0.3 ) + +EFTfitter.get_current_invcov(m, v2) + + +#@btime EFTfitter.evaluate_funcs!(m.mus, m.observable_functions, v, m) +#187.771 ns (14 allocations: 800 bytes) + + + + +using DensityInterface +using BenchmarkTools +v = rand(parameters) + +v = (C1 = 1.3646163105428428, C2 = 0.0669263861339656) + +#@code_warntype EFTfitter.evaluate_funcs!(m.mus, m.observable_functions, v, m) + +# logdensityof(posterior)(v) +@btime logdensityof(posterior)(v) # -71.62957930828858 +# 350.000 ns (18 allocations: 1.19 KiB) +# 633.523 ns (18 allocations: 1.19 KiB) +# 983.333 ns (18 allocations: 1.19 KiB) + +@btime [m.observable_functions[i](v) for i in eachindex(m.observable_functions)] + +@code_warntype logdensityof(posterior)(v) +@code_llvm logdensityof(posterior)(v) + +v = (C1 = 1.3777803296719995, C2 = -0.13471933089976204) +logdensityof(posterior)(v) # -139.56233066526895 + +v = (C1 = 0.4310417711590908, C2 = 0.5097850986277717) +logdensityof(posterior)(v) # -2162.171314291685 + + +import Random +Random.seed!(1234) +for v in [rand(parameters) for i in 1:10000] + println(logdensityof(posterior)(v)) +end + + + +@btime logdensityof(posterior)(v) #btime: 593.220 ns (26 allocations: 1.34 KiB) + +algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4, strict=false) +include("ram_sampler.jl") +algorithm = RAMSampler(nchains=1, nsteps=6*10^5, nburnin=4*10^5) + +@time samples = bat_sample(posterior, algorithm).result; + + # For further information on settings & algorithms when sampling with BAT.jl # see the BAT.jl [tutorial](https://bat.github.io/BAT.jl/dev/tutorial/#Parameter-Space-Exploration-via-MCMC) # and [documentation](https://bat.github.io/BAT.jl/dev/stable_api/#BAT.bat_sample). @@ -64,3 +182,73 @@ savefig(p, "plot_1d.pdf") # This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl +r = rand(500) +using LinearAlgebra +using BenchmarkTools +@btime Diagonal(r.^2) + +N = 50 +r = rand(N)*10 +M = rand(N, N) + +function addunc!(M, r) + for i in 1:size(M)[1] + M[i, i] += r[i]^2 + end +end + +function addunc2(M, r) + return M+Diagonal(r.^2) +end + +@btime addunc!(M, r) + +@btime addunc2(M, r) + + +M = [1 2; 3 4] +M2 = [1.5 2; 3 5] + +invM = inv(M) +invM2 = inv(M2) + +#------ Dispatch on Val ----------------------- +f(a::Val{false}) = println("f=False") +f(a::Val{true}) = println("f=True") +f(a) = println("??") + +@btime f(Val(false)) +@btime f(3) + + + +#---------------------------------------------- +#- Testing Dispatch on Type of Field in struct + +struct MyStruct{AT, BT} + A::AT + B::BT + C::Float64 +end + +f(ms::MyStruct) = 1 + +f(ms::MyStruct{String, Float64}) = "Hi" + +f(ms::MyStruct{Float64, String}) = "Ho" + + +m = MyStruct(1., 2., 3.) +m = MyStruct("H", 2., 3.) +m = MyStruct(3, "H0", 3.) + +f(m) +#--------------------------------s-------------- + + + +M = rand(4, 100) + +m = view(M, 1, :) +x = rand(100) +r = m - x \ No newline at end of file diff --git a/examples/tutorial/tutorial_inputs.jl b/examples/tutorial/tutorial_inputs.jl index 3177dc2..706bc05 100644 --- a/examples/tutorial/tutorial_inputs.jl +++ b/examples/tutorial/tutorial_inputs.jl @@ -42,6 +42,12 @@ function xsec1(params) c = [20.12, 5.56, 325.556] return c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 end +# +# function xsec1(params) +# c = [20.12, 5.56, 325.556] +# result = c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 +# return (result, 0.1 * params.C1 * result) +# end function xsec2(params) coeffs = [2.12, 4.3, 12.6] diff --git a/src/EFTfitter.jl b/src/EFTfitter.jl index b8d4e3b..473fe3c 100755 --- a/src/EFTfitter.jl +++ b/src/EFTfitter.jl @@ -12,6 +12,9 @@ using Parameters using RecipesBase using Requires using ValueShapes +using TypedTables +using BenchmarkTools # TODO: make optional +using SparseArrays using DensityInterface import DensityInterface: logdensityof @@ -30,3 +33,6 @@ function __init__() end end # module + + +#rm: ArraysOfArrays, RobustAdaptiveMetropolisSampler \ No newline at end of file diff --git a/src/EFTfitterDensity.jl b/src/EFTfitterDensity.jl index e1fb339..8b378e7 100755 --- a/src/EFTfitterDensity.jl +++ b/src/EFTfitterDensity.jl @@ -1,5 +1,4 @@ export EFTfitterDensity -export EFTfitterDensityNuisance struct _NuisanceCorrelation unc::Int @@ -8,70 +7,116 @@ struct _NuisanceCorrelation key::Symbol # parameter key end -struct EFTfitterDensity - measured_values::Vector{Float64} - observable_functions::Vector{Function} - observable_mins::Vector{Float64} - observable_maxs::Vector{Float64} - invcov::Array{Float64, 2} - check_bounds::Bool +abstract type MatrixType end + +struct CovarianceMatrix{T} <: MatrixType + m::T end -@inline DensityInterface.DensityKind(::EFTfitterDensity) = IsDensity() +struct InverseCovarianceMatrix{T} <: MatrixType + m::T +end + +abstract type ModelUncertaintiesStatus end + +struct HasModelUncertainties <: ModelUncertaintiesStatus end +struct NoModelUncertainties <: ModelUncertaintiesStatus end + +get_model_uncertainties_status(predictions::Vector{<:Real}) = NoModelUncertainties() +get_model_uncertainties_status(predictions) = HasModelUncertainties() + +abstract type AbstractNuisanceCorrelations end +struct NoNuissanceCorrelations <: AbstractNuisanceCorrelations end + +struct NuisanceCorrelations{T} <: AbstractNuisanceCorrelations + nuisances::Vector{_NuisanceCorrelation} + covs::Vector{T} +end + +NuisanceCorrelations(nuisances, m::EFTfitterModel) = NuisanceCorrelations(nuisances, get_covariances(m)) + -struct EFTfitterDensityNuisance + +abstract type LimitsStatus end +struct HasLimits <: LimitsStatus end +struct NoLimits <: LimitsStatus end + + +struct EFTfitterDensity{M<:MatrixType, MU<:ModelUncertaintiesStatus, NC<:AbstractNuisanceCorrelations, L<:LimitsStatus} measured_values::Vector{Float64} observable_functions::Vector{Function} observable_mins::Vector{Float64} observable_maxs::Vector{Float64} - covs::Vector{Array{Float64, 2}} - nuisances::Vector{_NuisanceCorrelation} + weights::Vector{Float64} + matrix::M + original_diag::Vector{Float64} check_bounds::Bool + predictions::Matrix{Float64} + prediction_uncertainties::Matrix{Float64} + limit_distributions::Vector{Distribution} + limit_functions::Vector{Function} + limit_predictions::Matrix{Float64} + limit_uncertainties::Matrix{Float64} + mus::MU + ls::L + nuisance_correlations::NC end -@inline DensityInterface.DensityKind(::EFTfitterDensityNuisance) = IsDensity() - - -function EFTfitterDensity(m::EFTfitterModel) - n = length(m.measurements) - measured_values = [meas.value for meas in m.measurements] - observable_functions = [meas.observable.func for meas in m.measurements] - observable_mins = [meas.observable.min for meas in m.measurements] - observable_maxs = [meas.observable.max for meas in m.measurements] - - bu = any(x->x!=Inf, observable_maxs) - bl = any(x->x!=-Inf, observable_mins) - check_bounds = any([bu, bl]) +@inline DensityInterface.DensityKind(::EFTfitterDensity) = IsDensity() +function get_matrix(mus::NoModelUncertainties, ncs::NoNuissanceCorrelations, m::EFTfitterModel, weights) invcov = inv(get_total_covariance(m)) + + invcov_weighted = weights .* invcov + M_invcov = m.CovarianceType(invcov_weighted) - return EFTfitterDensity( - measured_values, - observable_functions, - observable_mins, - observable_maxs, - invcov, - check_bounds - ) + return InverseCovarianceMatrix(M_invcov), diag(invcov_weighted) end -function EFTfitterDensityNuisance(m::EFTfitterModel) - n = length(m.measurements) - measured_values = [meas.value for meas in m.measurements] - observable_functions = [meas.observable.func for meas in m.measurements] - observable_mins = [meas.observable.min for meas in m.measurements] - observable_maxs = [meas.observable.max for meas in m.measurements] - - bu = any(x->x!=Inf, observable_maxs) - bl = any(x->x!=-Inf, observable_mins) - check_bounds = any([bu, bl]) +function get_matrix(mus::ModelUncertaintiesStatus, ncs::AbstractNuisanceCorrelations, m::EFTfitterModel, weights) + cov = get_total_covariance(m) + M_cov = m.CovarianceType(cov) + return CovarianceMatrix(M_cov), diag(cov) +end - covs = get_covariances(m) +function EFTfitterDensity(m::EFTfitterModel) + measured_values = Float64[meas.value for meas in m.measurements] + observable_functions = Function[meas.observable.prediction for meas in m.measurements] + observable_mins = Float64[meas.observable.min for meas in m.measurements] + observable_maxs = Float64[meas.observable.max for meas in m.measurements] + + observable_weights = Float64[meas.observable.weight for meas in m.measurements] + weights = length(observable_weights) * normalize(observable_weights, 1) + + upper_bounds = any(x->x!=Inf, observable_maxs) + lower_bounds = any(x->x!=-Inf, observable_mins) + check_bounds = any([upper_bounds, lower_bounds]) + + #todo: make this a function + #TODO: add a warning if functions are too slow or take too much memory + v = rand(m.parameters) + predicted_values = [f(v) for f in observable_functions] + mus = get_model_uncertainties_status(predicted_values) + + nthreads = Threads.nthreads() + predictions = zeros(nthreads, length(observable_functions)) + prediction_uncertainties = zeros(nthreads, length(observable_functions)) + + #TODO: add limits + ls = NoLimits() + limit_functions = Function[] + limit_distributions = Distribution[] + limit_predictions = zeros(nthreads, length(limit_functions)) + limit_uncertainties = zeros(nthreads, length(limit_functions)) + + #TODO: add nuisance correlations meas_keys = collect(keys(m.measurements)) unc_keys = collect(keys(m.correlations)) + @show m.nuisances#zip(m.nuisances, collect(keys(m.nuisances))) + nuisances = _NuisanceCorrelation[] for (nui, nui_k) in zip(m.nuisances, collect(keys(m.nuisances))) unc = findfirst(x->x==nui.unc_key , unc_keys) @@ -80,98 +125,149 @@ function EFTfitterDensityNuisance(m::EFTfitterModel) push!(nuisances, _NuisanceCorrelation(unc, i, j, nui_k)) end - return EFTfitterDensityNuisance( + nui = isempty(nuisances) ? NoNuissanceCorrelations() : NuisanceCorrelations(nuisances, m) + + #TODO: make this a function returning a matrix. depending on if there are model uncertainties or not, and if we want to use cholesky + matrix, original_diagonal = get_matrix(mus, nui, m, weights) + + + return EFTfitterDensity( measured_values, observable_functions, observable_mins, observable_maxs, - covs, - nuisances, - check_bounds - ) + weights, + matrix, + original_diagonal, + check_bounds, + predictions, + prediction_uncertainties, + limit_distributions, + limit_functions, + limit_predictions, + limit_uncertainties, + mus, + ls, + nui + ) end +function make_dist(limit::GaussianUpperLimit) + return Normal_from_limit(limit.best_fit, limit.limit, limit.cl) +end + function iswithinbounds(r::Float64, min::Float64, max::Float64) return min <= r <= max end - +# TODO: add dispatch, return 1 by default function check_obs_bounds(r::Vector{Float64}, mins::Vector{Float64}, maxs::Vector{Float64}) withinbounds = [iswithinbounds(r[i], mins[i], maxs[i]) for i in 1:length(r)] - return all(withinbounds) + all(withinbounds) ? (return 1.) : (return -Inf) end -function evaluate_funcs(arr::Vector{Function}, params) - return [arr[i](params) for i in 1:length(arr)] +# without model uncertainties +function evaluate_funcs!(mus::NoModelUncertainties, arr::Vector{Function}, params, m) + for i in eachindex(arr) + res::Prediction = Prediction(arr[i](params)) + m.predictions[Threads.threadid(), i] = res.pred + end end +# with model uncertainties +function evaluate_funcs!(mus::HasModelUncertainties, arr::Vector{Function}, params, m) + for i in eachindex(arr) + res::Prediction = Prediction(arr[i](params)) + m.predictions[Threads.threadid(), i] = res.pred + m.prediction_uncertainties[Threads.threadid(), i] = res.unc + end +end + + + function DensityInterface.logdensityof( m::EFTfitterDensity, params ) - r = evaluate_funcs(m.observable_functions, params) + #Todo: move into calculate_likelihood? + evaluate_funcs!(m.mus, m.observable_functions, params, m) - if m.check_bounds - ib = check_obs_bounds(r, m.observable_mins, m.observable_maxs) - if ib == false - return -Inf - end - end + #TODO: check_observable_bounds + + + result = calculate_likelihood(m, m.mus, m.nuisance_correlations) - r = r-m.measured_values - r1 = m.invcov*r + return result +end + +# no model uncertainties, no limits, weights are already in the covariance matrix +function calculate_likelihood(m::EFTfitterDensity, mus::NoModelUncertainties, ns::NoNuissanceCorrelations) + predictions = view(m.predictions, Threads.threadid(), :) + + @assert isa(m.matrix, InverseCovarianceMatrix) + + r = predictions-m.measured_values + r1 = m.matrix.m*r result = -dot(r, r1) return 0.5*result end -function DensityInterface.logdensityof( - m::EFTfitterDensityNuisance, - params -) - r = evaluate_funcs(m.observable_functions, params) - if m.check_bounds - ib = check_obs_bounds(r, m.observable_mins, m.observable_maxs) - if ib == false - return -Inf - end +# TODO: specify for cholesky lower +function add_model_uncertainties!(mus::HasModelUncertainties, m, r) + for i in 1:size(m.matrix.m, 1) + m.matrix.m[i, i] = m.original_diag[i] + r[i]^2 #TODO: check that original_diag is not affected by nuisance correlations end +end - invcov = get_current_invcov(m, params) +function add_model_uncertainties!(mus::NoModelUncertainties, m, r) + nothing +end + +# with model uncertainties, no limits +function calculate_likelihood(m::EFTfitterDensity, mus, nc) + predictions = view(m.predictions, Threads.threadid(), :) + prediction_uncertainties = view(m.prediction_uncertainties, Threads.threadid(), :) + + set_matrix_to_current_cov!(nc, m, params) + + @assert isa(m.matrix, CovarianceMatrix) + add_model_uncertainties!(mus, m, prediction_uncertainties) + invcov = inv(m.matrix.m) - r = r-m.measured_values + r = m.weights .* (predictions-m.measured_values) # we r1 = invcov*r + result = -dot(r, r1) return 0.5*result end -function get_current_invcov(m, params) - for nui in m.nuisances +function set_matrix_to_current_cov!(nc::NuisanceCorrelations, m, params) + for nui in m.nuisance_correlations.nuisances i = nui.i; j = nui.j - cov = params[nui.key] * sqrt(m.covs[nui.unc][i, i]) * sqrt(m.covs[nui.unc][j, j]) - m.covs[nui.unc][i, j] = cov - m.covs[nui.unc][j, i] = cov + cov = params[nui.key] * sqrt(m.nuisance_correlations.covs[nui.unc][i, i]) * sqrt(m.nuisance_correlations.covs[nui.unc][j, j]) + m.nuisance_correlations.covs[nui.unc][i, j] = cov + m.nuisance_correlations.covs[nui.unc][j, i] = cov end - total_cov = sum(m.covs) - invcov = inv(total_cov) + m.matrix = CovarianceMatrix(sum(m.nuisance_correlations.covs)) +end + +function set_matrix_to_current_cov!(nc::NoNuissanceCorrelations, m, params) + nothing end function BAT.PosteriorMeasure(m::EFTfitterModel) - if has_nuisance_correlations(m) - likelihood = EFTfitterDensityNuisance(m) - return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) - else - likelihood = EFTfitterDensity(m) - return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) - end + likelihood = EFTfitterDensity(m) + return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) end + \ No newline at end of file diff --git a/src/EFTfitterDensity_old.jl b/src/EFTfitterDensity_old.jl new file mode 100644 index 0000000..e335bfa --- /dev/null +++ b/src/EFTfitterDensity_old.jl @@ -0,0 +1,499 @@ +export EFTfitterDensity +export EFTfitterDensityNuisance + +struct _NuisanceCorrelation + unc::Int + i::Int + j::Int + key::Symbol # parameter key +end + +abstract type MatrixType end + +struct CovarianceMatrix{T} <: MatrixType + m::T +end +struct InverseCovarianceMatrix{T} <: MatrixType + m::T +end + +abstract type ModelUncertaintiesStatus end + +struct HasModelUncertainties <: ModelUncertaintiesStatus end +struct NoModelUncertainties <: ModelUncertaintiesStatus end + +get_model_uncertainties_status(predictions::Vector{<:Real}) = NoModelUncertainties() +get_model_uncertainties_status(predictions) = HasModelUncertainties() + +abstract type AbstractNuisanceCorrelations end +struct NoNuissanceCorrelations <: AbstractNuisanceCorrelations end + +struct NuisanceCorrelations{T} <: AbstractNuisanceCorrelations + nuisances::Vector{_NuisanceCorrelation} + covs::Vector{T} +end + +NuisanceCorrelations(nuisances, m::EFTfitterModel) = NuisanceCorrelations(nuisances, get_covariances(m)) + + + +abstract type LimitsStatus end +struct HasLimits <: LimitsStatus end +struct NoLimits <: LimitsStatus end + + +struct EFTfitterDensity{M<:MatrixType, MU<:ModelUncertaintiesStatus, NC<:AbstractNuisanceCorrelations, L<:LimitsStatus} + measured_values::Vector{Float64} + observable_functions::Vector{Function} + observable_mins::Vector{Float64} + observable_maxs::Vector{Float64} + weights::Vector{Float64} + matrix::M + original_diag::Vector{Float64} + check_bounds::Bool + predictions::Matrix{Float64} + prediction_uncertainties::Matrix{Float64} + limit_distributions::Vector{Distribution} + limit_functions::Vector{Function} + limit_predictions::Matrix{Float64} + limit_uncertainties::Matrix{Float64} + mus::MU + ls::L + nuisance_correlations::NC +end +@inline DensityInterface.DensityKind(::EFTfitterDensity) = IsDensity() + + +# TODO: remove + +# struct EFTfitterDensityNuisance +# measured_values::Vector{Float64} +# observable_functions::Vector{Function} +# observable_mins::Vector{Float64} +# observable_maxs::Vector{Float64} +# covs::Vector{Array{Float64, 2}} +# nuisances::Vector{_NuisanceCorrelation} +# check_bounds::Bool +# end +# @inline DensityInterface.DensityKind(::EFTfitterDensityNuisance) = IsDensity() + + +# struct EFTfitterDensityWithLimits +# measured_values::Vector{Float64} +# observable_functions::Vector{Function} +# observable_mins::Vector{Float64} +# observable_maxs::Vector{Float64} +# limit_distributions::Vector{Distribution} +# limit_functions::Vector{Function} +# invcov::Array{Float64, 2} +# check_bounds::Bool +# end +# @inline DensityInterface.DensityKind(::EFTfitterDensityWithLimits) = IsDensity() + +function prepare_cov_matrix(mus::NoModelUncertainties, ncs::NoNuissanceCorrelations, m::EFTfitterModel, weights) + invcov = inv(get_total_covariance(m)) + + invcov_weighted = weights .* invcov + M_invcov = m.CovarianceType(invcov_weighted) + + return InverseCovarianceMatrix(M_invcov), diag(invcov_weighted) +end + +function prepare_cov_matrix(mus::ModelUncertaintiesStatus, ncs::AbstractNuisanceCorrelations, m::EFTfitterModel, weights) + cov = get_total_covariance(m) + M_cov = m.CovarianceType(cov) + + return CovarianceMatrix(M_cov), diag(cov) +end + + +function EFTfitterDensity(m::EFTfitterModel) + measured_values = Float64[meas.value for meas in m.measurements] + observable_functions = Function[meas.observable.prediction for meas in m.measurements] + observable_mins = Float64[meas.observable.min for meas in m.measurements] + observable_maxs = Float64[meas.observable.max for meas in m.measurements] + + observable_weights = Float64[meas.observable.weight for meas in m.measurements] + weights = length(observable_weights) * normalize(observable_weights, 1) + + upper_bounds = any(x->x!=Inf, observable_maxs) + lower_bounds = any(x->x!=-Inf, observable_mins) + check_bounds = any([upper_bounds, lower_bounds]) + + #todo: make this a function + #TODO: add a warning if functions are too slow or take too much memory + v = rand(m.parameters) + predicted_values = [f(v) for f in observable_functions] + mus = get_model_uncertainties_status(predicted_values) + + nthreads = Threads.nthreads() + predictions = zeros(nthreads, length(observable_functions)) + prediction_uncertainties = zeros(nthreads, length(observable_functions)) + + #TODO: add limits + ls = NoLimits() + limit_functions = Function[] + limit_distributions = Distribution[] + limit_predictions = zeros(nthreads, length(limit_functions)) + limit_uncertainties = zeros(nthreads, length(limit_functions)) + + #TODO: add nuisance correlations + meas_keys = collect(keys(m.measurements)) + unc_keys = collect(keys(m.correlations)) + + nuisances = _NuisanceCorrelation[] + for (nui, nui_k) in zip(m.nuisances, collect(keys(m.nuisances))) + unc = findfirst(x->x==nui.unc_key , unc_keys) + i = findfirst(x->x==nui.meas1 , meas_keys) + j = findfirst(x->x==nui.meas2 , meas_keys) + push!(nuisances, _NuisanceCorrelation(unc, i, j, nui_k)) + end + + nui = isempty(nuisances) ? NoNuissanceCorrelations() : NuisanceCorrelations(nuisances, m) + + #TODO: make this a function returning a matrix. depending on if there are model uncertainties or not, and if we want to use cholesky + matrix, original_diagonal = prepare_cov_matrix(mus, ncs, m, weights) + + + return EFTfitterDensity( + measured_values, + observable_functions, + observable_mins, + observable_maxs, + weights, + matrix, + original_diagonal, + check_bounds, + predictions, + prediction_uncertainties, + limit_distributions, + limit_functions, + limit_predictions, + limit_uncertainties, + mus, + ls, + nui + ) +end + + +using SpecialFunctions +function Normal_from_limit(best_fit_value, limit, confidence_level) + μ = best_fit_value + p = confidence_level + q = limit + + σ = (q - μ)/(sqrt(2)*erfinv(2*p-1)) + + return Normal(μ, σ) +end + +function make_dist(limit::GaussianUpperLimit) + return Normal_from_limit(limit.best_fit, limit.limit, limit.cl) +end + +# function EFTfitterDensityWithLimits(m::EFTfitterModelWithLimits) +# n = length(m.measurements) +# measured_values = [meas.value for meas in m.measurements] +# observable_functions = [meas.observable.prediction for meas in m.measurements] +# observable_mins = [meas.observable.min for meas in m.measurements] +# observable_maxs = [meas.observable.max for meas in m.measurements] + +# bu = any(x->x!=Inf, observable_maxs) +# bl = any(x->x!=-Inf, observable_mins) +# check_bounds = any([bu, bl]) + +# limit_observable_functions = [limit.observable.prediction for limit in m.limits] +# limit_distributions = [make_dist(limit) for limit in m.limits] + +# invcov = inv(get_total_covariance(m)) + +# return EFTfitterDensityWithLimits( +# measured_values, +# observable_functions, +# observable_mins, +# observable_maxs, +# limit_distributions, +# limit_observable_functions, +# invcov, +# check_bounds +# ) +# end + +# function EFTfitterDensityNuisance(m::EFTfitterModel) +# n = length(m.measurements) +# measured_values = [meas.value for meas in m.measurements] +# observable_functions = [meas.observable.prediction for meas in m.measurements] +# observable_mins = [meas.observable.min for meas in m.measurements] +# observable_maxs = [meas.observable.max for meas in m.measurements] + +# bu = any(x->x!=Inf, observable_maxs) +# bl = any(x->x!=-Inf, observable_mins) +# check_bounds = any([bu, bl]) + + +# covs = get_covariances(m) + +# meas_keys = collect(keys(m.measurements)) +# unc_keys = collect(keys(m.correlations)) + + +# nuisances = _NuisanceCorrelation[] +# for (nui, nui_k) in zip(m.nuisances, collect(keys(m.nuisances))) +# unc = findfirst(x->x==nui.unc_key , unc_keys) +# i = findfirst(x->x==nui.meas1 , meas_keys) +# j = findfirst(x->x==nui.meas2 , meas_keys) +# push!(nuisances, _NuisanceCorrelation(unc, i, j, nui_k)) +# end + +# return EFTfitterDensityNuisance( +# measured_values, +# observable_functions, +# observable_mins, +# observable_maxs, +# covs, +# nuisances, +# check_bounds +# ) +# end + + + +function iswithinbounds(r::Float64, min::Float64, max::Float64) + return min <= r <= max +end + +# TODO: add dispatch, return 1 by default +function check_obs_bounds(r::Vector{Float64}, mins::Vector{Float64}, maxs::Vector{Float64}) + withinbounds = [iswithinbounds(r[i], mins[i], maxs[i]) for i in 1:length(r)] + all(withinbounds) ? (return 1.) : (return -Inf) +end + + +# why is this slower? +# function evaluate_funcs!(mus::NoModelUncertainties, arr::Vector{Function}, params, m) +# for i in eachindex(arr) +# m.predictions[Threads.threadid(), i] = arr[i](params) +# end +# end + + +# without model uncertainties +function evaluate_funcs!(mus::NoModelUncertainties, arr::Vector{Function}, params, m) + for i in eachindex(arr) + res::Prediction = Prediction(arr[i](params)) + m.predictions[Threads.threadid(), i] = res.pred + end +end + +# with model uncertainties +function evaluate_funcs!(mus::HasModelUncertainties, arr::Vector{Function}, params, m) + for i in eachindex(arr) + res::Prediction = Prediction(arr[i](params)) + m.predictions[Threads.threadid(), i] = res.pred + m.prediction_uncertainties[Threads.threadid(), i] = res.unc + end +end + + + +# # old: +# function DensityInterface.logdensityof( +# m::EFTfitterDensity, +# params +# ) +# r = evaluate_funcs(m.observable_functions, params) + +# if m.check_bounds +# ib = check_obs_bounds(r, m.observable_mins, m.observable_maxs) +# if ib == false +# return -Inf +# end +# end + +# r = r-m.measured_values +# r1 = m.invcov*r +# result = -dot(r, r1) + +# return 0.5*result +# end + + + +function DensityInterface.logdensityof( + m::EFTfitterDensity, + params +) + #Todo: move into calculate_likelihood? + evaluate_funcs!(m.mus, m.observable_functions, params, m) + + #TODO: check_observable_bounds + + + result = calculate_likelihood(m, m.mus, m.ls) + + return result +end + +# no model uncertainties, no limits, weights are already in the covariance matrix +function calculate_likelihood(m::EFTfitterDensity, mus::NoModelUncertainties, ls::NoLimits) + predictions = view(m.predictions, Threads.threadid(), :) + + @assert isa(m.matrix, InverseCovarianceMatrix) + + r = predictions-m.measured_values + r1 = m.matrix.m*r + result = -dot(r, r1) + + return 0.5*result +end + + +# TODO: specify for cholesky lower +function add_model_uncertainties!(m, r) + for i in 1:size(m.matrix.m, 1) + m.matrix.m[i, i] = m.original_diag[i] + r[i]^2 + end +end + +# with model uncertainties, no limits +function calculate_likelihood(m::EFTfitterDensity, mus::HasModelUncertainties, ls::NoLimits) + predictions = view(m.predictions, Threads.threadid(), :) + prediction_uncertainties = view(m.prediction_uncertainties, Threads.threadid(), :) + + @assert isa(m.matrix, CovarianceMatrix) + add_model_uncertainties!(m, prediction_uncertainties) + invcov = inv(m.matrix.m) + + r = m.weights .* (predictions-m.measured_values) # we + r1 = invcov*r + + result = -dot(r, r1) + + return 0.5*result +end + +# function DensityInterface.logdensityof( +# m::EFTfitterDensityWithLimits, +# params +# ) +# r = evaluate_funcs(m.observable_functions, params) + +# if m.check_bounds +# ib = check_obs_bounds(r, m.observable_mins, m.observable_maxs) +# if ib == false +# return -Inf +# end +# end + +# r = r-m.measured_values +# r1 = m.invcov*r +# result = -dot(r, r1) +# gaussian_result = 0.5*result + + +# r_limits = evaluate_funcs(m.limit_functions, params) +# ls=0. +# for i in eachindex(m.limit_distributions) +# ls += pdf(m.limit_distributions[i], r_limits[i]) +# end + + +# return gaussian_result + ls +# end + + +# function DensityInterface.logdensityof( +# m::EFTfitterDensityNuisance, +# params +# ) +# r = evaluate_funcs(m.observable_functions, params) + +# if m.check_bounds +# ib = check_obs_bounds(r, m.observable_mins, m.observable_maxs) +# if ib == false +# return -Inf +# end +# end + +# invcov = get_current_invcov(m, params) + +# r = r-m.measured_values +# r1 = invcov*r +# result = -dot(r, r1) + +# return 0.5*result +# end + + +function get_current_invcov(m, params) + for nui in m.nuisance_correlations.nuisances + i = nui.i; j = nui.j + + cov = params[nui.key] * sqrt(m.nuisance_correlations.covs[nui.unc][i, i]) * sqrt(m.nuisance_correlations.covs[nui.unc][j, j]) + m.nuisance_correlations.covs[nui.unc][i, j] = cov + m.nuisance_correlations.covs[nui.unc][j, i] = cov + end + + total_cov = sum(m.nuisance_correlations.covs) + invcov = inv(total_cov) +end + + + +function BAT.PosteriorMeasure(m::EFTfitterModel) + # if has_nuisance_correlations(m) # TODO: remove + # likelihood = EFTfitterDensityNuisance(m) + # return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) + # else + # likelihood = EFTfitterDensity(m) + # return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) + # end + likelihood = EFTfitterDensity(m) + return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) +end + +# function BAT.PosteriorMeasure(m::EFTfitterModelWithLimits) +# likelihood = EFTfitterDensityWithLimits(m) +# return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) + +# end + + +# x = rand(5) +# M = rand(5,5) +# w = [4,4,4,4,5] +# w = length(w)*normalize(w, 1) + +# mean(w) + + +# x = ones(5) + +# r = dot(w.*x, M*x) + +# w .* x +# x + +# M2 = w .* M +# r2 = dot(x, M2*x) + +# r_unw = dot(x, M*x) + +# r_unw/r + +# w = [1, 2, 2, 1, 3] +# w = normalize(w, 1) + +# M2 =x .* M + +# x2 = w.*x +# r = dot(x2, M*x) + +# r2 = dot(x, M2*x) + + + + + + \ No newline at end of file diff --git a/src/EFTfitterModel.jl b/src/EFTfitterModel.jl index e5470b2..0a3be49 100755 --- a/src/EFTfitterModel.jl +++ b/src/EFTfitterModel.jl @@ -41,37 +41,44 @@ model = EFTfitterModel(parameters, measurements, correlations, nuisances) # with struct EFTfitterModel parameters::BAT.NamedTupleDist measurements::NamedTuple{<:Any, <:Tuple{Vararg{Measurement}}} - measurementdistributions::NamedTuple{<:Any, <:Tuple{Vararg{MeasurementDistribution}}} + measured_distributions::NamedTuple{<:Any, <:Tuple{Vararg{MeasurementDistribution}}} + limits::Union{NamedTuple{<:Any, <:Tuple{Vararg{AbstractLimit}}}, Nothing} correlations::NamedTuple{<:Any, <:Tuple{Vararg{Correlation}}} nuisances::Union{NamedTuple{<:Any, <:Tuple{Vararg{NuisanceCorrelation}}}, Nothing} + CovarianceType::Union{Type, Function} end function EFTfitterModel( parameters::BAT.NamedTupleDist, measurements::NamedTuple{<:Any, <:Tuple{Vararg{AbstractMeasurement}}}, - correlations::NamedTuple{<:Any, <:Tuple{Vararg{AbstractCorrelation}}}, - nuisances::Union{NamedTuple{<:Any, <:Tuple{Vararg{NuisanceCorrelation}}}, Nothing} = nothing + correlations::NamedTuple{<:Any, <:Tuple{Vararg{AbstractCorrelation}}}; + limits::Union{NamedTuple{<:Any, <:Tuple{Vararg{AbstractLimit}}}, Nothing} = nothing, + nuisances::Union{NamedTuple{<:Any, <:Tuple{Vararg{NuisanceCorrelation}}}, Nothing} = nothing, + CovarianceType::Union{Type, Function} = Matrix{Float64} ) measurement_vec, measurement_keys = unpack(measurements) correlation_vec, uncertainty_keys = unpack(correlations) # convert elements of MeasurementDistribution to Measurement for each bin binned_measurements, binned_measurement_keys = convert_to_bins(measurement_vec, measurement_keys) - # use only active measurements/bins - active_measurements, active_measurement_keys, corrs = only_active_measurements(binned_measurements, binned_measurement_keys, correlation_vec) - # use only active uncertainties and correlations - active_measurements, active_correlations, uncertainty_keys = only_active_uncertainties(active_measurements, corrs, uncertainty_keys) - correlation_nt = namedtuple(uncertainty_keys, active_correlations) + active_measurements, active_measurement_keys, all_correlations = only_active_measurements(binned_measurements, binned_measurement_keys, correlation_vec) + active_measurements, active_correlations, active_uncertainty_keys = only_active_uncertainties(active_measurements, all_correlations, uncertainty_keys) + active_limits_nt = only_active_limits(limits) + + correlation_nt = namedtuple(active_uncertainty_keys, active_correlations) measurement_nt = namedtuple(active_measurement_keys, active_measurements) - meas_dists_nt = create_distributions(measurements, uncertainty_keys) - nuisances_nt = only_active_nuisances(nuisances, active_measurement_keys, uncertainty_keys) + + meas_dists_nt = create_distributions(measurements, active_uncertainty_keys) + nuisances_nt = only_active_nuisances(nuisances, active_measurement_keys, active_uncertainty_keys) params = add_nuisance_parameters(parameters, nuisances_nt) - return EFTfitterModel(params, measurement_nt, meas_dists_nt, correlation_nt, nuisances_nt) + return EFTfitterModel(params, measurement_nt, meas_dists_nt, active_limits_nt, correlation_nt, nuisances_nt, CovarianceType) end + + #=============================================================# """ get_parameters(m::EFTfitterModel) @@ -121,8 +128,8 @@ Note: The upper and lower limits are ignored and for each unique `Function`s onl """ function get_observables(model::EFTfitterModel) meas = get_measurements(model) - obs = unique(Observable.([m.observable.func for m in values(meas)])) - obs_names = [string(o.func) for o in obs] + obs = unique(Observable.([m.observable.prediction for m in NamedTupleTools.values(meas)])) + obs_names = [string(o.prediction) for o in obs] observables_nt = namedtuple(obs_names, obs) end @@ -179,6 +186,23 @@ function only_active_measurements( return measurements, measurement_keys, corrs end + +function only_active_limits( + limits::NamedTuple{<:Any, <:Tuple{Vararg{AbstractLimit}}} +) + limit_values, limit_keys = unpack(limits) + active_idxs = filter(x->limit_values[x].active, eachindex(limit_values)) + + limit_values = limit_values[active_idxs] + limit_keys = limit_keys[active_idxs] + + return namedtuple(limit_keys, limit_values) +end + +only_active_limits(limits::Nothing) = nothing + + + #TODO: rename? function get_correlations( correlation::Correlation, @@ -309,22 +333,31 @@ function check_nuisance( end +#TODO: add functions to return covariance with CovarianceType function get_total_covariance(m::EFTfitterModel) covs = get_covariances(m) - total_cov = Symmetric(sum(covs)) - + total_cov = sum(covs) + return total_cov end - function get_covariances(m::EFTfitterModel) unc_values = [[Float64(meas.uncertainties[u]) for meas in m.measurements] for u in keys(m.correlations)] corrs = [c.matrix for c in m.correlations] - covs = [Symmetric(σ*ρ*σ) for (σ, ρ) in zip(diagm.(unc_values), corrs)] + # symmetrize the matrix + return covs = [Matrix(Symmetric(σ*ρ*σ)) for (σ, ρ) in zip(diagm.(unc_values), corrs)] end +# function get_covariances(m::EFTfitterModel) +# unc_values = [[Float64(meas.uncertainties[u]) for meas in m.measurements] for u in keys(m.correlations)] +# corrs = [c.matrix for c in m.correlations] + +# # symmetrize the matrix and use the CovarianceType +# return covs = [m.CovarianceType(Matrix(Symmetric(σ*ρ*σ))) for (σ, ρ) in zip(diagm.(unc_values), corrs)] +# end + function Nbins(measurements::NamedTuple{<:Any, <:Tuple{Vararg{AbstractMeasurement}}}) @@ -439,3 +472,7 @@ function keys_of_bins( keys = reduce(vcat, keys_of_bins.(measurements, measurement_keys)) return keys end + + + + diff --git a/src/datatypes.jl b/src/datatypes.jl index e231bae..7af6528 100755 --- a/src/datatypes.jl +++ b/src/datatypes.jl @@ -7,33 +7,46 @@ export Correlation export NoCorrelation export NuisanceCorrelation +# TODO: Documentation +struct Prediction + pred::Float64 + unc::Float64 +end + +Prediction(a::Float64) = Prediction(a, 0.) +Prediction(a::Tuple{Float64, Float64}) = Prediction(a[1], a[2]) +Prediction(a::Prediction) = a + """ struct Observable Fields: -* `func::Function`: Function returning the predicted value of the observable as a function of the parameters -* `min::Float64`: Minimum boundary for values of the observable. Defaults to `-Inf`. -* `max::Float64`: Maximum boundary for values of the observable. Defaults to `Inf`. +* `prediction::Function`: Function returning the predicted value of the observable as a function of the parameters. +* `min::Real`: Minimum boundary for values of the observable. Defaults to `-Inf`. +* `max::Real`: Maximum boundary for values of the observable. Defaults to `Inf`. +* `weight::Real`: Weight of this observable in the combination. Defaults to `1.0`. Constructors: ```julia Observable( - func::Function; - min::Float64 = -Inf - max::Float64 = Inf + prediction::Function + min::Real = -Inf + max::Real = Inf + weight::Real = 1.0 ) ``` """ -struct Observable - func::Function - min::Float64 - max::Float64 +@with_kw struct Observable + prediction::Function + min::Real = -Inf + max::Real = Inf + weight::Real = 1.0 end -function Observable(f::Function; min=-Inf, max=Inf) - Observable(f, min, max) +function Observable(prediction::Function; min=-Inf, max=Inf, weight=1.0) + Observable(prediction=prediction, min=min, max=max, weight=weight) end @@ -45,7 +58,7 @@ abstract type AbstractMeasurement end Fields: * `observable::Observable`: Observable that is measured. -* `value::Float64;`: Measured value. +* `value::Real;`: Measured value. * `uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Real}}}`: Uncertainties of the measurement as NamedTuple. * `active::Bool`: Use or exclude measurement in fit. Defaults to `true`. @@ -53,7 +66,7 @@ Constructors: ```julia Measurement( observable::Observable, - value::Float64; + value::Real; uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Real}}}, active::Bool = true ) @@ -62,7 +75,7 @@ Measurement( ```julia Measurement( observable::Function, - value::Float64; + value::Real; uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Real}}}, active::Bool = true ) @@ -70,8 +83,8 @@ Measurement( """ struct Measurement <: AbstractMeasurement observable::Observable - value::Float64 - uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Real}}} + value::Real + uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Real}}} active::Bool end @@ -84,6 +97,7 @@ function Measurement( Measurement(observable, value, uncertainties, active) end +# Short-hand constructor that converts a function to an Observable object function Measurement( observable::Function, value::Real; @@ -101,7 +115,7 @@ end Fields: * `observable::Array{Observable, 1}`: Observables that are measured. - * `value::Array{Float64, 1}`: Measured values. + * `values::Array{Float64, 1}`: Measured values. * `uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Array{Float64, 1}}}}`: Uncertainties of the measurement as NamedTuple. * `active::Array{Bool, 1}`: Use or exclude bins in fit. Defaults to `true` for all bins. * `bin_names::Array{Symbol, 1}`: Suffixes that will be appended to the name of the measurement distribution for the individual bins. Defaults to [_bin1, _bin2, ...]. @@ -110,7 +124,7 @@ Constructors: ```julia MeasurementDistribution( observable::Array{Observable, 1}, - vals::Array{<:Real, 1}; + values::Array{<:Real, 1}; uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Union{Vector{Float64}, Vector{Int64}}}}}, active::Union{Bool, Array{Bool, 1}} = [true for i in 1:length(vals)], bin_names::Array{Symbol, 1} = [Symbol("bin\$i") for i in 1:length(vals)] @@ -120,7 +134,7 @@ MeasurementDistribution( ```julia MeasurementDistribution( observable::Array{Function, 1}, - vals::Array{<:Real, 1}; + values::Array{<:Real, 1}; uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Union{Vector{Float64}, Vector{Int64}}}}}, active::Union{Bool, Array{Bool, 1}} = [true for i in 1:length(vals)], bin_names::Array{Symbol, 1} @@ -135,35 +149,57 @@ struct MeasurementDistribution <: AbstractMeasurement bin_names::Array{Symbol, 1} end -# constructor with default value active=true +# constructor with default value active=true and names "bin1", ... function MeasurementDistribution( - observable::Array{Observable, 1}, - vals::Array{<:Real, 1}; - uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Union{Vector{Float64}, Vector{Int64}}}}}, - active::Union{Bool, Array{Bool, 1}} = [true for i in 1:length(vals)], - bin_names::Array{Symbol, 1} = [Symbol("bin$i") for i in 1:length(vals)] + observables::Array{Observable, 1}, + value::Array{<:Real, 1}; + uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Vector{<:Real}}}}, + active::Union{Bool, Array{Bool, 1}} = [true for i in eachindex(value)], + bin_names::Array{Symbol, 1} = [Symbol("bin$i") for i in eachindex(value)] ) - isa(active, Bool) ? active = fill(active, length(vals)) : nothing - unc = namedtuple(keys(uncertainties), float.(values(uncertainties))) + isa(active, Bool) ? active = fill(active, length(value)) : nothing + unc = namedtuple(keys(uncertainties), float.(NamedTupleTools.values(uncertainties))) - MeasurementDistribution(observable, vals, unc, active, bin_names) + MeasurementDistribution(observables, value, unc, active, bin_names) end -# constructor with default value active=true +# constructor converting Function to Observable with default value active=true and names "bin1", ... function MeasurementDistribution( - observable::Array{Function, 1}, - vals::Array{<:Real, 1}; - uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Union{Vector{Float64}, Vector{Int64}}}}}, - active::Union{Bool, Array{Bool, 1}} = [true for i in 1:length(vals)], - bin_names::Array{Symbol, 1} = [Symbol("bin$i") for i in 1:length(vals)] + observables::Array{Function, 1}, + value::Array{<:Real, 1}; + uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Vector{<:Real}}}}, + active::Union{Bool, Array{Bool, 1}} = [true for i in eachindex(value)], + bin_names::Array{Symbol, 1} = [Symbol("bin$i") for i in eachindex(value)] ) - obs = Observable.(observable) - isa(active, Bool) ? active = fill(active, length(vals)) : nothing - unc = namedtuple(keys(uncertainties), float.(values(uncertainties))) + obs = Observable.(observables) + isa(active, Bool) ? active = fill(active, length(value)) : nothing + unc = namedtuple(keys(uncertainties), float.(NamedTupleTools.values(uncertainties))) - MeasurementDistribution(obs, vals, unc, active, bin_names) + MeasurementDistribution(obs, value, unc, active, bin_names) +end + +#----- TODO: Limits ----------------------------------------- +abstract type AbstractLimit end + +struct GaussianUpperLimit <: AbstractLimit + observable::Observable + best_fit::Float64 + limit::Float64 + cl::Float64 + active::Bool +end + +function GaussianUpperLimit( + observable::Function, + best_fit::Float64, + limit::Float64, + cl::Float64; + active::Bool = true +) + GaussianUpperLimit(Observable(observable), best_fit, limit, cl, active) end +export GaussianUpperLimit #----- Correlation ----------------------------------------- abstract type AbstractCorrelation end @@ -180,14 +216,14 @@ Constructors: Correlation(matrix::Array{<:Real, 2}; active::Bool = true) ``` """ -struct Correlation <: AbstractCorrelation - matrix::Symmetric{Float64,Array{Float64,2}} +struct Correlation{M} <: AbstractCorrelation + matrix::M #Symmetric{Float64,Array{Float64,2}} active::Bool end -function Correlation(matrix::Array{<:Real, 2}; active::Bool = true) - symmatrix = Symmetric(matrix) - Correlation(symmatrix, active) +function Correlation(matrix::Array{<:Real, 2}; active::Bool = true, MatrixType = Symmetric) + new_matrix = MatrixType(matrix) + Correlation(new_matrix, active) end @with_kw struct NoCorrelation <: AbstractCorrelation diff --git a/src/plotting/plot_observables.jl b/src/plotting/plot_observables.jl index 34b7d58..7559ef3 100755 --- a/src/plotting/plot_observables.jl +++ b/src/plotting/plot_observables.jl @@ -7,9 +7,9 @@ x_nt, x_range, x_i = range_to_namedtuples(params) x_label = keys(params)[x_i] title_string = get_obs_title(params, x_i, titlewidth=titlewidth) - y = observable.func.(x_nt) + y = observable.prediction.(x_nt) - y_label = string(observable.func) + y_label = string(observable.prediction) @series begin seriestype --> :path @@ -72,7 +72,7 @@ end bin_names = ["bin$i" for i in 1:length(observables)] ) nbins = length(observables) - ys = [obs.func(params) for obs in observables] + ys = [obs.prediction(params) for obs in observables] @series begin seriestype --> :steppre diff --git a/src/utils.jl b/src/utils.jl index 5637130..4e3be74 100755 --- a/src/utils.jl +++ b/src/utils.jl @@ -68,6 +68,55 @@ function BLUE(m::EFTfitterModel) end function all_observables_equal(model::EFTfitterModel) - observable_functions = [m.observable.func for m in values(model.measurements)] + observable_functions = [m.observable.prediction for m in values(model.measurements)] all(y->y==observable_functions[1], observable_functions) end + + + + +function run_logdensity(posterior, vs) + [logdensityof(posterior)(v) for v in vs] +end + + +export run_speed_test +function run_speed_test( + m::EFTfitterModel; + typs= [Matrix, sparse, Symmetric], + vs = rand(m.parameters, 10), + verbose=true +) + @info "Running speed comparisons to find optimal data type for (inverse) covariance matrix!" + + benchmarks = [] + covtyps = [] + + for t in typs + current_model = @set m.CovarianceType = t; + posterior = PosteriorMeasure(current_model) + + current_invcov_type = typeof(posterior.likelihood.density._d.invcov) + push!(covtyps, current_invcov_type) + + verbose ? (@info "Testing type: $(current_invcov_type)") : nothing + + b = @benchmark run_logdensity($posterior, $vs) + push!(benchmarks, b) + + verbose ? display(b) : nothing + end + + median_times = median.([b.times for b in benchmarks]) + sorted_idxs = sortperm(median_times) + allocations = [benchmarks[i].allocs for i in sorted_idxs] + memory = [benchmarks[i].memory for i in sorted_idxs] + + tbl = Table(Type=covtyps[sorted_idxs], MedianTime=median_times[sorted_idxs], Allocations=allocations, Memory=memory) + + verbose ? display(tbl) : nothing + + @info "Recommended type for (inverse) covariance matrix: $(tbl.Type[1])" + + return tbl, benchmarks +end diff --git a/test/runtests.jl b/test/runtests.jl index 6c3fcdd..cc2fbe5 100755 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -10,4 +10,5 @@ Test.@testset "Package EFTfitter" begin include("test_utils.jl") include("test_inputs/test_inputs.jl") include("test_ranking.jl") + include("test_likelihood.jl") end diff --git a/test/test_datatypes.jl b/test/test_datatypes.jl index 065a50e..aa95068 100644 --- a/test/test_datatypes.jl +++ b/test/test_datatypes.jl @@ -3,14 +3,16 @@ # Test type Observable: obs1 = @inferred Observable(test_function) - @test obs1.func == test_function + @test obs1.prediction == test_function @test obs1.min == -Inf @test obs1.max == Inf + @test obs1.weight == 1.0 - obs2 = @inferred Observable(test_function, min=-5, max=5) - @test obs2.func == test_function + obs2 = @inferred Observable(test_function, min=-5, max=5, weight=2.1) + @test obs2.prediction == test_function @test obs2.min == -5 @test obs2.max == 5 + @test obs2.weight == 2.1 # Test type Measurement: meas1 = @inferred Measurement(test_function, 50.0, uncertainties=(unc1=0.5, unc2=0.3), active=true) @@ -20,9 +22,9 @@ #Test type MeasurementDistribution: measdist1 = MeasurementDistribution([obs1, obs1], [50.0, 49.9], - uncertainties=(unc1=[0.5, 0.4], unc2=[0.3, 0.29]), active=[true, false]) + uncertainties=(unc1=[0.5, 0.4], unc2=[0.3, 0.29]), active=[true, false]) measdist2 = MeasurementDistribution([obs1, obs1], [50.0, 49.9], - uncertainties=(unc1=[0.5, 0.4], unc2=[0.3, 0.29]), active=true) + uncertainties=(unc1=[0.5, 0.4], unc2=[0.3, 0.29]), active=true) @test measdist1.active == [true, false] @test measdist2.active == [true, true] diff --git a/test/test_inputs/test_basic_inputs.jl b/test/test_inputs/test_basic_inputs.jl index 0d72e13..fe8bffb 100644 --- a/test/test_inputs/test_basic_inputs.jl +++ b/test/test_inputs/test_basic_inputs.jl @@ -36,17 +36,18 @@ model1 = EFTfitterModel(parameters1, measurements1, correlations1) @testset "Test EFTfitterModel" begin - @test model1.measurements.meas1.observable == Observable(testfunc1, -Inf, Inf) + @test model1.measurements.meas1.observable == Observable(testfunc1) @test length(model1.measurements) == 2 @test keys(model1.measurements) == (:meas1, :meas3) - @test model1.measurements.meas1 == Measurement(Observable(testfunc1, -Inf, Inf), 111.1, (unc1=10.1, unc3=13.3), true) + @test model1.measurements.meas1 == Measurement(Observable(testfunc1, min=-Inf, max=Inf), 111.1, (unc1=10.1, unc3=13.3), true) @test model1.measurements.meas3 == Measurement(Observable(testfunc1, min=0, max=1000), 333.3, (unc1=30.1, unc3=30.3), true) - @test get_observables(model1) == (testfunc1 = Observable(testfunc1, -Inf, Inf),) + @test get_observables(model1) == (testfunc1 = Observable(testfunc1, min=-Inf, max=Inf),) end @testset "Test EFTfitterDensity" begin + PosteriorMeasure(model1) eftfitter_density = PosteriorMeasure(model1).likelihood.density._d @test isa(eftfitter_density, EFTfitterDensity) @@ -66,3 +67,4 @@ end end + diff --git a/test/test_inputs/test_likelihood.jl b/test/test_inputs/test_likelihood.jl new file mode 100644 index 0000000..54b3692 --- /dev/null +++ b/test/test_inputs/test_likelihood.jl @@ -0,0 +1,102 @@ +using Random + +using Random, LinearAlgebra + +function generate_correlation_matrix(N) + data = randn(N, N) # Generate a random N-by-N matrix + + # Create a covariance matrix by multiplying the data matrix with its transpose + covariance_matrix = data * data' + + # Calculate the diagonal matrix of standard deviations + diagonal_matrix = diag(covariance_matrix) + standard_deviations = sqrt.(diagonal_matrix) + + # Calculate the inverse of the diagonal matrix of standard deviations + inv_diagonal_matrix = diagm(1 ./ standard_deviations) + + # Calculate the correlation matrix + correlation_matrix = inv_diagonal_matrix * covariance_matrix * inv_diagonal_matrix + + return correlation_matrix +end + + + +function create_model(N; use_model_uncertainties = false) + Random.seed!(1234) + + parameters = BAT.NamedTupleDist( + p1 = -20..20, + p2 = -10..10, + ) + + true_params = (p1=1.3, p2=2.5) + + function testfunc(params) + c = [20.12, 5.56, 325.556] + return c[1] * params.p1^2 + c[2] * params.p1 * params.p2 + c[3] * params.p2^2 + end + + function testfunc_mu(params) + c = [20.12, 5.56, 325.556] + result = c[1] * params.p1^2 + c[2] * params.p1 * params.p2 + c[3] * params.p2^2 + return (result, 0.1 ) + end + + + expected = testfunc(true_params) + + + func_arr = use_model_uncertainties ? Function[testfunc_mu for i in 1:N] : Function[testfunc for i in 1:N] + + meas_arr = [expected*abs(rand(Normal(1, 0.1))) for i in 1:N] + unc_arr = [expected*abs(rand(Normal(0.1, 0.1))) for i in 1:N] + + + measurements = ( + #meas1 = Measurement(testfunc, 3000.0, uncertainties = (unc = 50.1,)), + + meas = MeasurementDistribution(func_arr, meas_arr, + uncertainties = (unc = unc_arr,)), + ) + + corm = generate_correlation_matrix(N) + + correlations = ( + unc = Correlation(corm), + ) + + return EFTfitterModel(parameters, measurements, correlations) +end + +model = create_model(5, use_model_uncertainties = true) + + +@testset "Test likelihood" begin + model_5 = create_model(5) + posterior_5 = PosteriorMeasure(model_5) + v = (p1 = 1.36, p2 = 2.3) + @test logdensityof(posterior_5)(v) ≈ -39.5175576223029 + @elapsed logdensityof(posterior_5)(v) + + + model_5_mu = create_model(5, use_model_uncertainties = true) + posterior_5_mu = PosteriorMeasure(model_5_mu) + v = (p1 = 1.36, p2 = 2.3) + @test logdensityof(posterior_5_mu)(v) ≈ -39.5175576223029 + + + + model_500 = create_model(500) + posterior_500 = PosteriorMeasure(model_500) + v = (p1 = 1.36, p2 = 2.3) + @test logdensityof(posterior_500)(v) ≈ -4.916679677894212e11 + @btime logdensityof(posterior_500)(v) + + model_5000 = create_model(5000) + posterior_5000 = PosteriorMeasure(model_5000) + v = (p1 = 1.36, p2 = 2.3) + @test logdensityof(posterior_5000)(v) ≈ -3.706920707573017e11 + @btime logdensityof(posterior_5000)(v) +end \ No newline at end of file diff --git a/test/test_inputs/test_nuisance_inputs.jl b/test/test_inputs/test_nuisance_inputs.jl index 335ef33..205da70 100644 --- a/test/test_inputs/test_nuisance_inputs.jl +++ b/test/test_inputs/test_nuisance_inputs.jl @@ -63,19 +63,19 @@ using BAT ρ2 = NuisanceCorrelation(:unc1, :meas1, :meas2, truncated(Normal(0, 1), 0, 0.9)), ) - model1 = EFTfitterModel(parameters1, measurements1, correlations1, nuisance_correlations) + model1 = EFTfitterModel(parameters1, measurements1, correlations1, limits=nothing, nuisances=nuisance_correlations, CovarianceType=Matrix) @testset "Test EFTfitterModel" begin @test length(model1.measurements) == 4 - @test model1.measurements.meas1 == Measurement(Observable(testfunc1, -Inf, Inf), 111.1, (unc1=10.1, unc3=13.3), true) - @test model1.measurements.meas4_10_20 == Measurement(Observable(testfunc1, -Inf, Inf), 30., (unc1=0.13, unc3=0.33), true) + @test model1.measurements.meas1 == Measurement(Observable(testfunc1, min=-Inf, max=Inf), 111.1, (unc1=10.1, unc3=13.3), true) + @test model1.measurements.meas4_10_20 == Measurement(Observable(testfunc1, min=-Inf, max=Inf), 30., (unc1=0.13, unc3=0.33), true) @test keys(model1.measurements) == (:meas1, :meas3, :meas4_0_5, :meas4_10_20) - @test model1.measurementdistributions.meas4.observable == [Observable(testfunc1, -Inf, Inf), Observable(testfunc1, -Inf, Inf)] - @test model1.measurementdistributions.meas4.value == [10., 30.] - @test model1.measurementdistributions.meas4.uncertainties == (unc1=[0.11, 0.13], unc3=[0.31, 0.33]) - @test model1.measurementdistributions.meas4.active == [true, true] - @test model1.measurementdistributions.meas4.bin_names == [Symbol("0_5"), Symbol("10_20")] + @test model1.measured_distributions.meas4.observable == [Observable(testfunc1), Observable(testfunc1)] + @test model1.measured_distributions.meas4.value == [10., 30.] + @test model1.measured_distributions.meas4.uncertainties == (unc1=[0.11, 0.13], unc3=[0.31, 0.33]) + @test model1.measured_distributions.meas4.active == [true, true] + @test model1.measured_distributions.meas4.bin_names == [Symbol("0_5"), Symbol("10_20")] @test length(model1.parameters._internal_distributions) == 3 @test model1.parameters._internal_distributions.ρ1 == Uniform(0, 0.5) From 87c9db3cac3bae57ab94e25aea34a8447d9a1621 Mon Sep 17 00:00:00 2001 From: Cornelius-G Date: Fri, 27 Oct 2023 12:25:31 +0200 Subject: [PATCH 2/9] add more test cases --- Project.toml | 1 + examples/tutorial/runTutorial.jl | 14 ++++++ src/EFTfitterDensity.jl | 37 +++++++-------- test/test_modelunc.jl | 72 +++++++++++++++++++++++++++++ test/test_nuisance.jl | 75 +++++++++++++++++++++++++++++++ test/test_plain.jl | 77 ++++++++++++++++++++++++++++++++ 6 files changed, 258 insertions(+), 18 deletions(-) create mode 100644 test/test_modelunc.jl create mode 100644 test/test_nuisance.jl create mode 100644 test/test_plain.jl diff --git a/Project.toml b/Project.toml index 15620de..83847fc 100644 --- a/Project.toml +++ b/Project.toml @@ -19,6 +19,7 @@ RobustAdaptiveMetropolisSampler = "2f96e190-b8a6-11e9-0b3d-5fbd22c21613" Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46" SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" +StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" ValueShapes = "136a8f8c-c49b-4edb-8b98-f3d64d48be8f" diff --git a/examples/tutorial/runTutorial.jl b/examples/tutorial/runTutorial.jl index a0167dd..d8e8db5 100644 --- a/examples/tutorial/runTutorial.jl +++ b/examples/tutorial/runTutorial.jl @@ -25,8 +25,22 @@ using LinearAlgebra f(x) = Symmetric(sparse(x)) model = EFTfitterModel(parameters, measurements, correlations, CovarianceType=f) +posterior = PosteriorMeasure(model) #run_speed_test(model) +v = rand(parameters) +v = (C1 = 1.3646163105428428, C2 = 0.0669263861339656) + +#@code_warntype EFTfitter.evaluate_funcs!(m.mus, m.observable_functions, v, m) + +using BenchmarkTools +using DensityInterface +# logdensityof(posterior)(v) +@btime logdensityof(posterior)(v) # -71.62957930828858 +# 350.000 ns (18 allocations: 1.19 KiB) + + + # To sample the posterior distribution, we specify that our `EFTfitterModel` # should be used and then setup BAT.jl to sample the EFTfitter likelihood. diff --git a/src/EFTfitterDensity.jl b/src/EFTfitterDensity.jl index 8b378e7..0d2a879 100755 --- a/src/EFTfitterDensity.jl +++ b/src/EFTfitterDensity.jl @@ -35,7 +35,7 @@ end NuisanceCorrelations(nuisances, m::EFTfitterModel) = NuisanceCorrelations(nuisances, get_covariances(m)) - +# Status indicating whether upper limits are used or not abstract type LimitsStatus end struct HasLimits <: LimitsStatus end struct NoLimits <: LimitsStatus end @@ -47,18 +47,18 @@ struct EFTfitterDensity{M<:MatrixType, MU<:ModelUncertaintiesStatus, NC<:Abstrac observable_mins::Vector{Float64} observable_maxs::Vector{Float64} weights::Vector{Float64} - matrix::M - original_diag::Vector{Float64} - check_bounds::Bool + matrix::M # CovarianceMatrix or InverseCovarianceMatrix + original_diag::Vector{Float64} # original diagonal of the covariance matrix + check_bounds::Bool # whether to check bounds or not predictions::Matrix{Float64} - prediction_uncertainties::Matrix{Float64} - limit_distributions::Vector{Distribution} - limit_functions::Vector{Function} - limit_predictions::Matrix{Float64} - limit_uncertainties::Matrix{Float64} - mus::MU - ls::L - nuisance_correlations::NC + prediction_uncertainties::Matrix{Float64} # only used if model uncertainties are present + limit_distributions::Vector{Distribution} # only used if limits are present + limit_functions::Vector{Function} # only used if limits are present + limit_predictions::Matrix{Float64} # only used if limits are present + limit_uncertainties::Matrix{Float64} # only used if limits are present + mus::MU # HasModelUncertainties or NoModelUncertainties + ls::L # HasLimits or NoLimits + nuisance_correlations::NC # NuisanceCorrelations or NoNuissanceCorrelations end @inline DensityInterface.DensityKind(::EFTfitterDensity) = IsDensity() @@ -118,12 +118,13 @@ function EFTfitterDensity(m::EFTfitterModel) @show m.nuisances#zip(m.nuisances, collect(keys(m.nuisances))) nuisances = _NuisanceCorrelation[] - for (nui, nui_k) in zip(m.nuisances, collect(keys(m.nuisances))) - unc = findfirst(x->x==nui.unc_key , unc_keys) - i = findfirst(x->x==nui.meas1 , meas_keys) - j = findfirst(x->x==nui.meas2 , meas_keys) - push!(nuisances, _NuisanceCorrelation(unc, i, j, nui_k)) - end + #TODO: fix this! + # for (nui, nui_k) in zip(m.nuisances, collect(keys(m.nuisances))) + # unc = findfirst(x->x==nui.unc_key , unc_keys) + # i = findfirst(x->x==nui.meas1 , meas_keys) + # j = findfirst(x->x==nui.meas2 , meas_keys) + # push!(nuisances, _NuisanceCorrelation(unc, i, j, nui_k)) + # end nui = isempty(nuisances) ? NoNuissanceCorrelations() : NuisanceCorrelations(nuisances, m) diff --git a/test/test_modelunc.jl b/test/test_modelunc.jl new file mode 100644 index 0000000..eb8582a --- /dev/null +++ b/test/test_modelunc.jl @@ -0,0 +1,72 @@ +using EFTfitter +using IntervalSets +using BAT +using DensityInterface +using BenchmarkTools +using Test + +parameters = BAT.NamedTupleDist( + p1 = -20..20, + p2 = -10..10, +) + +function testfunc1(params) + c = [20.12, 5.56, 325.556] + m = c[1] * params.p1^2 + c[2] * params.p1 * params.p2 + c[3] * params.p2^2 + u = c[1] * params.p1^2 + return (m, u) +end + +measurements = ( + meas1 = Measurement(testfunc1, 111.1, + uncertainties = (unc1=10.1, unc2=12.2, unc3=13.3), active=true), + + meas2 = Measurement(Observable(testfunc1, min=0, max=1000), 222.2, + uncertainties = (unc1=20.1, unc2=20.2, unc3=23.3), active=false), + + meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 333.3, + uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), + + meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], + [10, 20, 30], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), + active = [true, false, true], bin_names=[Symbol("0_5"), Symbol("5_10"), Symbol("10_20")]) +) + +corr_matrix = to_correlation_matrix(measurements, + (:meas1, :meas2, 0.12), # will be ignored later in EFTfitterModel + (:meas1, :meas3, 0.13), + (:meas1, :meas4_0_5, 0.141), + (:meas1, :meas4_5_10, 0.142), # will be ignored later in EFTfitterModel + (:meas1, :meas4_10_20, 0.143), # will be ignored later in EFTfitterModel + (:meas4_0_5, :meas4_5_10, 0.412), # will be ignored later in EFTfitterModel + (:meas4_0_5, :meas4_5_10, 0.413), + (:meas4_0_5, :meas4_0_5, 0.9) # will be ignored later in EFTfitterModel +) + +correlations = ( + unc1 = NoCorrelation(active=true), + + # wrong matrix size for number of measurements, will be ignored if active=false: + unc2 = Correlation([1.0 0.5 0.7; + 0.5 1.0 0.6; + 0.7 0.6 1.0], active=false), + + unc3 = Correlation(corr_matrix) +) + + +model = EFTfitterModel(parameters, measurements, correlations) +posterior = PosteriorMeasure(model) + +v = (p1 = 10.826122384321511, p2 = -8.32129957354641) +logp = logdensityof(posterior) + +logp(v) +@test logp(v) ≈ -5.2063526518e9 + +@btime logp(v) + +t = @benchmark logp(v) +@test t.allocs == 15 +@test t.memory == 720 +@test minimum(t.times) ≈ 226 atol=5 diff --git a/test/test_nuisance.jl b/test/test_nuisance.jl new file mode 100644 index 0000000..cd8d630 --- /dev/null +++ b/test/test_nuisance.jl @@ -0,0 +1,75 @@ +using EFTfitter +using IntervalSets +using Distributions +using BAT +using DensityInterface +using BenchmarkTools +using Test + +parameters = BAT.NamedTupleDist( + p1 = -20..20, + p2 = -10..10, +) + +function testfunc1(params) + c = [20.12, 5.56, 325.556] + return c[1] * params.p1^2 + c[2] * params.p1 * params.p2 + c[3] * params.p2^2 +end + +measurements = ( + meas1 = Measurement(testfunc1, 111.1, + uncertainties = (unc1=10.1, unc2=12.2, unc3=13.3), active=true), + + meas2 = Measurement(Observable(testfunc1, min=0, max=1000), 222.2, + uncertainties = (unc1=20.1, unc2=20.2, unc3=23.3), active=false), + + meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 333.3, + uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), + + meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], + [10, 20, 30], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), + active = [true, false, true], bin_names=[Symbol("0_5"), Symbol("5_10"), Symbol("10_20")]) +) + +corr_matrix = to_correlation_matrix(measurements, + (:meas1, :meas2, 0.12), # will be ignored later in EFTfitterModel + (:meas1, :meas3, 0.13), + (:meas1, :meas4_0_5, 0.141), + (:meas1, :meas4_5_10, 0.142), # will be ignored later in EFTfitterModel + (:meas1, :meas4_10_20, 0.143), # will be ignored later in EFTfitterModel + (:meas4_0_5, :meas4_5_10, 0.412), # will be ignored later in EFTfitterModel + (:meas4_0_5, :meas4_5_10, 0.413), + (:meas4_0_5, :meas4_0_5, 0.9) # will be ignored later in EFTfitterModel +) + +correlations = ( + unc1 = NoCorrelation(active=true), + + # wrong matrix size for number of measurements, will be ignored if active=false: + unc2 = Correlation([1.0 0.5 0.7; + 0.5 1.0 0.6; + 0.7 0.6 1.0], active=false), + + unc3 = Correlation(corr_matrix) +) + +nuisance_correlations = ( + ρ1 = NuisanceCorrelation(:unc1, :meas1, :meas3, 0..0.5), + ρ2 = NuisanceCorrelation(:unc1, :meas1, :meas2, truncated(Normal(0, 1), 0, 0.9)), +) + + +model = EFTfitterModel(parameters, measurements, correlations, nuisances=nuisance_correlations, ) +posterior = PosteriorMeasure(model) + +v = (p1 = 10.826122384321511, p2 = -8.32129957354641, ρ1 = 0.4, ρ2 = 0.8) +logp = logdensityof(posterior) + +@test logp(v) ≈ + +@btime logp(v) + +t = @benchmark logp(v) +@test t.allocs == 15 +@test t.memory == 720 +@test minimum(t.times) ≈ 226 atol=5 diff --git a/test/test_plain.jl b/test/test_plain.jl new file mode 100644 index 0000000..0c6238c --- /dev/null +++ b/test/test_plain.jl @@ -0,0 +1,77 @@ +using EFTfitter +using IntervalSets +using BAT +using DensityInterface +using BenchmarkTools +using Test +using StaticArrays + +parameters = BAT.NamedTupleDist( + p1 = -20..20, + p2 = -10..10, +) + +function testfunc1(params) + c = @SVector[20.12, 5.56, 325.556] + return c[1] * params.p1^2 + c[2] * params.p1 * params.p2 + c[3] * params.p2^2 +end + +measurements = ( + meas1 = Measurement(testfunc1, 111.1, + uncertainties = (unc1=10.1, unc2=12.2, unc3=13.3), active=true), + + meas2 = Measurement(Observable(testfunc1, min=0, max=1000), 222.2, + uncertainties = (unc1=20.1, unc2=20.2, unc3=23.3), active=false), + + meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 333.3, + uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), + + meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], + [10, 20, 30], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), + active = [true, false, true], bin_names=[Symbol("0_5"), Symbol("5_10"), Symbol("10_20")]) +) + +corr_matrix = to_correlation_matrix(measurements, + (:meas1, :meas2, 0.12), # will be ignored later in EFTfitterModel + (:meas1, :meas3, 0.13), + (:meas1, :meas4_0_5, 0.141), + (:meas1, :meas4_5_10, 0.142), # will be ignored later in EFTfitterModel + (:meas1, :meas4_10_20, 0.143), # will be ignored later in EFTfitterModel + (:meas4_0_5, :meas4_5_10, 0.412), # will be ignored later in EFTfitterModel + (:meas4_0_5, :meas4_5_10, 0.413), + (:meas4_0_5, :meas4_0_5, 0.9) # will be ignored later in EFTfitterModel +) + +correlations = ( + unc1 = NoCorrelation(active=true), + + # wrong matrix size for number of measurements, will be ignored if active=false: + unc2 = Correlation([1.0 0.5 0.7; + 0.5 1.0 0.6; + 0.7 0.6 1.0], active=false), + + unc3 = Correlation(corr_matrix) +) + + +model = EFTfitterModel(parameters, measurements, correlations) +posterior = PosteriorMeasure(model) + +v = (p1 = 10.826122384321511, p2 = -8.32129957354641) +logp = logdensityof(posterior) + +@test logp(v) ≈ -5.2063526518e9 + + +# without @SVector +t = @benchmark logp(v) +@test t.allocs == 15 +@test t.memory == 720 +@test minimum(t.times) ≈ 226 atol=5 + + +# with @SVector +t = @benchmark logp(v) +@test t.allocs == 11 +@test t.memory == 400 +@test minimum(t.times) ≈ 178 atol=5 From 171f44455caa32b98a18cd25a523cfdacdf84358 Mon Sep 17 00:00:00 2001 From: Cornelius-G Date: Fri, 27 Oct 2023 19:41:33 +0200 Subject: [PATCH 3/9] new internal structure for likelihood calculation --- examples/cholesky.jl | 6 +- src/EFTfitter.jl | 5 +- src/EFTfitterDensity.jl | 304 ++++++++++++++----------------------- src/EFTfitterLikelihood.jl | 107 +++++++++++++ test/test_modelunc.jl | 8 +- test/test_nuisance.jl | 6 +- test/test_plain.jl | 2 +- 7 files changed, 243 insertions(+), 195 deletions(-) create mode 100644 src/EFTfitterLikelihood.jl diff --git a/examples/cholesky.jl b/examples/cholesky.jl index e7b9d40..270ee20 100644 --- a/examples/cholesky.jl +++ b/examples/cholesky.jl @@ -36,7 +36,7 @@ end using BenchmarkTools -d = 2000 +d = 100 M = generate_covariance_matrix(d) x = rand(d) @@ -47,6 +47,10 @@ L = cholesky(M).L'; @btime cholesky_product2(L, x) + + + + # For Model Uncertainties using BenchmarkTools using LinearAlgebra diff --git a/src/EFTfitter.jl b/src/EFTfitter.jl index 473fe3c..9216389 100755 --- a/src/EFTfitter.jl +++ b/src/EFTfitter.jl @@ -21,6 +21,7 @@ import DensityInterface: logdensityof include("datatypes.jl") include("EFTfitterModel.jl") include("EFTfitterDensity.jl") +include("EFTfitterLikelihood.jl") include("ranking/ranking.jl") include("plotting/plotting.jl") include("utils.jl") @@ -34,5 +35,5 @@ end end # module - -#rm: ArraysOfArrays, RobustAdaptiveMetropolisSampler \ No newline at end of file +# TODO +#rm: ArraysOfArrays, RobustAdaptiveMetropolisSampler, BenchmarkTools, StaticArrays? \ No newline at end of file diff --git a/src/EFTfitterDensity.jl b/src/EFTfitterDensity.jl index 0d2a879..b70c412 100755 --- a/src/EFTfitterDensity.jl +++ b/src/EFTfitterDensity.jl @@ -1,274 +1,206 @@ export EFTfitterDensity -struct _NuisanceCorrelation - unc::Int - i::Int - j::Int - key::Symbol # parameter key +#------------- Nuisance Correlation Indices -----------------------------------------# +# internal struct for nuisance correlations (not to be confused with user-interface NuisanceCorrelation) +# TODO: rename ? +struct NuisanceCorrelationIndices + unc::Int # index of uncertainty + i::Int # index of measurement 1 + j::Int # index of measurement 2 + key::Symbol # parameter name for this nuisance correlation end -abstract type MatrixType end -struct CovarianceMatrix{T} <: MatrixType +#------------- Covariance Matrix Type Indicator -----------------------------------------# +# internal type for dispatch +abstract type CovOrInverseMatrix end + +# when covariance matrix is changed during sampling, +# i.e. when nuisance correlations or model uncertainties need to be added +struct CovMatrix{T} <: CovOrInverseMatrix m::T + diagonal::Vector{Float64} end -struct InverseCovarianceMatrix{T} <: MatrixType + +# when covariance matrix is fix and not changed during sampling, +# i.e. when no nuisance correlations or model uncertainties are used +struct InvCovMatrix{T} <: CovOrInverseMatrix m::T + diagonal::Vector{Float64} end -abstract type ModelUncertaintiesStatus end -struct HasModelUncertainties <: ModelUncertaintiesStatus end -struct NoModelUncertainties <: ModelUncertaintiesStatus end +#------------- Model Uncertainties Type Indicator ---------------------------------------# +abstract type ModelUncertaintiesIndicator end + +struct HasModelUncertainties <: ModelUncertaintiesIndicator end +struct NoModelUncertainties <: ModelUncertaintiesIndicator end + +get_model_uncertainties_indicator(predictions::Vector{<:Real}) = NoModelUncertainties() +get_model_uncertainties_indicator(predictions) = HasModelUncertainties() -get_model_uncertainties_status(predictions::Vector{<:Real}) = NoModelUncertainties() -get_model_uncertainties_status(predictions) = HasModelUncertainties() -abstract type AbstractNuisanceCorrelations end -struct NoNuissanceCorrelations <: AbstractNuisanceCorrelations end +#------------- Nuisance Correlations Indicator -----------------------###----------------# +abstract type NuisanceCorrelationsIndicator end +struct NoNuissanceCorrelations <: NuisanceCorrelationsIndicator end -struct NuisanceCorrelations{T} <: AbstractNuisanceCorrelations - nuisances::Vector{_NuisanceCorrelation} +struct NuisanceCorrelations{T} <: NuisanceCorrelationsIndicator + nuisance_correlations::Vector{NuisanceCorrelationIndices} covs::Vector{T} end NuisanceCorrelations(nuisances, m::EFTfitterModel) = NuisanceCorrelations(nuisances, get_covariances(m)) +#------------- Limits Indicator ---------------------------------------------------------# # Status indicating whether upper limits are used or not -abstract type LimitsStatus end -struct HasLimits <: LimitsStatus end -struct NoLimits <: LimitsStatus end - - -struct EFTfitterDensity{M<:MatrixType, MU<:ModelUncertaintiesStatus, NC<:AbstractNuisanceCorrelations, L<:LimitsStatus} +abstract type LimitsIndicator end +struct HasLimits <: LimitsIndicator end +struct NoLimits <: LimitsIndicator end +# TODO: Limits not yet used + + +#------------- EFTfitterDensity ---------------------------------------------------------# +struct EFTfitterDensity{ + M<:CovOrInverseMatrix, + MU<:ModelUncertaintiesIndicator, + NC<:NuisanceCorrelationsIndicator, + L<:LimitsIndicator +} measured_values::Vector{Float64} observable_functions::Vector{Function} observable_mins::Vector{Float64} observable_maxs::Vector{Float64} - weights::Vector{Float64} - matrix::M # CovarianceMatrix or InverseCovarianceMatrix - original_diag::Vector{Float64} # original diagonal of the covariance matrix - check_bounds::Bool # whether to check bounds or not - predictions::Matrix{Float64} + observable_weights::Vector{Float64} # observable weights + crossmatrix::M # CovMatrix or InvCovMatrix + check_bounds::Bool # whether to check observable bounds or not + predictions::Matrix{Float64} prediction_uncertainties::Matrix{Float64} # only used if model uncertainties are present - limit_distributions::Vector{Distribution} # only used if limits are present - limit_functions::Vector{Function} # only used if limits are present - limit_predictions::Matrix{Float64} # only used if limits are present - limit_uncertainties::Matrix{Float64} # only used if limits are present - mus::MU # HasModelUncertainties or NoModelUncertainties - ls::L # HasLimits or NoLimits + # limit_distributions::Vector{Distribution} # only used if limits are present + # limit_functions::Vector{Function} # only used if limits are present + # limit_predictions::Matrix{Float64} # only used if limits are present + # limit_uncertainties::Matrix{Float64} # only used if limits are present + model_uncertainties::MU # HasModelUncertainties or NoModelUncertainties + limits::L # HasLimits or NoLimits nuisance_correlations::NC # NuisanceCorrelations or NoNuissanceCorrelations end + @inline DensityInterface.DensityKind(::EFTfitterDensity) = IsDensity() -function get_matrix(mus::NoModelUncertainties, ncs::NoNuissanceCorrelations, m::EFTfitterModel, weights) - invcov = inv(get_total_covariance(m)) - - invcov_weighted = weights .* invcov +""" + get_crossmatrix(mus::NoModelUncertainties, ncs::NoNuissanceCorrelations, m::EFTfitterModel, weights) + +For models without model uncertainties and without nuisance correlations, this function +computes the cross matrix using the observable weights included in the matrix. +""" +function get_crossmatrix(mus::NoModelUncertainties, ncs::NoNuissanceCorrelations, m::EFTfitterModel, weights) + invcov_weighted = weights .* inv(get_total_covariance(m)) M_invcov = m.CovarianceType(invcov_weighted) - return InverseCovarianceMatrix(M_invcov), diag(invcov_weighted) + return InvCovMatrix(M_invcov, diag(invcov_weighted)) end -function get_matrix(mus::ModelUncertaintiesStatus, ncs::AbstractNuisanceCorrelations, m::EFTfitterModel, weights) + +""" + get_crossmatrix(mus::ModelUncertaintiesIndicator, ncs::NuisanceCorrelationsIndicator, m::EFTfitterModel, weights) + +For all other models (i.e., covariance matrix is changed during sampling), this function +computes the cross matrix without including observable weights in the matrix. +""" +function get_crossmatrix(mus::ModelUncertaintiesIndicator, ncs::NuisanceCorrelationsIndicator, m::EFTfitterModel, weights) cov = get_total_covariance(m) M_cov = m.CovarianceType(cov) - return CovarianceMatrix(M_cov), diag(cov) + return CovMatrix(M_cov, diag(cov)) end +# EFTfitterDensity constructor function EFTfitterDensity(m::EFTfitterModel) measured_values = Float64[meas.value for meas in m.measurements] + observable_functions = Function[meas.observable.prediction for meas in m.measurements] observable_mins = Float64[meas.observable.min for meas in m.measurements] observable_maxs = Float64[meas.observable.max for meas in m.measurements] - - observable_weights = Float64[meas.observable.weight for meas in m.measurements] - weights = length(observable_weights) * normalize(observable_weights, 1) + weights = Float64[meas.observable.weight for meas in m.measurements] + observable_weights = length(weights) * normalize(weights, 1) upper_bounds = any(x->x!=Inf, observable_maxs) lower_bounds = any(x->x!=-Inf, observable_mins) check_bounds = any([upper_bounds, lower_bounds]) - #todo: make this a function + # check if model uncertainties are present + #TODO: make this a function #TODO: add a warning if functions are too slow or take too much memory v = rand(m.parameters) predicted_values = [f(v) for f in observable_functions] - mus = get_model_uncertainties_status(predicted_values) + mus = get_model_uncertainties_indicator(predicted_values) + # preallocate arrays for storing parameter-dependent predictions and uncertainties nthreads = Threads.nthreads() predictions = zeros(nthreads, length(observable_functions)) prediction_uncertainties = zeros(nthreads, length(observable_functions)) - #TODO: add limits - ls = NoLimits() - limit_functions = Function[] - limit_distributions = Distribution[] - limit_predictions = zeros(nthreads, length(limit_functions)) - limit_uncertainties = zeros(nthreads, length(limit_functions)) - - #TODO: add nuisance correlations - meas_keys = collect(keys(m.measurements)) - unc_keys = collect(keys(m.correlations)) - - - @show m.nuisances#zip(m.nuisances, collect(keys(m.nuisances))) - - nuisances = _NuisanceCorrelation[] - #TODO: fix this! - # for (nui, nui_k) in zip(m.nuisances, collect(keys(m.nuisances))) - # unc = findfirst(x->x==nui.unc_key , unc_keys) - # i = findfirst(x->x==nui.meas1 , meas_keys) - # j = findfirst(x->x==nui.meas2 , meas_keys) - # push!(nuisances, _NuisanceCorrelation(unc, i, j, nui_k)) - # end - - nui = isempty(nuisances) ? NoNuissanceCorrelations() : NuisanceCorrelations(nuisances, m) + nuisance_correlations = build_nuisance_correlations(m.nuisances, m) #TODO: make this a function returning a matrix. depending on if there are model uncertainties or not, and if we want to use cholesky - matrix, original_diagonal = get_matrix(mus, nui, m, weights) + crossmatrix = get_crossmatrix(mus, nuisance_correlations, m, weights) + #TODO: add support for limits + limits = NoLimits() + # limit_functions = Function[] + # limit_distributions = Distribution[] + # limit_predictions = zeros(nthreads, length(limit_functions)) + # limit_uncertainties = zeros(nthreads, length(limit_functions)) return EFTfitterDensity( measured_values, observable_functions, observable_mins, observable_maxs, - weights, - matrix, - original_diagonal, + observable_weights, + crossmatrix, check_bounds, predictions, prediction_uncertainties, - limit_distributions, - limit_functions, - limit_predictions, - limit_uncertainties, + # limit_distributions, + # limit_functions, + # limit_predictions, + # limit_uncertainties, mus, - ls, - nui + limits, + nuisance_correlations ) end -function make_dist(limit::GaussianUpperLimit) - return Normal_from_limit(limit.best_fit, limit.limit, limit.cl) -end - - -function iswithinbounds(r::Float64, min::Float64, max::Float64) - return min <= r <= max -end - -# TODO: add dispatch, return 1 by default -function check_obs_bounds(r::Vector{Float64}, mins::Vector{Float64}, maxs::Vector{Float64}) - withinbounds = [iswithinbounds(r[i], mins[i], maxs[i]) for i in 1:length(r)] - all(withinbounds) ? (return 1.) : (return -Inf) -end - - -# without model uncertainties -function evaluate_funcs!(mus::NoModelUncertainties, arr::Vector{Function}, params, m) - for i in eachindex(arr) - res::Prediction = Prediction(arr[i](params)) - m.predictions[Threads.threadid(), i] = res.pred - end -end - -# with model uncertainties -function evaluate_funcs!(mus::HasModelUncertainties, arr::Vector{Function}, params, m) - for i in eachindex(arr) - res::Prediction = Prediction(arr[i](params)) - m.predictions[Threads.threadid(), i] = res.pred - m.prediction_uncertainties[Threads.threadid(), i] = res.unc - end -end - - - -function DensityInterface.logdensityof( - m::EFTfitterDensity, - params -) - #Todo: move into calculate_likelihood? - evaluate_funcs!(m.mus, m.observable_functions, params, m) - - #TODO: check_observable_bounds - - - result = calculate_likelihood(m, m.mus, m.nuisance_correlations) - - return result -end - -# no model uncertainties, no limits, weights are already in the covariance matrix -function calculate_likelihood(m::EFTfitterDensity, mus::NoModelUncertainties, ns::NoNuissanceCorrelations) - predictions = view(m.predictions, Threads.threadid(), :) - - @assert isa(m.matrix, InverseCovarianceMatrix) - - r = predictions-m.measured_values - r1 = m.matrix.m*r - result = -dot(r, r1) - - return 0.5*result -end - - -# TODO: specify for cholesky lower -function add_model_uncertainties!(mus::HasModelUncertainties, m, r) - for i in 1:size(m.matrix.m, 1) - m.matrix.m[i, i] = m.original_diag[i] + r[i]^2 #TODO: check that original_diag is not affected by nuisance correlations - end -end - -function add_model_uncertainties!(mus::NoModelUncertainties, m, r) - nothing -end - -# with model uncertainties, no limits -function calculate_likelihood(m::EFTfitterDensity, mus, nc) - predictions = view(m.predictions, Threads.threadid(), :) - prediction_uncertainties = view(m.prediction_uncertainties, Threads.threadid(), :) - - set_matrix_to_current_cov!(nc, m, params) - - @assert isa(m.matrix, CovarianceMatrix) - add_model_uncertainties!(mus, m, prediction_uncertainties) - invcov = inv(m.matrix.m) - - r = m.weights .* (predictions-m.measured_values) # we - r1 = invcov*r - - result = -dot(r, r1) - - return 0.5*result -end +function build_nuisance_correlations(nucs::Nothing, m::EFTfitterModel) + return NoNuissanceCorrelations() +end +function build_nuisance_correlations(nucs, m::EFTfitterModel) + meas_keys = collect(keys(m.measurements)) + unc_keys = collect(keys(m.correlations)) -function set_matrix_to_current_cov!(nc::NuisanceCorrelations, m, params) - for nui in m.nuisance_correlations.nuisances - i = nui.i; j = nui.j + nuisances = NuisanceCorrelationIndices[] - cov = params[nui.key] * sqrt(m.nuisance_correlations.covs[nui.unc][i, i]) * sqrt(m.nuisance_correlations.covs[nui.unc][j, j]) - m.nuisance_correlations.covs[nui.unc][i, j] = cov - m.nuisance_correlations.covs[nui.unc][j, i] = cov + for (nui, nui_k) in zip(m.nuisances, collect(keys(m.nuisances))) + println("nui: ", nui) + println("nui_k: ", nui_k) + unc = findfirst(x->x==nui.unc_key , unc_keys) + i = findfirst(x->x==nui.meas1 , meas_keys) + j = findfirst(x->x==nui.meas2 , meas_keys) + push!(nuisances, NuisanceCorrelationIndices(unc, i, j, nui_k)) end - m.matrix = CovarianceMatrix(sum(m.nuisance_correlations.covs)) -end - -function set_matrix_to_current_cov!(nc::NoNuissanceCorrelations, m, params) - nothing -end + return NuisanceCorrelations(nuisances, m) +end +# build BAT.PosteriorMeasure directly from EFTfitterModel function BAT.PosteriorMeasure(m::EFTfitterModel) likelihood = EFTfitterDensity(m) return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) end - \ No newline at end of file diff --git a/src/EFTfitterLikelihood.jl b/src/EFTfitterLikelihood.jl new file mode 100644 index 0000000..0e6a516 --- /dev/null +++ b/src/EFTfitterLikelihood.jl @@ -0,0 +1,107 @@ +function iswithinbounds(r::Float64, min::Float64, max::Float64) + return min <= r <= max +end + +# TODO: add dispatch, return 1 by default +function check_obs_bounds(r::Vector{Float64}, mins::Vector{Float64}, maxs::Vector{Float64}) + withinbounds = [iswithinbounds(r[i], mins[i], maxs[i]) for i in 1:length(r)] + all(withinbounds) ? (return 1.) : (return -Inf) +end + + +# without model uncertainties +function evaluate_funcs!(nomuncs::NoModelUncertainties, D::EFTfitterDensity, current_params) + funcs = D.observable_functions + for i in eachindex(funcs) + res::Prediction = Prediction(funcs[i](current_params)) + D.predictions[Threads.threadid(), i] = res.pred + end +end + +# with model uncertainties #TODO: remove arr +function evaluate_funcs!(muncs::HasModelUncertainties, D::EFTfitterDensity, current_params) + funcs = D.observable_functions + for i in eachindex(funcs) + res::Prediction = Prediction(funcs[i](current_params)) + D.predictions[Threads.threadid(), i] = res.pred + D.prediction_uncertainties[Threads.threadid(), i] = res.unc + end +end + + +function DensityInterface.logdensityof( + D::EFTfitterDensity, + params +) + evaluate_funcs!(D.model_uncertainties, D, params) + + #TODO: check_observable_bounds + result = calculate_likelihood(D.model_uncertainties, D.nuisance_correlations, D, params) + + return result +end + +# no model uncertainties & no limits, weights are already included in the inverse covariance matrix +function calculate_likelihood(nomuncs::NoModelUncertainties, ns::NoNuissanceCorrelations, D::EFTfitterDensity, params) + predictions = view(D.predictions, Threads.threadid(), :) + + @assert isa(D.crossmatrix, InvCovMatrix) #TODO: remove + + r = predictions-D.measured_values + r1 = D.crossmatrix.m * r + result = -dot(r, r1) + + return 0.5*result +end + + +# with model uncertainties, with nuisance correlations, no limits +function calculate_likelihood(muncs, nc, D::EFTfitterDensity, params) + predictions = view(D.predictions, Threads.threadid(), :) + prediction_uncertainties = view(D.prediction_uncertainties, Threads.threadid(), :) + + covmatrix = get_current_cov(nc, D, params) + + add_model_uncertainties_to_cov!(muncs, covmatrix, prediction_uncertainties) + + invcov = inv(covmatrix.m) + + r = D.observable_weights .* (predictions - D.measured_values) + r1 = invcov*r + + result = -dot(r, r1) + + return 0.5*result +end + + +# TODO: specify for cholesky lower ? (For larger matrices >100 cholesky is faster) +function add_model_uncertainties_to_cov!(mus::HasModelUncertainties, covmatrix, pred_unc) + for i in eachindex(axes(covmatrix.m, 1)) + covmatrix.m[i, i] = covmatrix.diagonal[i] + pred_unc[i]^2 #TODO: check that original_diag is not affected by nuisance correlations + end +end + +function add_model_uncertainties_to_cov!(mus::NoModelUncertainties, covmatrix, pred_unc) + nothing +end + + +#TODO: need type for covariance matrix +function get_current_cov(nc::NuisanceCorrelations, D, params) + for nui in D.nuisance_correlations.nuisance_correlations #TODO: rethink naming + i = nui.i; j = nui.j + + cov = params[nui.key] * sqrt(D.nuisance_correlations.covs[nui.unc][i, i]) * sqrt(D.nuisance_correlations.covs[nui.unc][j, j]) + D.nuisance_correlations.covs[nui.unc][i, j] = cov + D.nuisance_correlations.covs[nui.unc][j, i] = cov + end + + crossmatrix = CovMatrix(sum(D.nuisance_correlations.covs), D.crossmatrix.diagonal) + return crossmatrix +end + + +function get_current_cov(nc::NoNuissanceCorrelations, D, params) + return D.crossmatrix +end diff --git a/test/test_modelunc.jl b/test/test_modelunc.jl index eb8582a..3757bfc 100644 --- a/test/test_modelunc.jl +++ b/test/test_modelunc.jl @@ -4,6 +4,7 @@ using BAT using DensityInterface using BenchmarkTools using Test +using StaticArrays parameters = BAT.NamedTupleDist( p1 = -20..20, @@ -11,7 +12,7 @@ parameters = BAT.NamedTupleDist( ) function testfunc1(params) - c = [20.12, 5.56, 325.556] + c = @SVector[20.12, 5.56, 325.556] m = c[1] * params.p1^2 + c[2] * params.p1 * params.p2 + c[3] * params.p2^2 u = c[1] * params.p1^2 return (m, u) @@ -61,8 +62,9 @@ posterior = PosteriorMeasure(model) v = (p1 = 10.826122384321511, p2 = -8.32129957354641) logp = logdensityof(posterior) -logp(v) -@test logp(v) ≈ -5.2063526518e9 +logp(v) +@test logp(v) ≈ -218.67344468325953 +@test logp(v) ≈ -5.2063526518e9 # for modeluncertainty=0 @btime logp(v) diff --git a/test/test_nuisance.jl b/test/test_nuisance.jl index cd8d630..e6b20f1 100644 --- a/test/test_nuisance.jl +++ b/test/test_nuisance.jl @@ -62,10 +62,12 @@ nuisance_correlations = ( model = EFTfitterModel(parameters, measurements, correlations, nuisances=nuisance_correlations, ) posterior = PosteriorMeasure(model) -v = (p1 = 10.826122384321511, p2 = -8.32129957354641, ρ1 = 0.4, ρ2 = 0.8) +v = (p1 = 10.826122384321511, p2 = -8.32129957354641, ρ1 = 0.4) logp = logdensityof(posterior) +logp(v) -@test logp(v) ≈ +logp(rand(posterior.prior)) +@test logp(v) ≈ -5.213494198124699e9 @btime logp(v) diff --git a/test/test_plain.jl b/test/test_plain.jl index 0c6238c..3ff2a03 100644 --- a/test/test_plain.jl +++ b/test/test_plain.jl @@ -74,4 +74,4 @@ t = @benchmark logp(v) t = @benchmark logp(v) @test t.allocs == 11 @test t.memory == 400 -@test minimum(t.times) ≈ 178 atol=5 +@test minimum(t.times) ≈ 163 atol=5 From d619d9876786cbcbcd33c658ac7a4ea86a62065c Mon Sep 17 00:00:00 2001 From: Cornelius-G Date: Fri, 27 Oct 2023 20:56:42 +0200 Subject: [PATCH 4/9] add back bounds check --- src/EFTfitterDensity.jl | 14 +++++++++++--- src/EFTfitterLikelihood.jl | 18 ++++++++++++------ test/test_plain.jl | 12 ++++++------ 3 files changed, 29 insertions(+), 15 deletions(-) diff --git a/src/EFTfitterDensity.jl b/src/EFTfitterDensity.jl index b70c412..08261f4 100755 --- a/src/EFTfitterDensity.jl +++ b/src/EFTfitterDensity.jl @@ -59,10 +59,18 @@ struct HasLimits <: LimitsIndicator end struct NoLimits <: LimitsIndicator end # TODO: Limits not yet used +#------------- Bounds Check Indicator ---------------------------------------------------------# +# Status indicating whether observable bounds should be checked or not +abstract type BoundsCheckIndicator end +struct BoundsCheck <: BoundsCheckIndicator end +struct NoBoundsCheck <: BoundsCheckIndicator end + + #------------- EFTfitterDensity ---------------------------------------------------------# struct EFTfitterDensity{ - M<:CovOrInverseMatrix, + M<:CovOrInverseMatrix, + B<:BoundsCheckIndicator, MU<:ModelUncertaintiesIndicator, NC<:NuisanceCorrelationsIndicator, L<:LimitsIndicator @@ -73,7 +81,7 @@ struct EFTfitterDensity{ observable_maxs::Vector{Float64} observable_weights::Vector{Float64} # observable weights crossmatrix::M # CovMatrix or InvCovMatrix - check_bounds::Bool # whether to check observable bounds or not + check_bounds::B # whether to check observable bounds or not predictions::Matrix{Float64} prediction_uncertainties::Matrix{Float64} # only used if model uncertainties are present # limit_distributions::Vector{Distribution} # only used if limits are present @@ -128,7 +136,7 @@ function EFTfitterDensity(m::EFTfitterModel) upper_bounds = any(x->x!=Inf, observable_maxs) lower_bounds = any(x->x!=-Inf, observable_mins) - check_bounds = any([upper_bounds, lower_bounds]) + check_bounds = any([upper_bounds, lower_bounds]) ? BoundsCheck() : NoBoundsCheck() # check if model uncertainties are present #TODO: make this a function diff --git a/src/EFTfitterLikelihood.jl b/src/EFTfitterLikelihood.jl index 0e6a516..8a00380 100644 --- a/src/EFTfitterLikelihood.jl +++ b/src/EFTfitterLikelihood.jl @@ -3,9 +3,14 @@ function iswithinbounds(r::Float64, min::Float64, max::Float64) end # TODO: add dispatch, return 1 by default -function check_obs_bounds(r::Vector{Float64}, mins::Vector{Float64}, maxs::Vector{Float64}) - withinbounds = [iswithinbounds(r[i], mins[i], maxs[i]) for i in 1:length(r)] - all(withinbounds) ? (return 1.) : (return -Inf) +function check_observable_bounds(cb::NoBoundsCheck, predictions, mins::Vector{Float64}, maxs::Vector{Float64}) + return 1.0 +end + +function check_observable_bounds(cb::BoundsCheck, predictions, mins::Vector{Float64}, maxs::Vector{Float64}) + r = view(predictions, Threads.threadid(), :) + withinbounds = [iswithinbounds(r[i], mins[i], maxs[i]) for i in eachindex(r)] + all(withinbounds) ? (return 1.) : (return 1e50) end @@ -18,7 +23,7 @@ function evaluate_funcs!(nomuncs::NoModelUncertainties, D::EFTfitterDensity, cur end end -# with model uncertainties #TODO: remove arr +# with model uncertainties function evaluate_funcs!(muncs::HasModelUncertainties, D::EFTfitterDensity, current_params) funcs = D.observable_functions for i in eachindex(funcs) @@ -35,10 +40,11 @@ function DensityInterface.logdensityof( ) evaluate_funcs!(D.model_uncertainties, D, params) - #TODO: check_observable_bounds + bounds_factor = check_observable_bounds(D.check_bounds, D.predictions, D.observable_mins, D.observable_maxs) + result = calculate_likelihood(D.model_uncertainties, D.nuisance_correlations, D, params) - return result + return bounds_factor * result end # no model uncertainties & no limits, weights are already included in the inverse covariance matrix diff --git a/test/test_plain.jl b/test/test_plain.jl index 3ff2a03..fba398e 100644 --- a/test/test_plain.jl +++ b/test/test_plain.jl @@ -23,7 +23,7 @@ measurements = ( meas2 = Measurement(Observable(testfunc1, min=0, max=1000), 222.2, uncertainties = (unc1=20.1, unc2=20.2, unc3=23.3), active=false), - meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 333.3, + meas3 = Measurement(Observable(testfunc1, min=0, max=25000), 333.3, uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], @@ -54,12 +54,12 @@ correlations = ( ) -model = EFTfitterModel(parameters, measurements, correlations) +model = EFTfitterModel(parameters, measurements, correlations, ) posterior = PosteriorMeasure(model) v = (p1 = 10.826122384321511, p2 = -8.32129957354641) logp = logdensityof(posterior) - +logp(v) @test logp(v) ≈ -5.2063526518e9 @@ -72,6 +72,6 @@ t = @benchmark logp(v) # with @SVector t = @benchmark logp(v) -@test t.allocs == 11 -@test t.memory == 400 -@test minimum(t.times) ≈ 163 atol=5 +@test t.allocs == 12 +@test t.memory == 464 +@test minimum(t.times) ≈ 191 atol=5 From 4f6bda6cabc886b67f14566d521c3b936d172da0 Mon Sep 17 00:00:00 2001 From: Cornelius-G Date: Fri, 27 Oct 2023 21:58:24 +0200 Subject: [PATCH 5/9] update deps --- Project.toml | 9 +- examples/curve_fit/curve_fit.jl | 50 --- examples/curve_fit/inputs.jl | 62 ---- examples/curve_fit/optimize.py | 39 --- examples/curve_fit/runEFTfitter.jl | 46 --- examples/tutorial/ram_sampler.jl | 113 ------- src/EFTfitter.jl | 5 +- src/EFTfitterDensity_old.jl | 499 ----------------------------- 8 files changed, 4 insertions(+), 819 deletions(-) delete mode 100644 examples/curve_fit/curve_fit.jl delete mode 100644 examples/curve_fit/inputs.jl delete mode 100644 examples/curve_fit/optimize.py delete mode 100644 examples/curve_fit/runEFTfitter.jl delete mode 100644 examples/tutorial/ram_sampler.jl delete mode 100644 src/EFTfitterDensity_old.jl diff --git a/Project.toml b/Project.toml index 83847fc..cc451b4 100644 --- a/Project.toml +++ b/Project.toml @@ -1,10 +1,9 @@ name = "EFTfitter" uuid = "2a2a6a96-a4ec-477f-941b-476720990667" authors = ["Cornelius Grunwald"] -version = "0.1.2" +version = "0.2" [deps] -ArraysOfArrays = "65a8f2f4-9b39-5baf-92e2-a9cc46fdf018" BAT = "c0cd4b16-88b7-57fa-983b-ab80aecada7e" BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" DensityInterface = "b429d917-457f-4dbc-8f4c-0cc954292b1d" @@ -15,17 +14,15 @@ Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" Requires = "ae029012-a4dd-5104-9daa-d747884805df" -RobustAdaptiveMetropolisSampler = "2f96e190-b8a6-11e9-0b3d-5fbd22c21613" Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46" SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" -StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" ValueShapes = "136a8f8c-c49b-4edb-8b98-f3d64d48be8f" [compat] -BAT = "2, 3" +BAT = "3" Distributions = "0.22, 0.23, 0.24, 0.25" NamedTupleTools = "0.13" Parameters = "0.12" @@ -34,7 +31,7 @@ Requires = "0.5, 1" Setfield = "0.7" StatsBase = "0.32, 0.33" ValueShapes = "0.7, 0.8, 0.9, 0.10" -julia = "1.3" +julia = "1.8, 1.9" [extras] IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" diff --git a/examples/curve_fit/curve_fit.jl b/examples/curve_fit/curve_fit.jl deleted file mode 100644 index b83131f..0000000 --- a/examples/curve_fit/curve_fit.jl +++ /dev/null @@ -1,50 +0,0 @@ -using Random -using Plots - -# generate mock data -Random.seed!(45) -N = 20 - -f(x) = 1.1 + 0.2*x + 4.3*x^2 + 0.4*x^3 + 0.2*x^4 + 0.6*x^5 -x=-10:0.1:10 - -x_data = rand(x, N) -ys = f.(x_data) -y_data = [y + rand(Normal(0, 15)) for y in ys] - -for xi in x_data - print(xi, ",") -end - -for yi in y_data - print(yi, ",") -end - - - -plot(x, f.(x), label="Truth") -plot!(x_data, y_data, st=:scatter, label="Data") - - -# using the Julia package "LsqFit.jl" -using LsqFit -@. fit_func(x, p) = p[1] + p[2]*x + p[3]*x^2 + p[4]*x^3 + p[5]*x^4 + p[6]*x^5 - -p0 = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5] # initial guess - -# Fitting the model to the data using nonlinear least-squares optimization -fit = curve_fit(fit_func, x_data, y_data, p0) - - - - -best_fit = fit.param # Retrieving the best-fit parameter values for the model -sigma = stderror(fit) # Calculating the standard error of the fit -margin_of_error = margin_error(fit, 0.05) # Calculating the margin of error for the fit at a 95% confidence level -confidence_inter = confidence_interval(fit, 0.05) # Calculating the confidence interval for the fit at a 95% confidence level - -plot(x, f.(x), label="Truth") -plot!(x_data, y_data, st=:scatter, label="Data") -plot!(x, fit_func(x, best_fit), label="Fit") - -sqrt(20)^ \ No newline at end of file diff --git a/examples/curve_fit/inputs.jl b/examples/curve_fit/inputs.jl deleted file mode 100644 index 244ec62..0000000 --- a/examples/curve_fit/inputs.jl +++ /dev/null @@ -1,62 +0,0 @@ -# EFTfitter.jl - Curve Fit Example - -using Random - -# generate mock data -Random.seed!(45) -N = 20 - -f(x) = 1.1 + 0.2*x + 4.3*x^2 + 0.4*x^3 + 0.2*x^4 + 0.6*x^5 -x=-10:0.1:10 - -x_data = rand(x, N) -ys = f.(x_data) -y_data = [y + rand(Normal(0, 15)) for y in ys] - - - -# ============= Parameters =============================================# -parameters = BAT.NamedTupleDist( - p = [-20..40, -20..10, -10..10, -10..10, -5..5, -2..2], - #p = fill(-1..1, 6), -) - - -# ============= Observables ============================================# -function observable(params, x) - return params.p[1] + params.p[2]*x + params.p[3]*x^2 + params.p[4]*x^3 + params.p[5]*x^4 + params.p[6]*x^5 -end - -g(x) = params -> observable(params, x) - -obs_array = Function[g(x) for x in x_data] - -#unc_array = fill(1e-5, length(y_data)) -unc_array = sqrt.(abs.(y_data)) - -# ============= Measurements ===========================================# -using LinearAlgebra -cov_matrix = Matrix(I, N, N) - -cor, unc = cov_to_cor(cov_matrix) - -unc = unc .* sqrt(180) - - -measurements = ( - MeasDist = MeasurementDistribution(obs_array, y_data, uncertainties = (unc1 = unc,)), -) - - -# ============= Correlations ===========================================# -correlations = ( - unc1 = NoCorrelation(active=true), -) - -#corr_matrix = to_correlation_matrix(measurements, -# (:Meas1, :Meas2, 0.1), -#) - - -# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - diff --git a/examples/curve_fit/optimize.py b/examples/curve_fit/optimize.py deleted file mode 100644 index 60182b5..0000000 --- a/examples/curve_fit/optimize.py +++ /dev/null @@ -1,39 +0,0 @@ -import numpy as np -from scipy.optimize import curve_fit -from matplotlib import pyplot as plt - - -x = np.array([-6.5,-9.3,7.9,-8.9,9.7,5.5,5.5,2.5,-8.7,1.0,1.4,1.9,7.6,3.8,-8.5,-7.0,-2.8,0.9,1.3,4.2,]) -y = np.array([437.903955201858,1537.749199238419,1231.9258895641094,1323.9224677984573,2527.6637713963096,399.57818043731953,362.4963567699898,56.85153464909146,1202.774601731368,25.205508693430282,17.192572423872164,1.914974838495624,1086.4978390611982,134.2200703399384,1107.3595441415214,561.0614957587213,49.062840977188266,20.906407232145973,9.70889789068209,144.96530373831723]) - -# Test function with coefficients as parameters -def test(x, a, b, c, d, e): - return a + b*x + c*x**2 + d*x**3 + e*x**4 - -# curve_fit() function takes the test-function -# x-data and y-data as argument and returns -# the coefficients a and b in param and -# the estimated covariance of param in param_cov -param, param_cov = curve_fit(test, x, y) - - -print("Sine function coefficients:") -print(param) - -print("Covariance of coefficients:") -print(param_cov) - -np.sqrt(np.diag(param_cov)) - - -# ans stores the new y-data according to -# the coefficients given by curve-fit() function -ans = (param[0]*(np.sin(param[1]*x))) - -'''Below 4 lines can be un-commented for plotting results -using matplotlib as shown in the first example. ''' - -# plt.plot(x, y, 'o', color ='red', label ="data") -# plt.plot(x, ans, '--', color ='blue', label ="optimized data") -# plt.legend() -# plt.show() diff --git a/examples/curve_fit/runEFTfitter.jl b/examples/curve_fit/runEFTfitter.jl deleted file mode 100644 index ea48d05..0000000 --- a/examples/curve_fit/runEFTfitter.jl +++ /dev/null @@ -1,46 +0,0 @@ -# EFTfitter.jl - Empty Template -using EFTfitter -using BAT # for sampling -using IntervalSets # for specifying the prior -using Distributions # for specifying the prior -using Plots # for plotting - -# include definitions of observables, measurements, -# uncertainties and correlations from the inputs file: -include("inputs.jl") -include("../tutorial/ram_sampler.jl") - -# create an `EFTfitterModel` object: -model = EFTfitterModel(parameters, measurements, correlations) -# create posterior distribution: -posterior = PosteriorMeasure(model); -get_total_covariance(model) - - -# sample the posterior distribution with BAT.jl: -algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4, strict=false) -algorithm = RAMSampler(nchains=4, nsteps=8*10^5, nburnin=4*10^5) - -samples = bat_sample(posterior, algorithm).result; - -findmode = bat_findmode(posterior) -findmode.result - -findmode.info -# create and display a `SampledDensity` object for a quick overview of results: -sd = SampledDensity(posterior, samples) -print(sd) -bat_report(sd) - -cov(samples) - -# plot the posterior distribution: -p = plot(samples) -savefig(p, "plot.pdf") - -# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - -sqrt(180) - -d = 6 -0.5*(2*pi)^(d/2) diff --git a/examples/tutorial/ram_sampler.jl b/examples/tutorial/ram_sampler.jl deleted file mode 100644 index 5509f45..0000000 --- a/examples/tutorial/ram_sampler.jl +++ /dev/null @@ -1,113 +0,0 @@ -import BAT: AbstractSamplingAlgorithm, bat_sample_impl -using BAT: DensitySampleVector, AbstractRNG, AbstractMeasureOrDensity, MCMCSampleID, AnyMeasureOrDensity, ConvergenceTest, transform_and_unshape, bat_convergence -using Parameters -using ValueShapes -using ArraysOfArrays -using InverseFunctions - -# simple wrapper for the RAM sampler [1011.4381] using RobustAdaptiveMetropolisSampler.jl -using RobustAdaptiveMetropolisSampler - -export RAMSampler - -@with_kw struct RAMSampler{ - CT<:ConvergenceTest -} <: AbstractSamplingAlgorithm - trafo = PriorToGaussian() - nchains::Int = 4 - nsteps::Int = 10^5 - nburnin::Int = floor(Int,0.1*nsteps) # number of burnin steps to throw away per chain - convergence::CT = BrooksGelmanConvergence() - x0 = fill(nothing, nchains) - M0 = fill(1., nchains) - opt_α = fill(0.234, nchains) - γ=fill(2/3, nchains) - q=fill(Normal(), nchains) -end - - -function bat_sample_impl( - rng::AbstractRNG, - target::AnyMeasureOrDensity, - algorithm::RAMSampler -) - density_notrafo = convert(BAT.AbstractMeasureOrDensity, target) - density, trafo = transform_and_unshape(algorithm.trafo, density_notrafo) - shape = varshape(density) - - ram_vector = [] - @info "Start RAM sampling of $(algorithm.nchains) chains with $(Threads.nthreads()) threads." - - Threads.@threads for i in 1:algorithm.nchains - try - push!(ram_vector, generate_ram_samples(i, rng, density, algorithm; show_progress = ifelse(i==1, true, false))) - catch err - @info "RAM sampling failed for thread $(Threads.threadid())." - end - end - - samples, M, acceptance_rate = collect_samples(ram_vector) - - samples_trafo = shape.(reduce(vcat, samples)) - samples_notrafo = inverse(trafo).(samples_trafo) - - #converged = bat_convergence(samples_notrafo, algorithm.convergence).converged - #@info "RAM chains have$(ifelse(converged, "", " not")) converged" - - return (result = samples_notrafo, result_trafo = samples_trafo, trafo = trafo, M = M, acceptance_rate = acceptance_rate) - -end - - -function generate_ram_samples( - i::Integer, - rng::AbstractRNG, - target_density::Any, - algorithm::RAMSampler; - show_progress = false -) - n_tries = 0 - success = false - - ram_result_vec = [] - while !success && n_tries < 4000 - n_tries += 1 - try - x0 = any(isnothing.(algorithm.x0)) ? bat_initval(rng, target_density, InitFromTarget()).result : algorithm.x0[i] - M0 = algorithm.M0[i] - println("n_tries: ", n_tries) - - ram_result = RobustAdaptiveMetropolisSampler.RAM_sample(logdensityof(target_density), x0, M0, algorithm.nsteps; - opt_α=algorithm.opt_α[i], γ=algorithm.γ[i], q=algorithm.q[i], show_progress=show_progress, output_log_probability_x=true) - - success = true - push!(ram_result_vec, ram_result) - catch e - success = false - end - end - - ram_result = ram_result_vec[1] - nburnin = algorithm.nburnin - samples = nestedview(ram_result.chain')[nburnin+1:end] - logvals = ram_result.log_probabilities_x[nburnin+1:end] - - return (samples=samples, logvals=logvals, M=ram_result.M, acceptance_rate=ram_result.acceptance_rate) -end - - -function collect_samples(ram_vector) - M = getproperty.(ram_vector, :M) - acceptance_rate = getproperty.(ram_vector, :acceptance_rate) - samples_raw = getproperty.(ram_vector, :samples) - logvals_raw = getproperty.(ram_vector, :logvals) - samples = [] - - for i in 1:length(ram_vector) - n_samples = length(samples_raw[i]) - sample_id = fill(MCMCSampleID(i, 0, 0, 0), n_samples) - push!(samples, DensitySampleVector(samples_raw[i], logvals_raw[i], info=sample_id)) - end - - return (samples=samples, M=M, acceptance_rate=acceptance_rate) -end diff --git a/src/EFTfitter.jl b/src/EFTfitter.jl index 9216389..2a35e09 100755 --- a/src/EFTfitter.jl +++ b/src/EFTfitter.jl @@ -33,7 +33,4 @@ function __init__() @require Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" _PLOTS_MODULE[] = Plots end -end # module - -# TODO -#rm: ArraysOfArrays, RobustAdaptiveMetropolisSampler, BenchmarkTools, StaticArrays? \ No newline at end of file +end # module \ No newline at end of file diff --git a/src/EFTfitterDensity_old.jl b/src/EFTfitterDensity_old.jl deleted file mode 100644 index e335bfa..0000000 --- a/src/EFTfitterDensity_old.jl +++ /dev/null @@ -1,499 +0,0 @@ -export EFTfitterDensity -export EFTfitterDensityNuisance - -struct _NuisanceCorrelation - unc::Int - i::Int - j::Int - key::Symbol # parameter key -end - -abstract type MatrixType end - -struct CovarianceMatrix{T} <: MatrixType - m::T -end -struct InverseCovarianceMatrix{T} <: MatrixType - m::T -end - -abstract type ModelUncertaintiesStatus end - -struct HasModelUncertainties <: ModelUncertaintiesStatus end -struct NoModelUncertainties <: ModelUncertaintiesStatus end - -get_model_uncertainties_status(predictions::Vector{<:Real}) = NoModelUncertainties() -get_model_uncertainties_status(predictions) = HasModelUncertainties() - -abstract type AbstractNuisanceCorrelations end -struct NoNuissanceCorrelations <: AbstractNuisanceCorrelations end - -struct NuisanceCorrelations{T} <: AbstractNuisanceCorrelations - nuisances::Vector{_NuisanceCorrelation} - covs::Vector{T} -end - -NuisanceCorrelations(nuisances, m::EFTfitterModel) = NuisanceCorrelations(nuisances, get_covariances(m)) - - - -abstract type LimitsStatus end -struct HasLimits <: LimitsStatus end -struct NoLimits <: LimitsStatus end - - -struct EFTfitterDensity{M<:MatrixType, MU<:ModelUncertaintiesStatus, NC<:AbstractNuisanceCorrelations, L<:LimitsStatus} - measured_values::Vector{Float64} - observable_functions::Vector{Function} - observable_mins::Vector{Float64} - observable_maxs::Vector{Float64} - weights::Vector{Float64} - matrix::M - original_diag::Vector{Float64} - check_bounds::Bool - predictions::Matrix{Float64} - prediction_uncertainties::Matrix{Float64} - limit_distributions::Vector{Distribution} - limit_functions::Vector{Function} - limit_predictions::Matrix{Float64} - limit_uncertainties::Matrix{Float64} - mus::MU - ls::L - nuisance_correlations::NC -end -@inline DensityInterface.DensityKind(::EFTfitterDensity) = IsDensity() - - -# TODO: remove - -# struct EFTfitterDensityNuisance -# measured_values::Vector{Float64} -# observable_functions::Vector{Function} -# observable_mins::Vector{Float64} -# observable_maxs::Vector{Float64} -# covs::Vector{Array{Float64, 2}} -# nuisances::Vector{_NuisanceCorrelation} -# check_bounds::Bool -# end -# @inline DensityInterface.DensityKind(::EFTfitterDensityNuisance) = IsDensity() - - -# struct EFTfitterDensityWithLimits -# measured_values::Vector{Float64} -# observable_functions::Vector{Function} -# observable_mins::Vector{Float64} -# observable_maxs::Vector{Float64} -# limit_distributions::Vector{Distribution} -# limit_functions::Vector{Function} -# invcov::Array{Float64, 2} -# check_bounds::Bool -# end -# @inline DensityInterface.DensityKind(::EFTfitterDensityWithLimits) = IsDensity() - -function prepare_cov_matrix(mus::NoModelUncertainties, ncs::NoNuissanceCorrelations, m::EFTfitterModel, weights) - invcov = inv(get_total_covariance(m)) - - invcov_weighted = weights .* invcov - M_invcov = m.CovarianceType(invcov_weighted) - - return InverseCovarianceMatrix(M_invcov), diag(invcov_weighted) -end - -function prepare_cov_matrix(mus::ModelUncertaintiesStatus, ncs::AbstractNuisanceCorrelations, m::EFTfitterModel, weights) - cov = get_total_covariance(m) - M_cov = m.CovarianceType(cov) - - return CovarianceMatrix(M_cov), diag(cov) -end - - -function EFTfitterDensity(m::EFTfitterModel) - measured_values = Float64[meas.value for meas in m.measurements] - observable_functions = Function[meas.observable.prediction for meas in m.measurements] - observable_mins = Float64[meas.observable.min for meas in m.measurements] - observable_maxs = Float64[meas.observable.max for meas in m.measurements] - - observable_weights = Float64[meas.observable.weight for meas in m.measurements] - weights = length(observable_weights) * normalize(observable_weights, 1) - - upper_bounds = any(x->x!=Inf, observable_maxs) - lower_bounds = any(x->x!=-Inf, observable_mins) - check_bounds = any([upper_bounds, lower_bounds]) - - #todo: make this a function - #TODO: add a warning if functions are too slow or take too much memory - v = rand(m.parameters) - predicted_values = [f(v) for f in observable_functions] - mus = get_model_uncertainties_status(predicted_values) - - nthreads = Threads.nthreads() - predictions = zeros(nthreads, length(observable_functions)) - prediction_uncertainties = zeros(nthreads, length(observable_functions)) - - #TODO: add limits - ls = NoLimits() - limit_functions = Function[] - limit_distributions = Distribution[] - limit_predictions = zeros(nthreads, length(limit_functions)) - limit_uncertainties = zeros(nthreads, length(limit_functions)) - - #TODO: add nuisance correlations - meas_keys = collect(keys(m.measurements)) - unc_keys = collect(keys(m.correlations)) - - nuisances = _NuisanceCorrelation[] - for (nui, nui_k) in zip(m.nuisances, collect(keys(m.nuisances))) - unc = findfirst(x->x==nui.unc_key , unc_keys) - i = findfirst(x->x==nui.meas1 , meas_keys) - j = findfirst(x->x==nui.meas2 , meas_keys) - push!(nuisances, _NuisanceCorrelation(unc, i, j, nui_k)) - end - - nui = isempty(nuisances) ? NoNuissanceCorrelations() : NuisanceCorrelations(nuisances, m) - - #TODO: make this a function returning a matrix. depending on if there are model uncertainties or not, and if we want to use cholesky - matrix, original_diagonal = prepare_cov_matrix(mus, ncs, m, weights) - - - return EFTfitterDensity( - measured_values, - observable_functions, - observable_mins, - observable_maxs, - weights, - matrix, - original_diagonal, - check_bounds, - predictions, - prediction_uncertainties, - limit_distributions, - limit_functions, - limit_predictions, - limit_uncertainties, - mus, - ls, - nui - ) -end - - -using SpecialFunctions -function Normal_from_limit(best_fit_value, limit, confidence_level) - μ = best_fit_value - p = confidence_level - q = limit - - σ = (q - μ)/(sqrt(2)*erfinv(2*p-1)) - - return Normal(μ, σ) -end - -function make_dist(limit::GaussianUpperLimit) - return Normal_from_limit(limit.best_fit, limit.limit, limit.cl) -end - -# function EFTfitterDensityWithLimits(m::EFTfitterModelWithLimits) -# n = length(m.measurements) -# measured_values = [meas.value for meas in m.measurements] -# observable_functions = [meas.observable.prediction for meas in m.measurements] -# observable_mins = [meas.observable.min for meas in m.measurements] -# observable_maxs = [meas.observable.max for meas in m.measurements] - -# bu = any(x->x!=Inf, observable_maxs) -# bl = any(x->x!=-Inf, observable_mins) -# check_bounds = any([bu, bl]) - -# limit_observable_functions = [limit.observable.prediction for limit in m.limits] -# limit_distributions = [make_dist(limit) for limit in m.limits] - -# invcov = inv(get_total_covariance(m)) - -# return EFTfitterDensityWithLimits( -# measured_values, -# observable_functions, -# observable_mins, -# observable_maxs, -# limit_distributions, -# limit_observable_functions, -# invcov, -# check_bounds -# ) -# end - -# function EFTfitterDensityNuisance(m::EFTfitterModel) -# n = length(m.measurements) -# measured_values = [meas.value for meas in m.measurements] -# observable_functions = [meas.observable.prediction for meas in m.measurements] -# observable_mins = [meas.observable.min for meas in m.measurements] -# observable_maxs = [meas.observable.max for meas in m.measurements] - -# bu = any(x->x!=Inf, observable_maxs) -# bl = any(x->x!=-Inf, observable_mins) -# check_bounds = any([bu, bl]) - - -# covs = get_covariances(m) - -# meas_keys = collect(keys(m.measurements)) -# unc_keys = collect(keys(m.correlations)) - - -# nuisances = _NuisanceCorrelation[] -# for (nui, nui_k) in zip(m.nuisances, collect(keys(m.nuisances))) -# unc = findfirst(x->x==nui.unc_key , unc_keys) -# i = findfirst(x->x==nui.meas1 , meas_keys) -# j = findfirst(x->x==nui.meas2 , meas_keys) -# push!(nuisances, _NuisanceCorrelation(unc, i, j, nui_k)) -# end - -# return EFTfitterDensityNuisance( -# measured_values, -# observable_functions, -# observable_mins, -# observable_maxs, -# covs, -# nuisances, -# check_bounds -# ) -# end - - - -function iswithinbounds(r::Float64, min::Float64, max::Float64) - return min <= r <= max -end - -# TODO: add dispatch, return 1 by default -function check_obs_bounds(r::Vector{Float64}, mins::Vector{Float64}, maxs::Vector{Float64}) - withinbounds = [iswithinbounds(r[i], mins[i], maxs[i]) for i in 1:length(r)] - all(withinbounds) ? (return 1.) : (return -Inf) -end - - -# why is this slower? -# function evaluate_funcs!(mus::NoModelUncertainties, arr::Vector{Function}, params, m) -# for i in eachindex(arr) -# m.predictions[Threads.threadid(), i] = arr[i](params) -# end -# end - - -# without model uncertainties -function evaluate_funcs!(mus::NoModelUncertainties, arr::Vector{Function}, params, m) - for i in eachindex(arr) - res::Prediction = Prediction(arr[i](params)) - m.predictions[Threads.threadid(), i] = res.pred - end -end - -# with model uncertainties -function evaluate_funcs!(mus::HasModelUncertainties, arr::Vector{Function}, params, m) - for i in eachindex(arr) - res::Prediction = Prediction(arr[i](params)) - m.predictions[Threads.threadid(), i] = res.pred - m.prediction_uncertainties[Threads.threadid(), i] = res.unc - end -end - - - -# # old: -# function DensityInterface.logdensityof( -# m::EFTfitterDensity, -# params -# ) -# r = evaluate_funcs(m.observable_functions, params) - -# if m.check_bounds -# ib = check_obs_bounds(r, m.observable_mins, m.observable_maxs) -# if ib == false -# return -Inf -# end -# end - -# r = r-m.measured_values -# r1 = m.invcov*r -# result = -dot(r, r1) - -# return 0.5*result -# end - - - -function DensityInterface.logdensityof( - m::EFTfitterDensity, - params -) - #Todo: move into calculate_likelihood? - evaluate_funcs!(m.mus, m.observable_functions, params, m) - - #TODO: check_observable_bounds - - - result = calculate_likelihood(m, m.mus, m.ls) - - return result -end - -# no model uncertainties, no limits, weights are already in the covariance matrix -function calculate_likelihood(m::EFTfitterDensity, mus::NoModelUncertainties, ls::NoLimits) - predictions = view(m.predictions, Threads.threadid(), :) - - @assert isa(m.matrix, InverseCovarianceMatrix) - - r = predictions-m.measured_values - r1 = m.matrix.m*r - result = -dot(r, r1) - - return 0.5*result -end - - -# TODO: specify for cholesky lower -function add_model_uncertainties!(m, r) - for i in 1:size(m.matrix.m, 1) - m.matrix.m[i, i] = m.original_diag[i] + r[i]^2 - end -end - -# with model uncertainties, no limits -function calculate_likelihood(m::EFTfitterDensity, mus::HasModelUncertainties, ls::NoLimits) - predictions = view(m.predictions, Threads.threadid(), :) - prediction_uncertainties = view(m.prediction_uncertainties, Threads.threadid(), :) - - @assert isa(m.matrix, CovarianceMatrix) - add_model_uncertainties!(m, prediction_uncertainties) - invcov = inv(m.matrix.m) - - r = m.weights .* (predictions-m.measured_values) # we - r1 = invcov*r - - result = -dot(r, r1) - - return 0.5*result -end - -# function DensityInterface.logdensityof( -# m::EFTfitterDensityWithLimits, -# params -# ) -# r = evaluate_funcs(m.observable_functions, params) - -# if m.check_bounds -# ib = check_obs_bounds(r, m.observable_mins, m.observable_maxs) -# if ib == false -# return -Inf -# end -# end - -# r = r-m.measured_values -# r1 = m.invcov*r -# result = -dot(r, r1) -# gaussian_result = 0.5*result - - -# r_limits = evaluate_funcs(m.limit_functions, params) -# ls=0. -# for i in eachindex(m.limit_distributions) -# ls += pdf(m.limit_distributions[i], r_limits[i]) -# end - - -# return gaussian_result + ls -# end - - -# function DensityInterface.logdensityof( -# m::EFTfitterDensityNuisance, -# params -# ) -# r = evaluate_funcs(m.observable_functions, params) - -# if m.check_bounds -# ib = check_obs_bounds(r, m.observable_mins, m.observable_maxs) -# if ib == false -# return -Inf -# end -# end - -# invcov = get_current_invcov(m, params) - -# r = r-m.measured_values -# r1 = invcov*r -# result = -dot(r, r1) - -# return 0.5*result -# end - - -function get_current_invcov(m, params) - for nui in m.nuisance_correlations.nuisances - i = nui.i; j = nui.j - - cov = params[nui.key] * sqrt(m.nuisance_correlations.covs[nui.unc][i, i]) * sqrt(m.nuisance_correlations.covs[nui.unc][j, j]) - m.nuisance_correlations.covs[nui.unc][i, j] = cov - m.nuisance_correlations.covs[nui.unc][j, i] = cov - end - - total_cov = sum(m.nuisance_correlations.covs) - invcov = inv(total_cov) -end - - - -function BAT.PosteriorMeasure(m::EFTfitterModel) - # if has_nuisance_correlations(m) # TODO: remove - # likelihood = EFTfitterDensityNuisance(m) - # return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) - # else - # likelihood = EFTfitterDensity(m) - # return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) - # end - likelihood = EFTfitterDensity(m) - return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) -end - -# function BAT.PosteriorMeasure(m::EFTfitterModelWithLimits) -# likelihood = EFTfitterDensityWithLimits(m) -# return posterior = BAT.PosteriorMeasure(likelihood, m.parameters) - -# end - - -# x = rand(5) -# M = rand(5,5) -# w = [4,4,4,4,5] -# w = length(w)*normalize(w, 1) - -# mean(w) - - -# x = ones(5) - -# r = dot(w.*x, M*x) - -# w .* x -# x - -# M2 = w .* M -# r2 = dot(x, M2*x) - -# r_unw = dot(x, M*x) - -# r_unw/r - -# w = [1, 2, 2, 1, 3] -# w = normalize(w, 1) - -# M2 =x .* M - -# x2 = w.*x -# r = dot(x2, M*x) - -# r2 = dot(x, M2*x) - - - - - - \ No newline at end of file From 4be464eecd16c88942f40ae0ac938ac85076b20b Mon Sep 17 00:00:00 2001 From: Cornelius-G Date: Fri, 27 Oct 2023 22:02:26 +0200 Subject: [PATCH 6/9] clean up files --- examples/cholesky.jl | 116 ------------------- examples/limits/plotting.jl | 111 ------------------ examples/limits/runLimits.jl | 97 ---------------- examples/limits/testing_limits.jl | 179 ----------------------------- examples/limits/tutorial_inputs.jl | 176 ---------------------------- examples/tutorial/functions.jl | 116 ------------------- 6 files changed, 795 deletions(-) delete mode 100644 examples/cholesky.jl delete mode 100644 examples/limits/plotting.jl delete mode 100644 examples/limits/runLimits.jl delete mode 100644 examples/limits/testing_limits.jl delete mode 100644 examples/limits/tutorial_inputs.jl delete mode 100644 examples/tutorial/functions.jl diff --git a/examples/cholesky.jl b/examples/cholesky.jl deleted file mode 100644 index 270ee20..0000000 --- a/examples/cholesky.jl +++ /dev/null @@ -1,116 +0,0 @@ -using LinearAlgebra - -function generate_covariance_matrix(size::Int) - # Generate a random square matrix of size x size - A = rand(size, size) - - # Construct the covariance matrix by multiplying A with its transpose - covariance_matrix = A * A' - - return covariance_matrix -end - - - - -function cholesky_product(M, x) - L = cholesky(M).L - z = L' * x - return dot(z, z) -end - -function cholesky_product2(L, x) - z = L * x - return dot(z, z) -end - -function my_product(M, x) - z = M * x - return dot(x, z) - -end - - - - -using BenchmarkTools - - -d = 100 - -M = generate_covariance_matrix(d) -x = rand(d) - -@btime my_product(M, x) - -L = cholesky(M).L'; -@btime cholesky_product2(L, x) - - - - - - -# For Model Uncertainties -using BenchmarkTools -using LinearAlgebra - -using LinearAlgebra - -# Define the lower Cholesky factor L and matrix A -L = [3.0 0.0 0.0; 2.0 1.0 0.0; 1.0 2.0 2.0] -A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0] - -# Compute M = L * L' -M = L * L' - -# Solve the linear system L * X = A -X = L \ A - -# Calculate the inverse of M + A using the Woodbury matrix identity -inv_MplusA = M \ (A * M \ I) - -# Print the result -println(inv_MplusA) - - - - -M + A -@btime inv(M + A) - - -# For Model Uncertainties -using LinearAlgebra - -function inverse_sum(M_inv, D) - n = size(M_inv, 1) # Assuming M_inv and D are square matrices of the same size - - # Calculate the intermediate matrices - A = inv(M_inv * D + I(n)) - B = M_inv * D * A - C = M_inv - B * M_inv - - return C -end - - -# Define the matrices M, D, and M_inv -d = 500 -L = rand(d) -M = L*L' # Example symmetric positive definite matrix -D = Diagonal(rand(d)) # Example diagonal matrix -M_inv = inv(M) # Inverse of M - -# Calculate the inverse of M + D using M_inv -@btime inverse_sum(M_inv, D) - -@btime inv($(M + D)) - - -using WoodburyMatrices - -W = Woodbury(M, I(d), D, I(d)) - -Wi = inv(W) -Matrix(Wi) \ No newline at end of file diff --git a/examples/limits/plotting.jl b/examples/limits/plotting.jl deleted file mode 100644 index 4bf2f5b..0000000 --- a/examples/limits/plotting.jl +++ /dev/null @@ -1,111 +0,0 @@ -# EFTfitter.jl - Plotting Tutorial -# EFTfitter includes several recipes for plotting its datatypes -# using [Plots.jl](http://docs.juliaplots.org/latest/) -using EFTfitter -using BAT -using IntervalSets -using Distributions -using Plots - -# we use the inputs from the basic tutorial: -include("tutorial_inputs.jl") -model = EFTfitterModel(parameters, measurements, correlations) - -posterior = PosteriorMeasure(model) -algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) -samples = bat_sample(posterior, algorithm).result; - -# Note: All plots generated with the following plot recipes can be customized using the -# [series attributes](http://docs.juliaplots.org/latest/generated/attributes_series/), -# [axis attributes](http://docs.juliaplots.org/latest/generated/attributes_axis/), -# [subplot attributes](http://docs.juliaplots.org/latest/generated/attributes_subplot/) and -# [plot attributes](http://docs.juliaplots.org/latest/generated/attributes_plot/) - - -# ---------- Plotting Observables ------------------------- - -# Plotting an `Observable` object: -plot(Observable(xsec1), (C1=0, C2=-1:0.01:1)) - -# When plotting an `Observable` from the `EFTfitterModel`, it can be accessed in different ways: -plot(get_observables(model).xsec1, (C1=0, C2=-1:0.01:1)) - -plot(get_measurements(model).Meas1.observable, (C1=0, C2=-1:0.01:1)) - - -# If the model has many parameters, it can be convenient to pass the paramter that should be -# plotted together with as a `NamedTuple` with default values for all parameters. -default_parameters = (C1=1, C2=0) -plot(get_observables(model).xsec1, (C2=-1:0.01:1,), default_parameters) - -# The second argument in this function overwrites the corresponding default parameters, -# so it is also possible to pass multiple parameters: -plot(get_observables(model).xsec1, (C2=-1:0.01:1, C1=2.3), default_parameters) - -# All observables of a model can easily be plotted in one plot: -p = plot() -for meas in get_measurements(model) - p=plot!(meas.observable, (C1=0, C2=-1:0.01:1), ylabel="prediction") -end -p - -# When plotting observables, the default title contains the values of the fixed# parameters. In case the title is too long for one line, linebreaks can be inserted# using the keyword `titlewidth`. e.g.: -plot(get_observables(model).xsec1, (C1=-10:0.01:10, C2=0, C3=100, C4=200), titlewidth=13) - -# ---------- Plotting Measurements ------------------------- - -# `Measurement` objects can be plotted on top of the observables as a horizontal line with an uncertainty band: -plot(get_measurements(model).Meas1.observable, (C1=0, C2=-0.2:0.01:0.2)) -plot!(measurements.Meas1) - - -# However, when plotting the measurements of the `EFTfitterModel`, the following syntax -# is preferred as it supports showing the names of the measurments in the legend: -plot(get_measurements(model).Meas1.observable, (C1=0, C2=-0.2:0.01:0.2)) -plot!(get_measurements(model), :Meas1) - -# The uncertainty typed to be plotted can be specified: -plot(get_measurements(model).Meas1.observable, (C1=0, C2=-0.2:0.01:0.2)) -plot!(get_measurements(model), :Meas1, uncertainties=(:stat, :another_unc)) - -# When mutliple types of uncertainties are given, the sum of the squares is used as the total uncertainty. -# By default, all uncertainties included in the `EFTfitterModel` are used. - -# ---------- Plotting MeasurementDistributions ------------------------- -# `MeasurementDistribution`s can be plotted for fixed parameters: -plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) -plot!(get_measurement_distributions(model), :MeasDist) - -# alternative plotting style for measurement distributions: -plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) -plot!(get_measurement_distributions(model), :MeasDist, st=:scatter) - -# Also for `MeasurementDistribution`s the uncertainty types to be plotted can be specified. -# The names of the bins can be customized using the `bin_names` keyword. -plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) -plot!(get_measurement_distributions(model), :MeasDist, st=:scatter, uncertainties=(:stat,), bin_names=("First bin", "Second bin")) - - -# ---------- Plotting 1D Intervals ------------------------- -# Default plot of the smallest 1D intervals containing 90% posterior probability: -plot(samples, 0.9) - -# Default settings for keywords: -plot(samples, 0.9, - parameter_names = get_parameter_names(maybe_shaped_samples), # Array of String with the names of the parameters - y_positions = collect(1:length(parameter_names))*-1, # y-positions of the interval lines - y_offset = 0, # offest on the y-axis, helpful when plotting multiple samples on top of each other - bins = 200, # number of bins for calculating smallest intervals - atol = 0,) # merge intervals that are seperated less then atol (especially helpful when using a high number of bins) - -# helpful keyword arguments: -# msc = markerstrokecolor: color of the interval lines -# msw = markerstrokewidth: linewidth -# ms = markersize: size of caps - -# Customized 1D interval plot: -p = plot(samples, 0.9, bins = 400, atol=0.01, y_offset=-0.1, label = "Samples A") -p = plot!(samples, 0.9, bins = 100, atol=0.05, y_offset=0.1, msw = 5, ms=8, msc=:red, label = "Samples B") - -# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - diff --git a/examples/limits/runLimits.jl b/examples/limits/runLimits.jl deleted file mode 100644 index b764651..0000000 --- a/examples/limits/runLimits.jl +++ /dev/null @@ -1,97 +0,0 @@ -# EFTfitter.jl - Tutorial -# This tutorial introduces the basic functionalities of EFTfitter.jl using a generic example. -# More functionalities of EFTfitter.jl, like handling nuisance correlations -# or ranking measurements and uncertainties, are shown in the -# [advanced tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/advanced_tutorial/). - -# Here, we create the `EFTfitterModel` from our inputs and run the actual analysis. - -# First, we need to setup EFTfitter, BAT and some other Julia packages: -using EFTfitter -using BAT # for sampling -using IntervalSets # for specifying the prior -using Distributions # for specifying the prior -using Plots # for plotting - -# We include the definitions of observables, measurements, -# uncertainties and correlations from our `tutorial_inputs.jl` file: -include("tutorial_inputs.jl") - -# We can then build the `EFTfitterModel` which combines all our inputs into -# one object that is then used to perform the analysis on. -model = EFTfitterModelWithLimits(parameters, measurements, correlations, limits) - -# To sample the posterior distribution, we specify that our `EFTfitterModel` -# should be used and then setup BAT.jl to sample the EFTfitter likelihood. -posterior = PosteriorMeasure(model) - -algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) -samples = bat_sample(posterior, algorithm).result; -# For further information on settings & algorithms when sampling with BAT.jl -# see the BAT.jl [tutorial](https://bat.github.io/BAT.jl/dev/tutorial/#Parameter-Space-Exploration-via-MCMC) -# and [documentation](https://bat.github.io/BAT.jl/dev/stable_api/#BAT.bat_sample). - -# We can then inspect the results of the sampling using BAT.jl's `SampledDensity`, -# giving a summary of the sampling and the results of the model parameters. -sd = SampledDensity(posterior, samples) -display(sd) - -# Information about the smallest 1d intervals containing p% proability can be -# obtained using the `get_smallest_interval_edges` function: -intervals_1d_C1 = get_smallest_interval_edges(samples, :C1, 0.9, bins=200, atol=0.1) -println("lower interval edges: $(intervals_1d_C1.lower)") -println("upper interval edges: $(intervals_1d_C1.upper)") - -# The keyword `atol` controls the absolute tolerance for which intervals are joined -# together when they are seperated less than this value. This is particularly useful -# when a large number of bins is used. - -# Of course, plotting the resulting posterior distributions is also simple -# using Plots.jl and the BAT.jl plotting recipes: -p = plot(samples) -savefig(p, "plot.pdf") - -# For information on how to customize plots of the samples, please see the BAT.jl -# [plotting documentation](https://bat.github.io/BAT.jl/dev/plotting/) and -# [examples](https://github.com/bat/BAT.jl/blob/master/examples/dev-internal/plotting_examples.jl). - -p = plot(samples, 0.9) -savefig(p, "plot_1d.pdf") - -# For customizing the plots of the 1D intervals, also see the EFTfitter -# [plotting documentation](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/plotting/) -# and [tutorial](https://github.com/tudo-physik-e4/EFTfitter.jl/blob/main/examples/tutorial/plotting.jl). - -# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - - -using SpecialFunctions - -μ = 0.0 -p = 0.9 -q = 8.5 - -function Normal_from_limit(best_fit_value, limit, confidence_level) - μ = best_fit_value - p = confidence_level - q = limit - - σ = (q - μ)/(sqrt(2)*erfinv(2*p-1)) - - return Normal(μ, σ) -end - -function Exponential_from_limit(limit, confidence_level) - p = confidence_level - q = limit - - λ = -1/q * log(1-p) - - return Exponential(1/λ) -end - - -quantile(Normal_from_limit(μ, q, p), p) -quantile(Exponential_from_limit(q, p), p) - - diff --git a/examples/limits/testing_limits.jl b/examples/limits/testing_limits.jl deleted file mode 100644 index f409fa8..0000000 --- a/examples/limits/testing_limits.jl +++ /dev/null @@ -1,179 +0,0 @@ -using BAT -using EFTfitter -using Distributions -using DensityInterface -using Plots -gr(size=(1000,800), thickness_scaling=2) - - - -# Counting experiment (Poisson distribution) -# Expected Background: b = 3.4 -# Observed: N=3 -# What is 95% upper limit on s? - - -likelihood = logfuncdensity(params -> begin - s = params.s - b = params.b - n = 0#3 - - return logpdf.(Poisson(s+b), n)#logpdf(Normal(1.9, 1.6), s)#logpdf.(Poisson(s+b), n) - -end) - -prior = BAT.NamedTupleDist( - s = Uniform(0, 12), - b = 0#3.4, #truncated(Normal(3.4, 2.), 0.01, Inf) -) - -posterior = PosteriorMeasure(likelihood, prior); - -samples, chains = bat_sample(posterior, MCMCSampling(mcalg = MetropolisHastings(), nsteps = 4*10^6)); - -plot(samples, intervals=[0.9], bins=500) - -interval_edges = get_smallest_interval_edges(samples, :s, 0.9, bins=500) - -upper_limit = interval_edges.upper[1] - -using SpecialFunctions -function Normal_from_limit(best_fit_value, limit, confidence_level) - μ = best_fit_value - p = confidence_level - q = limit - - σ = (q - μ)/(sqrt(2)*erfinv(p)) - - return Normal(μ, σ) -end - -function Exponential_from_limit(limit, confidence_level) - p = confidence_level - q = limit - - λ = -1/q * log(1-p) - - return Exponential(1/λ) -end - -exponential_dist = Exponential_from_limit(upper_limit, 0.9) -normal_dist = Normal_from_limit(-10, upper_limit, 0.9) - -x = 0:0.1:12 -plot(samples, :s, intervals=[0.9], bins=500, label="Posterior") -plot!(x, pdf.(exponential_dist, x), lw=4, lc=1, label="Exponential from limit", legend=true) -plot!(x, 20*pdf.(normal_dist, x), lw=4, lc=2, label="Normal from limit", legend=true) - - -g(x) = (x+3.4)^3/6 * exp(-(x+3.4)) - -g(x) = exp(-(x)) -plot!(x, 1.8*g.(x), lw=4, lc="black", label="Poisson", legend=true) - - -g(x; μ=0, N=0) = (x+μ)^N * exp(-(x+μ)) - -x = 0:0.05:6 -plot(x, g.(x, μ=2, N=4)) - -#------------------------------------------------------------ -using DelimitedFiles - -data_file = "C:\\Users\\Cornelius\\Projects\\plot2.csv" - -data = readdlm(data_file, ';', Float64) - -idxs = sortperm(data[:,1]) -points_x = data[:, 1][idxs] -points_y = 1 .- data[:, 2][idxs] -points_y2 = data[:, 2][idxs] - -x = 0.22:0.01:5.6 -x1 = 0.22:0.01:2 -x2 = 2.01:0.01:5.8 - -plot(points_x, points_y, st=:scatter, ms=2) - -using Interpolations -itp = interpolate((points_x,), points_y, Gridded(Linear())) - -plot!(x, itp.(x1), lw=2) - - -dx = only.(Interpolations.gradient.(Ref(itp), x)) - -plot!(x, dx, lw=2) - -poi(N) = x-> x^N/factorial(N)*exp(-x) - -plot(points_x, points_y2, st=:scatter, msw=0, ms=2) -#plot!(x1, 2*poi(0).(x1)) -a=0.64 -a2 = 2.2 -plot!(x1, 0.35 .+ a.*exp.(-a*x1)) -plot!(x2, -0.05 .+ a2.*exp.(-a*x2)) - -f1(x; a=0.64) = 1-(0.35 .+ a.*exp.(-a*x)) -f2(x; a=2.2) = 1-(-0.05 .+ a.*exp.(-a*x)) - -plot(points_x, points_y, st=:scatter, ms=2, msw=0) -plot!(x1, f1.(x1), lw=2) -plot!(x2, f2.(x2), lw=2) - - - -#--------------------------------------- -n = 47 -plot(points_x[1:n], points_y[1:n], st=:scatter, msw=0, ms=2) -plot!(points_x[n:end], points_y[n:end], st=:scatter, msw=0, ms=2, color=2) - -@. ffq(x, p) = p[1]*x^2 + p[2]*x + p[3] + p[4]*x^3 + p[5]*x^4 - - -p0 = ones(5) -fit = curve_fit(ffq, points_x[1:n], points_y[1:n], p0) -p1 = fit.param -plot!(x1, ffq(x1, p1), lw=3) - - -fit = curve_fit(ffq, points_x[n:end], points_y[n:end], p0) -p2 = fit.param -plot!(x2, ffq(x2, p2), lw=3) - - -ffq(p) = x -> ffq(x, p) - -using ForwardDiff -plot!(x1, ForwardDiff.derivative.(ffq(p1), x1)) -plot!(x2, ForwardDiff.derivative.(ffq(p2), x2)) - -plot!(x2, pdf.(Normal(2, 1.6), x2)) - - - - - - - - - - - - - -using StatsFuns - -plot(points_x, points_y, st=:scatter, msw=0, ms=2) - - -using LsqFit - -@. model2(x, p) = p[3]*StatsFuns.nchisqpdf(x, p[1], p[2]) - -p0 = [0.05, 1, 0.1] # Initial guesses for the two parameters of the model -# Fitting the model to the data using nonlinear least-squares optimization -fit = curve_fit(model2, points_x[1:20], points_y[1:20], p0) -fit.param - -plot!(x1, model2(x1, fit.param)) \ No newline at end of file diff --git a/examples/limits/tutorial_inputs.jl b/examples/limits/tutorial_inputs.jl deleted file mode 100644 index 9e3860e..0000000 --- a/examples/limits/tutorial_inputs.jl +++ /dev/null @@ -1,176 +0,0 @@ -# EFTfitter.jl - Tutorial -# This tutorial introduces the basic functionalities of EFTfitter.jl using a generic example. -# More functionalities of EFTfitter.jl, like handling nuisance correlations -# or ranking measurements and uncertainties, are shown in the -# [advanced tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/advanced_tutorial/). - - -# We start by defining all neccesary inputs to create an -# [`EFTfitterModel`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.EFTfitterModel). - -# ============= Parameters =============================================# -# We specify the parameters our model depends on and choose a prior for each of the parameters. -# The prior has to be specified in form of a [BAT.jl prior](https://bat.github.io/BAT.jl/dev/tutorial/#Prior-Definition). - -# For our example, we consider two parameters with the names `C1` and `C2`. -# For `C1` we choose a uniform (flat) prior in the range (-3, 3). -# For `C2` we choose a gaussian prior with μ=0 and σ=0.5. -parameters = BAT.NamedTupleDist( - C1 = -3..3, # short for: Uniform(-3, 3) - C2 = Normal(0, 0.5) # Normal distribution -) - -# A parameter can be fixed (and therefore excluded from the fit) by setting its -# prior to a certain value, e.g.: `C2 = 0`. -# Also see [here](https://bat.github.io/BAT.jl/dev/tutorial/#Prior-Definition) -# for more information on priors in the BAT.jl documentation. - -# ============= Observables =============================================# -# We now proceed to implement `Functions` that specify how the predicted values -# of the observables depend on the model parameters. -# For each observable, we need to provide a `Function` that returns the predicted -# value of the observable for certain values of the model parameters. In our example, -# we consider two observables (e.g. cross sections) by defining the two functions `xsec1` and `xsec2`. - -# Note: The functions for the observables may only have the model parameters as -# their only argument. You can, however define a function that only depends on -# the parameters and that internally calls a more complex function and passes the -# corresponding arguments. In this example, the function `xsec2` calls the -# function `myfunc` and passes further arguments (`coeffs`). - -function xsec1(params) - c = [20.12, 5.56, 325.556] - return c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 -end - -function xsec2(params) - coeffs = [2.12, 4.3, 12.6] - return myfunc(params, coeffs) -end - -function myfunc(params, c) - return c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 -end - -# If your observable is a distribution, you can define a vector of functions -# with one function for each bin of the distribution. -# (You could also treat each bin as a separate observable as shown above.) - -function diff_xsec_bin1(params) - coeffs = [2.2, 5.5, 6.6] - return myfunc(params, coeffs) -end - -function diff_xsec_bin2(params) - coeffs = [3.3, 4.8, 7.6] - return myfunc(params, coeffs) -end - -function diff_xsec_bin3(params) - coeffs = [4.9, 5.6, 8.9] - return myfunc(params, coeffs) -end - -diff_xsec = [diff_xsec_bin1, diff_xsec_bin2, diff_xsec_bin3] - -# Note: Another way to define a vector of functions for the bins of distributions -# is shown [here](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/advanced_tutorial/#Creating-a-vector-of-functions-for-distributions-1) -# in the [advanced tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/advanced_tutorial/). -# This can be particularly useful when the predictions for the individual bins -# have a similar functional relation and only differ in terms of some coefficients, -# as it is the case here in this example. - -# ============= Measurements =============================================# -# We can now enter measurements of the observables. -# This is done by defining a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) -# consisting of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) -# and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution) objects. - -# A `Measurement` consists of the observable, the measured numerical value and -# numerical values for the (multiple types of) uncertainties. -# The observable can be passed to the `Measurement` either as an [`Observable`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Observable) -# object or as a `Function`. When using the latter, the observable is assumed to be unconstrained. -# The uncertainties are passed as a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types). -# Each measurement has to provide uncertainty values for all of the (active) uncertainty -# types (see next section on `Correlations`). For a `MeasurementDistribution`, -# the corresponding inputs have to be passed as `Vectors`, where each element -# represents one bin of the distribution. - -# A `Measurement` can be excluded from the model by setting the switch `active=false`. -# For a `MeasurementDistribution`, the keyword `active` accepts `true` or `false` -# to (de)activate the whole distribution or a vector of booleans for (de)activating only certain bins. - -measurements = ( - Meas1 = Measurement(xsec1, 21.6, uncertainties = (stat=0.8, syst=1.8, another_unc=2.3), - active=true), # `active = false`: exclude measurement from fit (default: active = true) - - Meas2 = Measurement(Observable(xsec2, min=0), 1.9, - uncertainties = (stat=0.6, syst=0.9, another_unc=1.1), active=true), - - MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4], - uncertainties = (stat = [0.7, 1.1, 1.2], syst= [0.7, 0.8, 1.3], another_unc = [1.0, 1.2, 1.9]), - active=[true, false, true]), # `active = false`: exclude all bins from fit, `active = [true, true, false]`: exclude only third bin from fit -) - -limits = ( - UL1 = GaussianUpperLimit(xsec1, 0.01, 5.0, 0.9), -) - -# Further information on the constructors see the API documentation of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) -# and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution). - -# Note: When using only one measurement or only one type of uncertainties, -# make sure to insert a comma, like: `uncertainties = (stat = 0.5,)` so that -# Julia can parse the [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) correctly! - - -# ============= Correlations =============================================# -# The correlations between the uncertainties of the measurements need to be provided -# for each of the uncertainty types. We can pass them by defining a `NamedTuple` -# of [`Correlation`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Correlation) -# objects that contain the corresponding correlation matrices. -# The correlation matrix for each type of uncertainty needs to have a size -# of ``N \times N``, where ``N`` is the number of measurements, counting each bin of a distribution. -# When a certain type of uncertainty should not be considered, it can be deactivated -# by setting `active = false`. This means that the uncertainty values given in the -# corresponding `Measurement` and `MeasurementDistribution` objects will not be used. - -# When assuming the uncertainties of all measurements are uncorrelated, you can -# use the `NoCorrelation` object for easily passing an identity matrix of the correct size. - -# When using a large number of measurements, entering the correlation matrix becomes -# quite impractical, especially if you want to add further measurements later. -# With the function `to_correlation_matrix`, it is possible to enter a correlation -# matrix by simply specifying the names of the measurements that should be correlated -# and the value of the corresponding correlation coefficient. -# When using a `MeasurementDistribution`, the inter-bin correlations can also be -# entered by passing a matrix. By appending `_binX` to the name of a `MeasurementDistribution`, -# the Xth bin of the distribution can be accessed. -# Note: This function is evaluated from top to bottom, so if you overwrite a -# specific correlation value, the last value entered will be used. - -dist_corr = [1.0 0.5 0.0; - 0.5 1.0 0.0; - 0.0 0.0 1.0] - -another_corr_matrix = to_correlation_matrix(measurements, - (:Meas1, :Meas2, 0.4), # correlate measurements :Meas1 and :Meas2 with a correlation coefficient of 0.4 - (:Meas1, :MeasDist, 0.1), # correlate all bins of :MeasDist with :Meas1 with 0.1 - (:MeasDist, :MeasDist, dist_corr), # correlate the bins of :MeasDist according to the matrix dist_corr - (:MeasDist_bin2, :MeasDist_bin3, 0.3), # correlate bin2 of :MeasDist with bin3 with 0.3 (overwrites the corresponding element set in the previous line, but ignored in fit since MeasDist_bin2 is inactive) -) - -correlations = ( - stat = NoCorrelation(active=true), # will use the identity matrix of the correct size - - syst = Correlation([1.0 0.5 0.3 0.2 0.2; - 0.5 1.0 0.2 0.2 0.2; - 0.3 0.2 1.0 0.2 0.2; - 0.2 0.2 0.2 1.0 0.2; - 0.2 0.2 0.2 0.2 1.0], active=false), # `active = false`: ignore all uncertainty values and correlations for this type of uncertainty - - another_unc = Correlation(another_corr_matrix, active=true) -) - -# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - diff --git a/examples/tutorial/functions.jl b/examples/tutorial/functions.jl deleted file mode 100644 index 2d3b0ca..0000000 --- a/examples/tutorial/functions.jl +++ /dev/null @@ -1,116 +0,0 @@ -using BenchmarkTools - -struct Prediction - pred::Float64 - unc::Float64 -end - -Prediction(a::Float64) = Prediction(a, 0.) -Prediction(a::Tuple{Float64, Float64}) = Prediction(a[1], a[2]) -Prediction(a::Prediction) = a - -observable1(params) = rand() -observable2(params) = (rand(), rand()) - -functions_vector_1 = fill(observable1, 100) -functions_vector_2 = fill(observable2, 100) -functions_vector_12 = vcat(fill(observable1, 50), fill(observable2, 50)) - - -# using tuple: -to_tuple(f) = x -> (f(x), 0.) -functions_vector_12_tuple = vcat(fill(to_tuple(observable1), 50), fill(observable2, 50)) - - -# using Prediction struct: -observable1_p(params) = Prediction(rand()) -observable2_p(params) = Prediction(rand(), rand()) - -functions_vector_2_p = fill(observable2_p, 100) -functions_vector_12_p = vcat(fill(observable1_p, 50), fill(observable2_p, 50)) - - -function eval_functions_a(f_vec, params) - res = [f(params) for f in f_vec] - return res -end - -function eval_functions_a2(f_vec, params) - res::Vector{Tuple{Float64, Float64}} = [f(params) for f in f_vec] - return res -end - - -function eval_functions_c(f_vec, params, preds, uncs) - for i in eachindex(f_vec) - res::Tuple{Float64, Float64} = f_vec[i](params) - preds[i] = res[1] - uncs[i] = res[2] - end - return preds, uncs -end - -function eval_functions_d(f_vec, params, preds, uncs) - for i in eachindex(f_vec) - res::Prediction = f_vec[i](params) - preds[i] = res.pred - uncs[i] = res.unc - end - #return preds, uncs -end - - -function eval_functions_f(f_vec, params) - ps = Float64[] - uncs = Float64[] - for i in eachindex(f_vec) - res::Prediction = f_vec[i](params) - push!(ps, res.pred) - push!(uncs, res.unc) - end - return ps, uncs -end - -function eval_functions_e(f_vec, params, preds, uncs) - for i in eachindex(f_vec) - res::Prediction = Prediction(f_vec[i](params)) - preds[i] = res.pred - uncs[i] = res.unc - end - return preds, uncs -end - -params = rand(3) - -# A: Current EFTfitter Implementation -@btime eval_functions_a(functions_vector_1, params) -@btime eval_functions_a(functions_vector_2, params) -@btime eval_functions_a(functions_vector_12, params) -@btime eval_functions_a(functions_vector_12_tuple, params) - -@code_llvm eval_functions_a(functions_vector_12, params) - -# B: - - -# C: Using preallocation -preds = zeros(100) -uncs = zeros(100) -@btime eval_functions_c(functions_vector_2, params, preds, uncs) -@btime eval_functions_c(functions_vector_12_tuple, params, preds, uncs) - - -# C: Using preallocation & Prediction Type -preds = zeros(100) -uncs = zeros(100) -@btime eval_functions_d(functions_vector_2_p, params, preds, uncs) -@btime eval_functions_d(functions_vector_12_p, params, preds, uncs) -@btime eval_functions_f(functions_vector_12_p, params) - - -@btime eval_functions_e(functions_vector_12, params, preds, uncs) - - -@code_warntype eval_functions_d(functions_vector_12_p, params, preds, uncs) - -typeof((1.,2.)) \ No newline at end of file From a2dc5d7268b103bb6401820c788b5ea030c0a65b Mon Sep 17 00:00:00 2001 From: Cornelius-G Date: Fri, 27 Oct 2023 22:16:41 +0200 Subject: [PATCH 7/9] update run_speed_test function --- src/utils.jl | 46 ++++++++++++++++++++++++++++++++++++---------- test/test_plain.jl | 2 ++ 2 files changed, 38 insertions(+), 10 deletions(-) diff --git a/src/utils.jl b/src/utils.jl index 4e3be74..0a888c6 100755 --- a/src/utils.jl +++ b/src/utils.jl @@ -74,30 +74,55 @@ end - function run_logdensity(posterior, vs) [logdensityof(posterior)(v) for v in vs] end +""" + run_speed_test(m::EFTfitterModel; matrix_types=[Matrix, sparse, Symmetric], vs=rand(m.parameters, 10), verbose=true) + +Test different data types for the (inverse) covariance matrix to find the optimal one in terms of speed. + +# Arguments +- `m::EFTfitterModel`: The model for which the speed test is performed. + +# Keyword Arguments +- `matrix_types::Vector{DataType}=[Matrix, sparse, Symmetric]`: The types of matrices to be tested. +- `vs`: Sample values to test. Default is 10 random samples from `m.parameters`. +- `verbose::Bool=true`: If `true`, informative messages and results are displayed during the test. + +# Returns +- A table summarizing the test results, showing minimum computation times, memory allocations, etc., for each matrix type. +- A list of benchmark results for each matrix type. + +Notes + +The function benchmarks the provided matrix types using the given sample values and returns recommendations based on minimum computation times. +The recommended matrix type is the one with the shortest minimum time. + +# Example +```julia-repl +julia> tbl, benchmarks = run_speed_test(model) +``` +""" -export run_speed_test function run_speed_test( m::EFTfitterModel; - typs= [Matrix, sparse, Symmetric], + matrix_types = [Matrix, sparse, Symmetric], vs = rand(m.parameters, 10), verbose=true ) @info "Running speed comparisons to find optimal data type for (inverse) covariance matrix!" benchmarks = [] - covtyps = [] + mtypes = [] - for t in typs + for t in matrix_types current_model = @set m.CovarianceType = t; posterior = PosteriorMeasure(current_model) - current_invcov_type = typeof(posterior.likelihood.density._d.invcov) - push!(covtyps, current_invcov_type) + current_invcov_type = typeof(posterior.likelihood.density._d.crossmatrix.m) + push!(mtypes, current_invcov_type) verbose ? (@info "Testing type: $(current_invcov_type)") : nothing @@ -107,12 +132,12 @@ function run_speed_test( verbose ? display(b) : nothing end - median_times = median.([b.times for b in benchmarks]) - sorted_idxs = sortperm(median_times) + min_times = minimum.([b.times for b in benchmarks]) + sorted_idxs = sortperm(min_times) allocations = [benchmarks[i].allocs for i in sorted_idxs] memory = [benchmarks[i].memory for i in sorted_idxs] - tbl = Table(Type=covtyps[sorted_idxs], MedianTime=median_times[sorted_idxs], Allocations=allocations, Memory=memory) + tbl = Table(Type=mtypes[sorted_idxs], MinTime=min_times[sorted_idxs], Allocations=allocations, Memory=memory) verbose ? display(tbl) : nothing @@ -120,3 +145,4 @@ function run_speed_test( return tbl, benchmarks end +export run_speed_test \ No newline at end of file diff --git a/test/test_plain.jl b/test/test_plain.jl index fba398e..0e83d69 100644 --- a/test/test_plain.jl +++ b/test/test_plain.jl @@ -57,6 +57,8 @@ correlations = ( model = EFTfitterModel(parameters, measurements, correlations, ) posterior = PosteriorMeasure(model) +run_speed_test(model) + v = (p1 = 10.826122384321511, p2 = -8.32129957354641) logp = logdensityof(posterior) logp(v) From 5ac79b5ffb6e0a8915f9a715042282f944594a80 Mon Sep 17 00:00:00 2001 From: Cornelius-G Date: Fri, 27 Oct 2023 22:21:41 +0200 Subject: [PATCH 8/9] update tutorial --- docs/src/tutorial.md | 52 +++---- examples/tutorial/runTutorial.jl | 212 +-------------------------- examples/tutorial/tutorial_inputs.jl | 9 +- 3 files changed, 33 insertions(+), 240 deletions(-) diff --git a/docs/src/tutorial.md b/docs/src/tutorial.md index ed8a5e9..8a4dc83 100644 --- a/docs/src/tutorial.md +++ b/docs/src/tutorial.md @@ -26,12 +26,12 @@ For our example, we consider two parameters with the names `C1` and `C2`. For `C1` we choose a uniform (flat) prior in the range (-3, 3). For `C2` we choose a gaussian prior with μ=0 and σ=0.5. -```julia +````julia parameters = BAT.NamedTupleDist( C1 = -3..3, # short for: Uniform(-3, 3) C2 = Normal(0, 0.5) # Normal distribution ) -``` +```` A parameter can be fixed (and therefore excluded from the fit) by setting its prior to a certain value, e.g.: `C2 = 0`. @@ -51,7 +51,7 @@ the parameters and that internally calls a more complex function and passes the corresponding arguments. In this example, the function `xsec2` calls the function `myfunc` and passes further arguments (`coeffs`). -```julia +````julia function xsec1(params) c = [20.12, 5.56, 325.556] return c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 @@ -65,13 +65,13 @@ end function myfunc(params, c) return c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 end -``` +```` If your observable is a distribution, you can define a vector of functions with one function for each bin of the distribution. (You could also treat each bin as a separate observable as shown above.) -```julia +````julia function diff_xsec_bin1(params) coeffs = [2.2, 5.5, 6.6] return myfunc(params, coeffs) @@ -88,7 +88,7 @@ function diff_xsec_bin3(params) end diff_xsec = [diff_xsec_bin1, diff_xsec_bin2, diff_xsec_bin3] -``` +```` Note: Another way to define a vector of functions for the bins of distributions is shown [here](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/advanced_tutorial/#Creating-a-vector-of-functions-for-distributions-1) @@ -117,7 +117,7 @@ A `Measurement` can be excluded from the model by setting the switch `active=fal For a `MeasurementDistribution`, the keyword `active` accepts `true` or `false` to (de)activate the whole distribution or a vector of booleans for (de)activating only certain bins. -```julia +````julia measurements = ( Meas1 = Measurement(xsec1, 21.6, uncertainties = (stat=0.8, syst=1.8, another_unc=2.3), active=true), # `active = false`: exclude measurement from fit (default: active = true) @@ -129,7 +129,7 @@ measurements = ( uncertainties = (stat = [0.7, 1.1, 1.2], syst= [0.7, 0.8, 1.3], another_unc = [1.0, 1.2, 1.9]), active=[true, false, true]), # `active = false`: exclude all bins from fit, `active = [true, true, false]`: exclude only third bin from fit ) -``` +```` Further information on the constructors see the API documentation of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution). @@ -162,7 +162,7 @@ the Xth bin of the distribution can be accessed. Note: This function is evaluated from top to bottom, so if you overwrite a specific correlation value, the last value entered will be used. -```julia +````julia dist_corr = [1.0 0.5 0.0; 0.5 1.0 0.0; 0.0 0.0 1.0] @@ -173,9 +173,9 @@ another_corr_matrix = to_correlation_matrix(measurements, (:MeasDist, :MeasDist, dist_corr), # correlate the bins of :MeasDist according to the matrix dist_corr (:MeasDist_bin2, :MeasDist_bin3, 0.3), # correlate bin2 of :MeasDist with bin3 with 0.3 (overwrites the corresponding element set in the previous line, but ignored in fit since MeasDist_bin2 is inactive) ) -``` +```` -```julia +````julia correlations = ( stat = NoCorrelation(active=true), # will use the identity matrix of the correct size @@ -187,37 +187,37 @@ correlations = ( another_unc = Correlation(another_corr_matrix, active=true) ) -``` +```` ## File "runTutorial.jl" Here, we create the `EFTfitterModel` from our inputs and run the actual analysis. First, we need to setup EFTfitter, BAT and some other Julia packages: -```julia +````julia using EFTfitter using BAT # for sampling using IntervalSets # for specifying the prior using Distributions # for specifying the prior using Plots # for plotting -``` +```` We can then build the `EFTfitterModel` which combines all our inputs into one object that is then used to perform the analysis on. -```julia +````julia model = EFTfitterModel(parameters, measurements, correlations) -``` +```` To sample the posterior distribution, we specify that our `EFTfitterModel` should be used and then setup BAT.jl to sample the EFTfitter likelihood. -```julia +````julia posterior = PosteriorMeasure(model) algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) samples = bat_sample(posterior, algorithm).result; -``` +```` For further information on settings & algorithms when sampling with BAT.jl see the BAT.jl [tutorial](https://bat.github.io/BAT.jl/dev/tutorial/#Parameter-Space-Exploration-via-MCMC) @@ -226,7 +226,7 @@ and [documentation](https://bat.github.io/BAT.jl/dev/stable_api/#BAT.bat_sample) We can then inspect the results of the sampling using BAT.jl's `SampledDensity`, giving a summary of the sampling and the results of the model parameters. -```julia +````julia sd = SampledDensity(posterior, samples) display(sd) ``` @@ -258,16 +258,16 @@ cov ╲ │ C1 C2 ───────┼───────────────────────── C1 │ 0.122271 -0.0070394 C2 │ -0.0070394 0.000442548 -``` +```` Information about the smallest 1d intervals containing p% proability can be obtained using the `get_smallest_interval_edges` function: -```julia +````julia intervals_1d_C1 = get_smallest_interval_edges(samples, :C1, 0.9, bins=200, atol=0.1) println("lower interval edges: $(intervals_1d_C1.lower)") println("upper interval edges: $(intervals_1d_C1.upper)") -``` +```` The keyword `atol` controls the absolute tolerance for which intervals are joined together when they are seperated less than this value. This is particularly useful @@ -276,10 +276,10 @@ when a large number of bins is used. Of course, plotting the resulting posterior distributions is also simple using Plots.jl and the BAT.jl plotting recipes: -```julia +````julia p = plot(samples) savefig(p, "plot.pdf") -``` +```` ![example plot](plots/plot.png) @@ -287,10 +287,10 @@ For information on how to customize plots of the samples, please see the BAT.jl [plotting documentation](https://bat.github.io/BAT.jl/dev/plotting/) and [examples](https://github.com/bat/BAT.jl/blob/master/examples/dev-internal/plotting_examples.jl). -```julia +````julia p = plot(samples, 0.9) savefig(p, "plot_1d.pdf") -``` +```` ![example plot](plots/interval_plot_1.png) diff --git a/examples/tutorial/runTutorial.jl b/examples/tutorial/runTutorial.jl index d8e8db5..1b20644 100644 --- a/examples/tutorial/runTutorial.jl +++ b/examples/tutorial/runTutorial.jl @@ -1,4 +1,5 @@ # EFTfitter.jl - Tutorial + # This tutorial introduces the basic functionalities of EFTfitter.jl using a generic example. # More functionalities of EFTfitter.jl, like handling nuisance correlations # or ranking measurements and uncertainties, are shown in the @@ -19,146 +20,14 @@ include("tutorial_inputs.jl") # We can then build the `EFTfitterModel` which combines all our inputs into # one object that is then used to perform the analysis on. - -using SparseArrays -using LinearAlgebra -f(x) = Symmetric(sparse(x)) - -model = EFTfitterModel(parameters, measurements, correlations, CovarianceType=f) -posterior = PosteriorMeasure(model) -#run_speed_test(model) - -v = rand(parameters) -v = (C1 = 1.3646163105428428, C2 = 0.0669263861339656) - -#@code_warntype EFTfitter.evaluate_funcs!(m.mus, m.observable_functions, v, m) - -using BenchmarkTools -using DensityInterface -# logdensityof(posterior)(v) -@btime logdensityof(posterior)(v) # -71.62957930828858 -# 350.000 ns (18 allocations: 1.19 KiB) - - +model = EFTfitterModel(parameters, measurements, correlations) # To sample the posterior distribution, we specify that our `EFTfitterModel` # should be used and then setup BAT.jl to sample the EFTfitter likelihood. +posterior = PosteriorMeasure(model) -parameters1 = BAT.NamedTupleDist( - p1 = -20..20, - p2 = -10..10, -) - -function testfunc1(params) - c = [20.12, 5.56, 325.556] - return c[1] * params.p1^2 + c[2] * params.p1 * params.p2 + c[3] * params.p2^2 -end - -measurements1 = ( - meas1 = Measurement(testfunc1, 111.1, - uncertainties = (unc1=10.1, unc2=12.2, unc3=13.3), active=true), - - meas2 = Measurement(Observable(testfunc1, min=0, max=1000), 222.2, - uncertainties = (unc1=20.1, unc2=20.2, unc3=23.3), active=false), - - meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 333.3, - uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), - - meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], - [10, 20, 30], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), - active = [true, false, true], bin_names=[Symbol("0_5"), Symbol("5_10"), Symbol("10_20")]) -) - -corr_matrix = to_correlation_matrix(measurements1, - (:meas1, :meas2, 0.12), # will be ignored later in EFTfitterModel - (:meas1, :meas3, 0.13), - (:meas1, :meas4_0_5, 0.141), - (:meas1, :meas4_5_10, 0.142), # will be ignored later in EFTfitterModel - (:meas1, :meas4_10_20, 0.143), # will be ignored later in EFTfitterModel - (:meas4_0_5, :meas4_5_10, 0.412), # will be ignored later in EFTfitterModel - (:meas4_0_5, :meas4_5_10, 0.413), - (:meas4_0_5, :meas4_0_5, 0.9) # will be ignored later in EFTfitterModel -) - -correlations1 = ( - unc1 = NoCorrelation(active=true), - - # wrong matrix size for number of measurements, will be ignored if active=false: - unc2 = Correlation([1.0 0.5 0.7; - 0.5 1.0 0.6; - 0.7 0.6 1.0], active=false), - - unc3 = Correlation(corr_matrix) -) - -nuisance_correlations = ( - ρ1 = NuisanceCorrelation(:unc1, :meas1, :meas3, 0..0.5), - ρ2 = NuisanceCorrelation(:unc1, :meas1, :meas2, truncated(Normal(0, 1), 0, 0.9)), -) - -model1 = EFTfitterModel(parameters1, measurements1, correlations1, limits=nothing, nuisances=nuisance_correlations, CovarianceType=Matrix) - - - - - -posterior = PosteriorMeasure(model1) -m = posterior.likelihood.density._d - -v2 = (p1 = 1.3646163105428428, p2 = 0.0669263861339656, ρ1=0.2, ρ2=0.3 ) - -EFTfitter.get_current_invcov(m, v2) - - -#@btime EFTfitter.evaluate_funcs!(m.mus, m.observable_functions, v, m) -#187.771 ns (14 allocations: 800 bytes) - - - - -using DensityInterface -using BenchmarkTools -v = rand(parameters) - -v = (C1 = 1.3646163105428428, C2 = 0.0669263861339656) - -#@code_warntype EFTfitter.evaluate_funcs!(m.mus, m.observable_functions, v, m) - -# logdensityof(posterior)(v) -@btime logdensityof(posterior)(v) # -71.62957930828858 -# 350.000 ns (18 allocations: 1.19 KiB) -# 633.523 ns (18 allocations: 1.19 KiB) -# 983.333 ns (18 allocations: 1.19 KiB) - -@btime [m.observable_functions[i](v) for i in eachindex(m.observable_functions)] - -@code_warntype logdensityof(posterior)(v) -@code_llvm logdensityof(posterior)(v) - -v = (C1 = 1.3777803296719995, C2 = -0.13471933089976204) -logdensityof(posterior)(v) # -139.56233066526895 - -v = (C1 = 0.4310417711590908, C2 = 0.5097850986277717) -logdensityof(posterior)(v) # -2162.171314291685 - - -import Random -Random.seed!(1234) -for v in [rand(parameters) for i in 1:10000] - println(logdensityof(posterior)(v)) -end - - - -@btime logdensityof(posterior)(v) #btime: 593.220 ns (26 allocations: 1.34 KiB) - -algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4, strict=false) -include("ram_sampler.jl") -algorithm = RAMSampler(nchains=1, nsteps=6*10^5, nburnin=4*10^5) - -@time samples = bat_sample(posterior, algorithm).result; - - +algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) +samples = bat_sample(posterior, algorithm).result; # For further information on settings & algorithms when sampling with BAT.jl # see the BAT.jl [tutorial](https://bat.github.io/BAT.jl/dev/tutorial/#Parameter-Space-Exploration-via-MCMC) # and [documentation](https://bat.github.io/BAT.jl/dev/stable_api/#BAT.bat_sample). @@ -195,74 +64,3 @@ savefig(p, "plot_1d.pdf") # and [tutorial](https://github.com/tudo-physik-e4/EFTfitter.jl/blob/main/examples/tutorial/plotting.jl). # This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - -r = rand(500) -using LinearAlgebra -using BenchmarkTools -@btime Diagonal(r.^2) - -N = 50 -r = rand(N)*10 -M = rand(N, N) - -function addunc!(M, r) - for i in 1:size(M)[1] - M[i, i] += r[i]^2 - end -end - -function addunc2(M, r) - return M+Diagonal(r.^2) -end - -@btime addunc!(M, r) - -@btime addunc2(M, r) - - -M = [1 2; 3 4] -M2 = [1.5 2; 3 5] - -invM = inv(M) -invM2 = inv(M2) - -#------ Dispatch on Val ----------------------- -f(a::Val{false}) = println("f=False") -f(a::Val{true}) = println("f=True") -f(a) = println("??") - -@btime f(Val(false)) -@btime f(3) - - - -#---------------------------------------------- -#- Testing Dispatch on Type of Field in struct - -struct MyStruct{AT, BT} - A::AT - B::BT - C::Float64 -end - -f(ms::MyStruct) = 1 - -f(ms::MyStruct{String, Float64}) = "Hi" - -f(ms::MyStruct{Float64, String}) = "Ho" - - -m = MyStruct(1., 2., 3.) -m = MyStruct("H", 2., 3.) -m = MyStruct(3, "H0", 3.) - -f(m) -#--------------------------------s-------------- - - - -M = rand(4, 100) - -m = view(M, 1, :) -x = rand(100) -r = m - x \ No newline at end of file diff --git a/examples/tutorial/tutorial_inputs.jl b/examples/tutorial/tutorial_inputs.jl index 706bc05..2d39f6f 100644 --- a/examples/tutorial/tutorial_inputs.jl +++ b/examples/tutorial/tutorial_inputs.jl @@ -1,4 +1,5 @@ # EFTfitter.jl - Tutorial + # This tutorial introduces the basic functionalities of EFTfitter.jl using a generic example. # More functionalities of EFTfitter.jl, like handling nuisance correlations # or ranking measurements and uncertainties, are shown in the @@ -42,12 +43,6 @@ function xsec1(params) c = [20.12, 5.56, 325.556] return c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 end -# -# function xsec1(params) -# c = [20.12, 5.56, 325.556] -# result = c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 -# return (result, 0.1 * params.C1 * result) -# end function xsec2(params) coeffs = [2.12, 4.3, 12.6] @@ -122,6 +117,7 @@ measurements = ( # and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution). # Note: When using only one measurement or only one type of uncertainties, + # make sure to insert a comma, like: `uncertainties = (stat = 0.5,)` so that # Julia can parse the [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) correctly! @@ -175,4 +171,3 @@ correlations = ( ) # This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - From 19045c30e93fc3a1db51d5d08939eedc28455726 Mon Sep 17 00:00:00 2001 From: Cornelius-G Date: Fri, 3 Nov 2023 11:23:55 +0100 Subject: [PATCH 9/9] rename MeasurementDistribution to BinnedMeasurement --- README.md | 13 +- docs/src/BLUE.md | 40 +- docs/src/advanced_tutorial.md | 66 +- .../lit_advanced_tutorial_inputs.jl | 30 +- .../lit_runAdvancedTutorial.jl | 2 +- .../literate/empty_template_lit/lit_inputs.jl | 4 +- .../empty_template_lit/lit_runTemplate.jl | 5 +- .../src/literate/tutorial_lit/lit_plotting.jl | 8 +- .../literate/tutorial_lit/lit_runTutorial.jl | 5 +- .../tutorial_lit/lit_tutorial_inputs.jl | 18 +- docs/src/plotting.md | 74 +- docs/src/tutorial.md | 23 +- examples/BLUE/runBLUE.jl | 3 +- examples/advanced_tutorial/advanced_inputs.jl | 31 +- .../advanced_tutorial/runAdvancedTutorial.jl | 4 +- examples/empty_template/inputs.jl | 6 +- examples/empty_template/runEFTfitter.jl | 7 +- examples/notebooks/AdvancedTutorial.ipynb | 41078 ++++++++-------- examples/notebooks/BLUE.ipynb | 916 +- examples/notebooks/EmptyTemplate.ipynb | 847 +- examples/notebooks/Tutorial.ipynb | 6074 +-- examples/tutorial/plotting.jl | 13 +- examples/tutorial/runTutorial.jl | 5 +- examples/tutorial/tutorial_inputs.jl | 18 +- src/EFTfitterLikelihood.jl | 3 +- src/EFTfitterModel.jl | 20 +- src/datatypes.jl | 18 +- src/plotting/plot_measurements.jl | 10 +- src/utils.jl | 2 +- test/test_datatypes.jl | 6 +- test/test_inputs/test_likelihood.jl | 2 +- test/test_inputs/test_nuisance_inputs.jl | 2 +- test/test_modelunc.jl | 2 +- test/test_nuisance.jl | 2 +- test/test_plain.jl | 2 +- test/test_ranking.jl | 2 +- 36 files changed, 21991 insertions(+), 27370 deletions(-) diff --git a/README.md b/README.md index 09d437a..f54d5ee 100644 --- a/README.md +++ b/README.md @@ -10,11 +10,18 @@ New implementation of the [EFTfitter](https://github.com/tudo-physik-e4/EFTfitterRelease) in the [Julia languange](https://julialang.org/). -Tool for constraining the parameters of physics models using Bayesian inference by combining measurements of (different) observables. -Particularly suited for EFT (effective field theory) interpretations. +EFTfitter is a tool for constraining the parameters of physics models using Bayesian inference by combining measurements of (different) observables. +It is particularly suited for EFT (effective field theory) interpretations, but is not limited to these use cases. Work-in-progress, interfaces and functionalities might be subject to changes. +## News +Since version 0.2 of the package, the following new features are available: +- Model uncertainties: The functions giving the predictions for the observable values can now also return a parameter-dependent value quantifying the uncertainty on the prediction. These uncertainties are currently treated as uncorrelated and are added to the total covariance matrix. +- The data type of the (inverse) covariance matrix can now be set by the user. This can allow to increase the performance by speeding up the vector-matrix multiplication, e.g. in the case of sparse covariance matrices. +- `MeasurementDistribution` is now called `BinnedMeasurement` + + ## Installation The EFTfitter.jl package can be installed using: ```julia @@ -27,7 +34,7 @@ Please see the [installation guide](https://tudo-physik-e4.github.io/EFTfitter.j ## Documentation & Tutorials Please see the [documentation](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/) for tutorials and information on how to use EFTfitter.jl. -Executable versions of the tutorials and examples can also be found [here](https://github.com/tudo-physik-e4/EFTfitter.jl/tree/main/examples/tutorials). +Executable versions of the tutorials and examples can also be found [here](https://github.com/tudo-physik-e4/EFTfitter.jl/tree/main/examples). You can also try running the tutorials right now: [![badge](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/tudo-physik-e4/EFTfitter.jl/binder?urlpath=git-pull%3Frepo%3Dhttps%253A%252F%252Fgithub.com%252Ftudo-physik-e4%252FEFTfitter.jl%26urlpath%3Dtree%252FEFTfitter.jl%252Fexamples%252Fnotebooks%252F%26branch%3Dmain) diff --git a/docs/src/BLUE.md b/docs/src/BLUE.md index 6f9c886..cb4204a 100644 --- a/docs/src/BLUE.md +++ b/docs/src/BLUE.md @@ -10,7 +10,7 @@ by L. Lyons, D. Gibaut and P. Clifford (https://www.sciencedirect.com/science/ar All numbers are taken from the example on charm particle lifetime experiments in section 5. A factor of 10^13 is applied for convenience. -```julia +````julia using EFTfitter using BAT using IntervalSets @@ -18,37 +18,37 @@ using Statistics using StatsBase using LinearAlgebra using Plots -``` +```` We need one parameter for the best estimator and choose a uniform distribution in the range 8 to 14 as prior: -```julia +````julia parameters = BAT.NamedTupleDist( τ = 8..14, ) -``` +```` When combining multiple measurements of the same observable, only a function returning the combination parameter is needed: -```julia +````julia estimator(params) = params.τ -``` +```` In Eq. (17') of the reference paper the following covariance matrix is given: -```julia +````julia covariance = [2.74 1.15 0.86 1.31; 1.15 1.67 0.82 1.32; 0.86 0.82 2.12 1.05; 1.31 1.32 1.05 2.93] -``` +```` For using this in EFTfitter.jl, we first need to convert the covariance matrix into a correlation matrix and the corresponding uncertainty values: -```julia +````julia corr, unc = EFTfitter.cov_to_cor(covariance) measurements = ( @@ -61,44 +61,44 @@ measurements = ( correlations = ( stat = Correlation(corr), ) -``` +```` construct an `EFTfitterModel`: -```julia +````julia model = EFTfitterModel(parameters, measurements, correlations) posterior = PosteriorMeasure(model); -``` +```` sample the posterior with BAT.jl: -```julia +````julia algorithm = MCMCSampling(mcalg =MetropolisHastings(), nsteps = 10^6, nchains = 4) samples = bat_sample(posterior, algorithm).result -``` +```` plot the posterior distribution for the combination parameter τ: -```julia +````julia plot(samples, :τ, mean=true) -``` +```` ![blue plots](plots/plot_blue.png) print numerical results of combination: -```julia +````julia println("Mode: $(mode(samples).τ)") println("Mean: $(mean(samples).τ) ± $(std(samples).τ)") ``` Mode: 11.15985 Mean: 11.15471 ± 0.80180 ``` -``` +```` ### Comparison with BLUE method -```julia +````julia blue = BLUE(model) println("BLUE: $(blue.value) ± $(blue.unc)") println("BLUE weights: $(blue.weights)") @@ -106,7 +106,7 @@ println("BLUE weights: $(blue.weights)") BLUE: 11.15983 ± 1.28604 BLUE weights: [0.145, 0.470, 0.347, 0.038] ``` -``` +```` --- diff --git a/docs/src/advanced_tutorial.md b/docs/src/advanced_tutorial.md index ea51f62..354eabb 100644 --- a/docs/src/advanced_tutorial.md +++ b/docs/src/advanced_tutorial.md @@ -6,20 +6,20 @@ Pages = ["advanced_tutorial.md"] Depth = 3 ``` -## Vector of functions for a MeasurementDistribution -When using distributions of measurements, a vector of functions with the predictions -for the observable needs to be passed containing a function for each of the bins which -have only the model parameters as their argument. Defining a separate function for each +## Vector of functions for a BinnedMeasurement +When using binned measurements, a vector of functions giving the predictions +for the observable needs to be passed. It contains a function for each of bin and +has only the model parameters as its argument. Defining a separate function for each bin can, however, become tedious for a large number of bins, especially since typically the bins of a distribution have a similar functional dependence on the model parameters and only differ in some coefficients. In such cases, it is possible to use Julia's -[metaprogramming](https://docs.julialang.org/en/v1/manual/metaprogramming/) features to -create the vector of functions. The distribution in our [basic tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/tutorial/) +anonymous functions to quickly create the vector of functions. +The distribution in our [basic tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/tutorial/) has been defined by implementing three functions that all call the same function `myfunc` but with different values for the coefficients The same result can also be achieved like this: -```julia +````julia function get_coeffs(i) # return the coefficients for bin i coeffs = [[2.2, 5.5, 6.6], [2.2, 5.5, 6.6], [2.2, 5.5, 6.6]] return coeffs[i] @@ -29,21 +29,13 @@ function my_dist_func(params, i) coeffs = get_coeffs(i) return coeffs[1] * params.C1 + coeffs[2] * params.C1 * params.C2+ coeffs[3] * params.C2 end -``` +```` -create an array of Functions with names `diff_xsec_binX`: - -```julia -diff_xsec=Function[] -for i in 1:3 - @eval begin - function $(Symbol("diff_xsec_bin$i"))(params) - return my_dist_func(params, $i) - end - push!(diff_xsec, $(Symbol("diff_xsec_bin$i"))) - end -end -``` +create an array of anonymous functions + +````julia +diff_xsec = Function[x -> my_dist_func(x, i) for i in 1:3] +```` ## Using covariance matrices Information about the uncertainties of measurements need to be provided to EFTfitter.jl @@ -53,7 +45,7 @@ to correlation matrices and uncertainty values before. The function [`cov_to_cor`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.cov_to_cor-Tuple{Array{var%22#s58%22,2}%20where%20var%22#s58%22%3C:Real}) can be used for this: -```julia +````julia cov_syst = [3.24 0.81 0.378 0.324 0.468; 0.81 0.81 0.126 0.162 0.234; 0.378 0.126 0.49 0.126 0.182; @@ -61,9 +53,9 @@ cov_syst = [3.24 0.81 0.378 0.324 0.468; 0.468 0.234 0.182 0.234 1.69] cor_syst, unc_syst = cov_to_cor(cov_syst) -``` +```` -```julia +````julia measurements = ( Meas1 = Measurement(xsec1, 21.6, @@ -73,23 +65,23 @@ measurements = ( uncertainties = (stat=0.6, syst=unc_syst[2], another_unc=1.1), active=true), - MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4], + MeasDist = BinnedMeasurement(diff_xsec, [1.9, 2.93, 4.4], uncertainties = (stat = [0.7, 1.1, 1.2], syst= unc_syst[3:5], another_unc = [1.0, 1.2, 1.9]), active=[true, false, true]), ) -``` +```` ## Nuisance Correlations When performing an analysis with unknown correlation coefficients, it is possible to treat them as nuisance parameters in the fit. For this, we define a further `NamedTuple` consisting of `NuisanceCorrelation` objects: -```julia +````julia nuisance_correlations = ( ρ1 = NuisanceCorrelation(:syst, :Meas1, :Meas2, -1..1), ρ2 = NuisanceCorrelation(:syst, :MeasDist_bin1, :MeasDist_bin3, truncated(Normal(0.5, 0.1), -1, 1)), ) -``` +```` In the `NuisanceCorrelation` object we specify the name of the uncertainty type, the names of the two measurements we want to correlate using the nuisance correlations and @@ -102,12 +94,12 @@ the normal distribution accordingly. We need to modify the definition of the `EFTfitterModel` by also passing the `nuisance_correlations`: -```julia -model = EFTfitterModel(parameters, measurements, correlations, nuisance_correlations) +````julia +model = EFTfitterModel(parameters, measurements, correlations, nuisances = nuisance_correlations) savefig(p, "plot.pdf") -``` +```` ![plot with nuisances](plots/plot_nuisance.png) !!! warning @@ -129,28 +121,28 @@ smallest interval containing 90% of the posterior probability when deactivating For models with more than one parameter, the sum of the relative increases of all one-dimensional smallest intervals is used, i.e. `SumOfSmallestIntervals(p=0.9, bins=200)`. -```julia +````julia measurement_ranking = EFTfitter.rank_measurements(model) -``` +```` The sampling algorithm to be used can be passed with the keyword `sampling_algorithm`. By default, `BAT.MCMCSampling()` is used, i.e. Metropolis-Hastings with 4 chains and 100000 steps. -```julia +````julia plot(measurement_ranking, title = "Ranking of measurements") -``` +```` ![measurement ranking](plots/meas_ranks.png) For ranking the uncertainty types, the relative decrease is used. -```julia +````julia uncertainty_ranking = EFTfitter.rank_uncertainties(model, criterion = SumOfSmallestIntervals(p=0.9, bins=200), sampling_algorithm = SobolSampler(nsamples = 10^5), order = :values) plot(uncertainty_ranking, title = "Ranking of uncertainty types") -``` +```` ![measurement ranking](plots/unc_ranks.png) Please see the [ranking documentation](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.rank_measurements) for further ranking criteria and keyword arguments. diff --git a/docs/src/literate/advanced_tutorial_lit/lit_advanced_tutorial_inputs.jl b/docs/src/literate/advanced_tutorial_lit/lit_advanced_tutorial_inputs.jl index eafff85..88b1b46 100644 --- a/docs/src/literate/advanced_tutorial_lit/lit_advanced_tutorial_inputs.jl +++ b/docs/src/literate/advanced_tutorial_lit/lit_advanced_tutorial_inputs.jl @@ -12,7 +12,7 @@ #nb # ### Parameters #jl #~============= Parameters =============================================# #!md #~We use the same parameters & priors as in the basic tutorial: -#!md parameters = BAT.NamedTupleDist( +#!md parameters = BAT.distprod( #!md C1 = -3..3, # short for: Uniform(-3, 3) #!md C2 = Normal(0, 0.5) # Normal distribution #!md ) @@ -21,7 +21,7 @@ #nb # ### Observables #jl #~============= Observables =============================================# #!md #~We use the same observables as in the basic tutorial. However, we use a different -#!md #~way for creating the vector of functions for the MeasurementDistribution. +#!md #~way for creating the vector of functions for the BinnedMeasurement. #!md function xsec1(params) #!md coeffs = [20.12, 5.56, 325.556] @@ -38,15 +38,15 @@ #!md end #- -#md # ## Vector of functions for a MeasurementDistribution -#~When using distributions of measurements, a vector of functions with the predictions -#~for the observable needs to be passed containing a function for each of the bins which -#~have only the model parameters as their argument. Defining a separate function for each +#md # ## Vector of functions for a BinnedMeasurement +#~When using binned measurements, a vector of functions giving the predictions +#~for the observable needs to be passed. It contains a function for each of bin and +#~has only the model parameters as its argument. Defining a separate function for each #~bin can, however, become tedious for a large number of bins, especially since typically #~the bins of a distribution have a similar functional dependence on the model parameters #~and only differ in some coefficients. In such cases, it is possible to use Julia's -#~[metaprogramming](https://docs.julialang.org/en/v1/manual/metaprogramming/) features to -#~create the vector of functions. The distribution in our [basic tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/tutorial/) +#~anonymous functions to quickly create the vector of functions. +#~The distribution in our [basic tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/tutorial/) #~has been defined by implementing three functions that all call the same function `myfunc` #~but with different values for the coefficients #~The same result can also be achieved like this: @@ -62,16 +62,8 @@ function my_dist_func(params, i) end -# create an array of Functions with names `diff_xsec_binX`: -diff_xsec=Function[] -for i in 1:3 - @eval begin - function $(Symbol("diff_xsec_bin$i"))(params) - return my_dist_func(params, $i) - end - push!(diff_xsec, $(Symbol("diff_xsec_bin$i"))) - end -end +# create an array of anonymous functions +diff_xsec = Function[x -> my_dist_func(x, i) for i in 1:3] #nb # ### Measurements #jl #~============= Measurements =============================================# @@ -102,7 +94,7 @@ measurements = ( uncertainties = (stat=0.6, syst=unc_syst[2], another_unc=1.1), active=true), - MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4], + MeasDist = BinnedMeasurement(diff_xsec, [1.9, 2.93, 4.4], uncertainties = (stat = [0.7, 1.1, 1.2], syst= unc_syst[3:5], another_unc = [1.0, 1.2, 1.9]), active=[true, false, true]), ) diff --git a/docs/src/literate/advanced_tutorial_lit/lit_runAdvancedTutorial.jl b/docs/src/literate/advanced_tutorial_lit/lit_runAdvancedTutorial.jl index 3ea7509..31926a5 100644 --- a/docs/src/literate/advanced_tutorial_lit/lit_runAdvancedTutorial.jl +++ b/docs/src/literate/advanced_tutorial_lit/lit_runAdvancedTutorial.jl @@ -27,7 +27,7 @@ #jl include("advanced_inputs.jl") #~We need to modify the definition of the `EFTfitterModel` by also passing the `nuisance_correlations`: -model = EFTfitterModel(parameters, measurements, correlations, nuisance_correlations) +model = EFTfitterModel(parameters, measurements, correlations, nuisances = nuisance_correlations) #!md posterior = PosteriorMeasure(model) #!md diff --git a/docs/src/literate/empty_template_lit/lit_inputs.jl b/docs/src/literate/empty_template_lit/lit_inputs.jl index 1ba2881..d84f740 100644 --- a/docs/src/literate/empty_template_lit/lit_inputs.jl +++ b/docs/src/literate/empty_template_lit/lit_inputs.jl @@ -2,7 +2,7 @@ #!jl # ### Parameters #jl #~============= Parameters =============================================# -parameters = BAT.NamedTupleDist( +parameters = BAT.distprod( p1 = -2..2, ) @@ -19,7 +19,7 @@ end measurements = ( Meas1 = Measurement(observable1, 0.0, uncertainties = (unc1 = 0.1,), active=true), - #MeasDist = MeasurementDistribution(obs_array, values_array, uncertainties = (unc1 = unc1_array,), active=false), + #MeasDist = BinnedMeasurement(obs_array, values_array, uncertainties = (unc1 = unc1_array,), active=false), ) diff --git a/docs/src/literate/empty_template_lit/lit_runTemplate.jl b/docs/src/literate/empty_template_lit/lit_runTemplate.jl index d3cbcd6..cdedb2f 100644 --- a/docs/src/literate/empty_template_lit/lit_runTemplate.jl +++ b/docs/src/literate/empty_template_lit/lit_runTemplate.jl @@ -28,9 +28,8 @@ posterior = PosteriorMeasure(model); algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) samples = bat_sample(posterior, algorithm).result; -#~create and display a `SampledDensity` object for a quick overview of results: -sd = SampledDensity(posterior, samples) -display(sd) +#~let's get a quick overview of results: +bat_report(samples) #~ plot the posterior distribution: p = plot(samples) diff --git a/docs/src/literate/tutorial_lit/lit_plotting.jl b/docs/src/literate/tutorial_lit/lit_plotting.jl index 7ebb4eb..7a53ccc 100755 --- a/docs/src/literate/tutorial_lit/lit_plotting.jl +++ b/docs/src/literate/tutorial_lit/lit_plotting.jl @@ -99,9 +99,9 @@ plot!(get_measurements(model), :Meas1, uncertainties=(:stat, :another_unc)) #~When mutliple types of uncertainties are given, the sum of the squares is used as the total uncertainty. #~By default, all uncertainties included in the `EFTfitterModel` are used. -#!jl # ## Plotting MeasurementDistributions -#jl #~---------- Plotting MeasurementDistributions ------------------------- -#~`MeasurementDistribution`s can be plotted for fixed parameters: +#!jl # ## Plotting BinnedMeasurements +#jl #~---------- Plotting BinnedMeasurements ------------------------- +#~`BinnedMeasurement`s can be plotted for fixed parameters: plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) plot!(get_measurement_distributions(model), :MeasDist) #src p = plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) @@ -117,7 +117,7 @@ plot!(get_measurement_distributions(model), :MeasDist, st=:scatter) #src savefig(p, "measdist_plot_2.png") #md # ![example plot](plots/measdist_plot_2.png) -#~Also for `MeasurementDistribution`s the uncertainty types to be plotted can be specified. +#~Also for `BinnedMeasurement`s the uncertainty types to be plotted can be specified. #~The names of the bins can be customized using the `bin_names` keyword. plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) plot!(get_measurement_distributions(model), :MeasDist, st=:scatter, uncertainties=(:stat,), bin_names=("First bin", "Second bin")) diff --git a/docs/src/literate/tutorial_lit/lit_runTutorial.jl b/docs/src/literate/tutorial_lit/lit_runTutorial.jl index e48db50..628eedf 100644 --- a/docs/src/literate/tutorial_lit/lit_runTutorial.jl +++ b/docs/src/literate/tutorial_lit/lit_runTutorial.jl @@ -46,10 +46,9 @@ samples = bat_sample(posterior, algorithm).result; #~see the BAT.jl [tutorial](https://bat.github.io/BAT.jl/dev/tutorial/#Parameter-Space-Exploration-via-MCMC) #~and [documentation](https://bat.github.io/BAT.jl/dev/stable_api/#BAT.bat_sample). -#~We can then inspect the results of the sampling using BAT.jl's `SampledDensity`, +#~We can then inspect the results of the sampling using BAT.jl's `bat_report`, #~giving a summary of the sampling and the results of the model parameters. -sd = SampledDensity(posterior, samples) -display(sd) +bat_report(samples) #md ``` #md ``` #md BAT.jl - SampledDensity diff --git a/docs/src/literate/tutorial_lit/lit_tutorial_inputs.jl b/docs/src/literate/tutorial_lit/lit_tutorial_inputs.jl index b23ab0e..46b5f1f 100644 --- a/docs/src/literate/tutorial_lit/lit_tutorial_inputs.jl +++ b/docs/src/literate/tutorial_lit/lit_tutorial_inputs.jl @@ -25,7 +25,7 @@ #~For our example, we consider two parameters with the names `C1` and `C2`. #~For `C1` we choose a uniform (flat) prior in the range (-3, 3). #~For `C2` we choose a gaussian prior with μ=0 and σ=0.5. -parameters = BAT.NamedTupleDist( +parameters = BAT.distprod( C1 = -3..3, # short for: Uniform(-3, 3) C2 = Normal(0, 0.5) # Normal distribution ) @@ -96,7 +96,7 @@ diff_xsec = [diff_xsec_bin1, diff_xsec_bin2, diff_xsec_bin3] #~We can now enter measurements of the observables. #~This is done by defining a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) #~consisting of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) -#~and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution) objects. +#~and [`BinnedMeasurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.BinnedMeasurement) objects. #~A `Measurement` consists of the observable, the measured numerical value and #~numerical values for the (multiple types of) uncertainties. @@ -104,12 +104,12 @@ diff_xsec = [diff_xsec_bin1, diff_xsec_bin2, diff_xsec_bin3] #~object or as a `Function`. When using the latter, the observable is assumed to be unconstrained. #~The uncertainties are passed as a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types). #~Each measurement has to provide uncertainty values for all of the (active) uncertainty -#~types (see next section on `Correlations`). For a `MeasurementDistribution`, +#~types (see next section on `Correlations`). For a `BinnedMeasurement`, #~the corresponding inputs have to be passed as `Vectors`, where each element #~represents one bin of the distribution. #~A `Measurement` can be excluded from the model by setting the switch `active=false`. -#~For a `MeasurementDistribution`, the keyword `active` accepts `true` or `false` +#~For a `BinnedMeasurement`, the keyword `active` accepts `true` or `false` #~to (de)activate the whole distribution or a vector of booleans for (de)activating only certain bins. measurements = ( @@ -119,13 +119,13 @@ measurements = ( Meas2 = Measurement(Observable(xsec2, min=0), 1.9, uncertainties = (stat=0.6, syst=0.9, another_unc=1.1), active=true), - MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4], + MeasDist = BinnedMeasurement(diff_xsec, [1.9, 2.93, 4.4], uncertainties = (stat = [0.7, 1.1, 1.2], syst= [0.7, 0.8, 1.3], another_unc = [1.0, 1.2, 1.9]), active=[true, false, true]), # `active = false`: exclude all bins from fit, `active = [true, true, false]`: exclude only third bin from fit ) #~Further information on the constructors see the API documentation of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) -#~and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution). +#~and [`BinnedMeasurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.BinnedMeasurement). #md # !!! note #md # When using only one measurement or only one type of uncertainties, make sure to insert a comma, like: `uncertainties = (stat = 0.5,)` so that Julia can parse the [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) correctly! @@ -144,7 +144,7 @@ measurements = ( #~of ``N \times N``, where ``N`` is the number of measurements, counting each bin of a distribution. #~When a certain type of uncertainty should not be considered, it can be deactivated #~by setting `active = false`. This means that the uncertainty values given in the -#~corresponding `Measurement` and `MeasurementDistribution` objects will not be used. +#~corresponding `Measurement` and `BinnedMeasurement` objects will not be used. #~When assuming the uncertainties of all measurements are uncorrelated, you can #~use the `NoCorrelation` object for easily passing an identity matrix of the correct size. @@ -154,8 +154,8 @@ measurements = ( #~With the function `to_correlation_matrix`, it is possible to enter a correlation #~matrix by simply specifying the names of the measurements that should be correlated #~and the value of the corresponding correlation coefficient. -#~When using a `MeasurementDistribution`, the inter-bin correlations can also be -#~entered by passing a matrix. By appending `_binX` to the name of a `MeasurementDistribution`, +#~When using a `BinnedMeasurement`, the inter-bin correlations can also be +#~entered by passing a matrix. By appending `_binX` to the name of a `BinnedMeasurement`, #~the Xth bin of the distribution can be accessed. #~Note: This function is evaluated from top to bottom, so if you overwrite a #~specific correlation value, the last value entered will be used. diff --git a/docs/src/plotting.md b/docs/src/plotting.md index 05fa5cb..af808c2 100644 --- a/docs/src/plotting.md +++ b/docs/src/plotting.md @@ -3,24 +3,24 @@ EFTfitter includes several recipes for plotting its datatypes using [Plots.jl](http://docs.juliaplots.org/latest/) -```julia +````julia using EFTfitter using BAT using IntervalSets using Distributions using Plots -``` +```` we use the inputs from the basic tutorial: -```julia +````julia include("tutorial_inputs.jl") model = EFTfitterModel(parameters, measurements, correlations) posterior = PosteriorMeasure(model) algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) samples = bat_sample(posterior, algorithm).result; -``` +```` Note: All plots generated with the following plot recipes can be customized using the [series attributes](http://docs.juliaplots.org/latest/generated/attributes_series/), @@ -32,48 +32,48 @@ Note: All plots generated with the following plot recipes can be customized usin Plotting an `Observable` object: -```julia +````julia plot(Observable(xsec1), (C1=0, C2=-1:0.01:1)) -``` +```` When plotting an `Observable` from the `EFTfitterModel`, it can be accessed in different ways: -```julia +````julia plot(get_observables(model).xsec1, (C1=0, C2=-1:0.01:1)) plot(get_measurements(model).Meas1.observable, (C1=0, C2=-1:0.01:1)) -``` +```` ![example plot](plots/observable_plot.png) If the model has many parameters, it can be convenient to pass the paramter that should be plotted together with as a `NamedTuple` with default values for all parameters. -```julia +````julia default_parameters = (C1=1, C2=0) plot(get_observables(model).xsec1, (C2=-1:0.01:1,), default_parameters) -``` +```` ![example plot](plots/observable_plot_2.png) The second argument in this function overwrites the corresponding default parameters, so it is also possible to pass multiple parameters: -```julia +````julia plot(get_observables(model).xsec1, (C2=-1:0.01:1, C1=2.3), default_parameters) -``` +```` ![example plot](plots/observable_plot_3.png) All observables of a model can easily be plotted in one plot: -```julia +````julia p = plot() for meas in get_measurements(model) p=plot!(meas.observable, (C1=0, C2=-1:0.01:1), ylabel="prediction") end p -``` +```` ![example plot](plots/observable_plot_4.png) @@ -81,9 +81,9 @@ When plotting observables, the default title contains the values of the fixed parameters. In case the title is too long for one line, linebreaks can be inserted using the keyword `titlewidth`. e.g.: -```julia +````julia plot(get_observables(model).xsec1, (C1=-10:0.01:10, C2=0, C3=100, C4=200), titlewidth=13) -``` +```` ![example plot](plots/observable_plot_5.png) @@ -91,83 +91,83 @@ plot(get_observables(model).xsec1, (C1=-10:0.01:10, C2=0, C3=100, C4=200), title `Measurement` objects can be plotted on top of the observables as a horizontal line with an uncertainty band: -```julia +````julia plot(get_measurements(model).Meas1.observable, (C1=0, C2=-0.2:0.01:0.2)) plot!(measurements.Meas1) -``` +```` ![example plot](plots/measurement_plot_1.png) However, when plotting the measurements of the `EFTfitterModel`, the following syntax is preferred as it supports showing the names of the measurments in the legend: -```julia +````julia plot(get_measurements(model).Meas1.observable, (C1=0, C2=-0.2:0.01:0.2)) plot!(get_measurements(model), :Meas1) -``` +```` ![example plot](plots/measurement_plot_2.png) The uncertainty typed to be plotted can be specified: -```julia +````julia plot(get_measurements(model).Meas1.observable, (C1=0, C2=-0.2:0.01:0.2)) plot!(get_measurements(model), :Meas1, uncertainties=(:stat, :another_unc)) -``` +```` ![example plot](plots/measurement_plot_3.png) When mutliple types of uncertainties are given, the sum of the squares is used as the total uncertainty. By default, all uncertainties included in the `EFTfitterModel` are used. -## Plotting MeasurementDistributions -`MeasurementDistribution`s can be plotted for fixed parameters: +## Plotting BinnedMeasurements +`BinnedMeasurement`s can be plotted for fixed parameters: -```julia +````julia plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) plot!(get_measurement_distributions(model), :MeasDist) -``` +```` ![example plot](plots/measdist_plot_1.png) alternative plotting style for measurement distributions: -```julia +````julia plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) plot!(get_measurement_distributions(model), :MeasDist, st=:scatter) -``` +```` ![example plot](plots/measdist_plot_2.png) -Also for `MeasurementDistribution`s the uncertainty types to be plotted can be specified. +Also for `BinnedMeasurement`s the uncertainty types to be plotted can be specified. The names of the bins can be customized using the `bin_names` keyword. -```julia +````julia plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) plot!(get_measurement_distributions(model), :MeasDist, st=:scatter, uncertainties=(:stat,), bin_names=("First bin", "Second bin")) -``` +```` ![example plot](plots/measdist_plot_3.png) ## Plotting 1D Intervals Default plot of the smallest 1D intervals containing 90% posterior probability: -```julia +````julia plot(samples, 0.9) -``` +```` ![example plot](plots/interval_plot_1.png) Default settings for keywords: -```julia +````julia plot(samples, 0.9, parameter_names = get_parameter_names(maybe_shaped_samples), # Array of String with the names of the parameters y_positions = collect(1:length(parameter_names))*-1, # y-positions of the interval lines y_offset = 0, # offest on the y-axis, helpful when plotting multiple samples on top of each other bins = 200, # number of bins for calculating smallest intervals atol = 0,) # merge intervals that are seperated less then atol (especially helpful when using a high number of bins) -``` +```` helpful keyword arguments: msc = markerstrokecolor: color of the interval lines @@ -176,10 +176,10 @@ helpful keyword arguments: Customized 1D interval plot: -```julia +````julia p = plot(samples, 0.9, bins = 400, atol=0.01, y_offset=-0.1, label = "Samples A") p = plot!(samples, 0.9, bins = 100, atol=0.05, y_offset=0.1, msw = 5, ms=8, msc=:red, label = "Samples B") -``` +```` ![example plot](plots/interval_plot_2.png) diff --git a/docs/src/tutorial.md b/docs/src/tutorial.md index 8a4dc83..a4460f4 100644 --- a/docs/src/tutorial.md +++ b/docs/src/tutorial.md @@ -27,7 +27,7 @@ For `C1` we choose a uniform (flat) prior in the range (-3, 3). For `C2` we choose a gaussian prior with μ=0 and σ=0.5. ````julia -parameters = BAT.NamedTupleDist( +parameters = BAT.distprod( C1 = -3..3, # short for: Uniform(-3, 3) C2 = Normal(0, 0.5) # Normal distribution ) @@ -101,7 +101,7 @@ as it is the case here in this example. We can now enter measurements of the observables. This is done by defining a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) consisting of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) -and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution) objects. +and [`BinnedMeasurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.BinnedMeasurement) objects. A `Measurement` consists of the observable, the measured numerical value and numerical values for the (multiple types of) uncertainties. @@ -109,12 +109,12 @@ The observable can be passed to the `Measurement` either as an [`Observable`](ht object or as a `Function`. When using the latter, the observable is assumed to be unconstrained. The uncertainties are passed as a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types). Each measurement has to provide uncertainty values for all of the (active) uncertainty -types (see next section on `Correlations`). For a `MeasurementDistribution`, +types (see next section on `Correlations`). For a `BinnedMeasurement`, the corresponding inputs have to be passed as `Vectors`, where each element represents one bin of the distribution. A `Measurement` can be excluded from the model by setting the switch `active=false`. -For a `MeasurementDistribution`, the keyword `active` accepts `true` or `false` +For a `BinnedMeasurement`, the keyword `active` accepts `true` or `false` to (de)activate the whole distribution or a vector of booleans for (de)activating only certain bins. ````julia @@ -125,14 +125,14 @@ measurements = ( Meas2 = Measurement(Observable(xsec2, min=0), 1.9, uncertainties = (stat=0.6, syst=0.9, another_unc=1.1), active=true), - MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4], + MeasDist = BinnedMeasurement(diff_xsec, [1.9, 2.93, 4.4], uncertainties = (stat = [0.7, 1.1, 1.2], syst= [0.7, 0.8, 1.3], another_unc = [1.0, 1.2, 1.9]), active=[true, false, true]), # `active = false`: exclude all bins from fit, `active = [true, true, false]`: exclude only third bin from fit ) ```` Further information on the constructors see the API documentation of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) -and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution). +and [`BinnedMeasurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.BinnedMeasurement). !!! note When using only one measurement or only one type of uncertainties, make sure to insert a comma, like: `uncertainties = (stat = 0.5,)` so that Julia can parse the [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) correctly! @@ -146,7 +146,7 @@ The correlation matrix for each type of uncertainty needs to have a size of ``N \times N``, where ``N`` is the number of measurements, counting each bin of a distribution. When a certain type of uncertainty should not be considered, it can be deactivated by setting `active = false`. This means that the uncertainty values given in the -corresponding `Measurement` and `MeasurementDistribution` objects will not be used. +corresponding `Measurement` and `BinnedMeasurement` objects will not be used. When assuming the uncertainties of all measurements are uncorrelated, you can use the `NoCorrelation` object for easily passing an identity matrix of the correct size. @@ -156,8 +156,8 @@ quite impractical, especially if you want to add further measurements later. With the function `to_correlation_matrix`, it is possible to enter a correlation matrix by simply specifying the names of the measurements that should be correlated and the value of the corresponding correlation coefficient. -When using a `MeasurementDistribution`, the inter-bin correlations can also be -entered by passing a matrix. By appending `_binX` to the name of a `MeasurementDistribution`, +When using a `BinnedMeasurement`, the inter-bin correlations can also be +entered by passing a matrix. By appending `_binX` to the name of a `BinnedMeasurement`, the Xth bin of the distribution can be accessed. Note: This function is evaluated from top to bottom, so if you overwrite a specific correlation value, the last value entered will be used. @@ -223,12 +223,11 @@ For further information on settings & algorithms when sampling with BAT.jl see the BAT.jl [tutorial](https://bat.github.io/BAT.jl/dev/tutorial/#Parameter-Space-Exploration-via-MCMC) and [documentation](https://bat.github.io/BAT.jl/dev/stable_api/#BAT.bat_sample). -We can then inspect the results of the sampling using BAT.jl's `SampledDensity`, +We can then inspect the results of the sampling using BAT.jl's `bat_report`, giving a summary of the sampling and the results of the model parameters. ````julia -sd = SampledDensity(posterior, samples) -display(sd) +bat_report(samples) ``` ``` BAT.jl - SampledDensity diff --git a/examples/BLUE/runBLUE.jl b/examples/BLUE/runBLUE.jl index 9093ce3..2d6dec4 100644 --- a/examples/BLUE/runBLUE.jl +++ b/examples/BLUE/runBLUE.jl @@ -1,4 +1,5 @@ # EFTfitter.jl - BLUE Example + # When using multiple measurements of a single observable and a uniform prior for # the parameter representing the combined value, the combination of measurements performed with EFTfitter.jl # yields the same results as the Best Linear Unbiased Estimator (BLUE) method. @@ -64,9 +65,9 @@ println("Mode: $(mode(samples).τ)") println("Mean: $(mean(samples).τ) ± $(std(samples).τ)") # comparison with BLUE method: + blue = BLUE(model) println("BLUE: $(blue.value) ± $(blue.unc)") println("BLUE weights: $(blue.weights)") # This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - diff --git a/examples/advanced_tutorial/advanced_inputs.jl b/examples/advanced_tutorial/advanced_inputs.jl index fbc8fcb..c8713c6 100644 --- a/examples/advanced_tutorial/advanced_inputs.jl +++ b/examples/advanced_tutorial/advanced_inputs.jl @@ -1,11 +1,12 @@ # EFTfitter.jl - Advanced Tutorial + # This tutorial introduces some of the advanced functionalities of EFTfitter.jl # using a generic example. Please see the [tutorial] for basic usage of EFTfitter. # ============= Parameters =============================================# # We use the same parameters & priors as in the basic tutorial: -parameters = BAT.NamedTupleDist( +parameters = BAT.distprod( C1 = -3..3, # short for: Uniform(-3, 3) C2 = Normal(0, 0.5) # Normal distribution ) @@ -13,7 +14,7 @@ parameters = BAT.NamedTupleDist( # ============= Observables =============================================# # We use the same observables as in the basic tutorial. However, we use a different -# way for creating the vector of functions for the MeasurementDistribution. +# way for creating the vector of functions for the BinnedMeasurement. function xsec1(params) coeffs = [20.12, 5.56, 325.556] @@ -29,14 +30,14 @@ function myfunc(params, c) return c[1] * params.C1 + c[2] * params.C1 * params.C2+ c[3] * params.C2 end -# When using distributions of measurements, a vector of functions with the predictions -# for the observable needs to be passed containing a function for each of the bins which -# have only the model parameters as their argument. Defining a separate function for each +# When using binned measurements, a vector of functions giving the predictions +# for the observable needs to be passed. It contains a function for each of bin and +# has only the model parameters as its argument. Defining a separate function for each # bin can, however, become tedious for a large number of bins, especially since typically # the bins of a distribution have a similar functional dependence on the model parameters # and only differ in some coefficients. In such cases, it is possible to use Julia's -# [metaprogramming](https://docs.julialang.org/en/v1/manual/metaprogramming/) features to -# create the vector of functions. The distribution in our [basic tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/tutorial/) +# anonymous functions to quickly create the vector of functions. +# The distribution in our [basic tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/tutorial/) # has been defined by implementing three functions that all call the same function `myfunc` # but with different values for the coefficients # The same result can also be achieved like this: @@ -51,16 +52,9 @@ function my_dist_func(params, i) return coeffs[1] * params.C1 + coeffs[2] * params.C1 * params.C2+ coeffs[3] * params.C2 end -# create an array of Functions with names `diff_xsec_binX`: -diff_xsec=Function[] -for i in 1:3 - @eval begin - function $(Symbol("diff_xsec_bin$i"))(params) - return my_dist_func(params, $i) - end - push!(diff_xsec, $(Symbol("diff_xsec_bin$i"))) - end -end +# create an array of anonymous functions + +diff_xsec = Function[x -> my_dist_func(x, i) for i in 1:3] # ============= Measurements =============================================# # Information about the uncertainties of measurements need to be provided to EFTfitter.jl @@ -87,7 +81,7 @@ measurements = ( uncertainties = (stat=0.6, syst=unc_syst[2], another_unc=1.1), active=true), - MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4], + MeasDist = BinnedMeasurement(diff_xsec, [1.9, 2.93, 4.4], uncertainties = (stat = [0.7, 1.1, 1.2], syst= unc_syst[3:5], another_unc = [1.0, 1.2, 1.9]), active=[true, false, true]), ) @@ -138,4 +132,3 @@ nuisance_correlations = ( # the normal distribution accordingly. # This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - diff --git a/examples/advanced_tutorial/runAdvancedTutorial.jl b/examples/advanced_tutorial/runAdvancedTutorial.jl index 1a80ef0..733c26a 100644 --- a/examples/advanced_tutorial/runAdvancedTutorial.jl +++ b/examples/advanced_tutorial/runAdvancedTutorial.jl @@ -1,4 +1,5 @@ # EFTfitter.jl - Advanced Tutorial + # This tutorial introduces some of the advanced functionalities of EFTfitter.jl # using a generic example. Please see the [tutorial] for basic usage of EFTfitter. using EFTfitter @@ -10,7 +11,7 @@ using Plots # for plotting include("advanced_inputs.jl") # We need to modify the definition of the `EFTfitterModel` by also passing the `nuisance_correlations`: -model = EFTfitterModel(parameters, measurements, correlations, nuisance_correlations) +model = EFTfitterModel(parameters, measurements, correlations, nuisances = nuisance_correlations) posterior = PosteriorMeasure(model) @@ -54,4 +55,3 @@ plot(uncertainty_ranking, title = "Ranking of uncertainty types") # Please see the [ranking documentation](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.rank_measurements) for further ranking criteria and keyword arguments. # This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - diff --git a/examples/empty_template/inputs.jl b/examples/empty_template/inputs.jl index 5bbe0f7..d650b1f 100755 --- a/examples/empty_template/inputs.jl +++ b/examples/empty_template/inputs.jl @@ -1,6 +1,7 @@ # EFTfitter.jl - Empty Template + # ============= Parameters =============================================# -parameters = BAT.NamedTupleDist( +parameters = BAT.distprod( p1 = -2..2, ) @@ -15,7 +16,7 @@ end measurements = ( Meas1 = Measurement(observable1, 0.0, uncertainties = (unc1 = 0.1,), active=true), - #MeasDist = MeasurementDistribution(obs_array, values_array, uncertainties = (unc1 = unc1_array,), active=false), + #MeasDist = BinnedMeasurement(obs_array, values_array, uncertainties = (unc1 = unc1_array,), active=false), ) @@ -29,4 +30,3 @@ correlations = ( #) # This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - diff --git a/examples/empty_template/runEFTfitter.jl b/examples/empty_template/runEFTfitter.jl index 65d650d..da60d96 100644 --- a/examples/empty_template/runEFTfitter.jl +++ b/examples/empty_template/runEFTfitter.jl @@ -1,4 +1,5 @@ # EFTfitter.jl - Empty Template + using EFTfitter using BAT # for sampling using IntervalSets # for specifying the prior @@ -18,13 +19,11 @@ posterior = PosteriorMeasure(model); algorithm = MCMCSampling(mcalg = MetropolisHastings(), nsteps = 10^5, nchains = 4) samples = bat_sample(posterior, algorithm).result; -# create and display a `SampledDensity` object for a quick overview of results: -sd = SampledDensity(posterior, samples) -display(sd) +# let's get a quick overview of results: +bat_report(samples) # plot the posterior distribution: p = plot(samples) savefig(p, "plot.pdf") # This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - diff --git a/examples/notebooks/AdvancedTutorial.ipynb b/examples/notebooks/AdvancedTutorial.ipynb index 1658687..83c2ed7 100644 --- a/examples/notebooks/AdvancedTutorial.ipynb +++ b/examples/notebooks/AdvancedTutorial.ipynb @@ -50,7 +50,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "ValueShapes.NamedTupleDist{(:C1, :C2),Tuple{Distributions.Uniform{Float64},Distributions.Normal{Float64}},Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}},ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}(\n_internal_distributions: (C1 = Distributions.Uniform{Float64}(a=-3.0, b=3.0), C2 = Distributions.Normal{Float64}(μ=0.0, σ=0.5))\n_internal_shape: ValueShapes.NamedTupleShape{(:C1, :C2),Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}},ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}((C1 = ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}(ValueShapes.ScalarShape{Real}(), 0, 1), C2 = ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}(ValueShapes.ScalarShape{Real}(), 1, 1)), 2)\n)\n" + "text/plain": "NamedTupleDist((C1 = Uniform{Float64}(a=-3.0, b=3.0), C2 = Normal{Float64}(μ=0.0, σ=0.5)))" }, "metadata": {}, "execution_count": 2 @@ -58,7 +58,7 @@ ], "cell_type": "code", "source": [ - "parameters = BAT.NamedTupleDist(\n", + "parameters = BAT.distprod(\n", " C1 = -3..3, # short for: Uniform(-3, 3)\n", " C2 = Normal(0, 0.5) # Normal distribution\n", ")" @@ -71,7 +71,7 @@ "source": [ "### Observables\n", "We use the same observables as in the basic tutorial. However, we use a different\n", - "way for creating the vector of functions for the MeasurementDistribution." + "way for creating the vector of functions for the BinnedMeasurement." ], "metadata": {} }, @@ -108,14 +108,14 @@ { "cell_type": "markdown", "source": [ - "When using distributions of measurements, a vector of functions with the predictions\n", - "for the observable needs to be passed containing a function for each of the bins which\n", - "have only the model parameters as their argument. Defining a separate function for each\n", + "When using binned measurements, a vector of functions giving the predictions\n", + "for the observable needs to be passed. It contains a function for each of bin and\n", + "has only the model parameters as its argument. Defining a separate function for each\n", "bin can, however, become tedious for a large number of bins, especially since typically\n", "the bins of a distribution have a similar functional dependence on the model parameters\n", "and only differ in some coefficients. In such cases, it is possible to use Julia's\n", - "[metaprogramming](https://docs.julialang.org/en/v1/manual/metaprogramming/) features to\n", - "create the vector of functions. The distribution in our [basic tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/tutorial/)\n", + "anonymous functions to quickly create the vector of functions.\n", + "The distribution in our [basic tutorial](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/tutorial/)\n", "has been defined by implementing three functions that all call the same function `myfunc`\n", "but with different values for the coefficients\n", "The same result can also be achieved like this:" @@ -151,23 +151,24 @@ { "cell_type": "markdown", "source": [ - "create an array of Functions with names `diff_xsec_binX`:" + "create an array of anonymous functions" ], "metadata": {} }, { - "outputs": [], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "3-element Vector{Function}:\n #1 (generic function with 1 method)\n #1 (generic function with 1 method)\n #1 (generic function with 1 method)" + }, + "metadata": {}, + "execution_count": 5 + } + ], "cell_type": "code", "source": [ - "diff_xsec=Function[]\n", - "for i in 1:3\n", - " @eval begin\n", - " function $(Symbol(\"diff_xsec_bin$i\"))(params)\n", - " return my_dist_func(params, $i)\n", - " end\n", - " push!(diff_xsec, $(Symbol(\"diff_xsec_bin$i\")))\n", - " end\n", - "end" + "diff_xsec = Function[x -> my_dist_func(x, i) for i in 1:3]" ], "metadata": {}, "execution_count": 5 @@ -214,7 +215,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "(Meas1 = EFTfitter.Measurement(EFTfitter.Observable(Main.##410.xsec1, -Inf, Inf), 21.6, (stat = 0.8, syst = 1.8, another_unc = 2.3), true), Meas2 = EFTfitter.Measurement(EFTfitter.Observable(Main.##410.xsec2, 0.0, Inf), 1.9, (stat = 0.6, syst = 0.9, another_unc = 1.1), true), MeasDist = EFTfitter.MeasurementDistribution(EFTfitter.Observable[EFTfitter.Observable(Main.##410.diff_xsec_bin1, -Inf, Inf), EFTfitter.Observable(Main.##410.diff_xsec_bin2, -Inf, Inf), EFTfitter.Observable(Main.##410.diff_xsec_bin3, -Inf, Inf)], [1.9, 2.93, 4.4], (stat = [0.7, 1.1, 1.2], syst = [0.7, 0.9, 1.3], another_unc = [1.0, 1.2, 1.9]), Bool[1, 0, 1], [:bin1, :bin2, :bin3]))" + "text/plain": "(Meas1 = Measurement(Observable\n prediction: xsec1 (function of type typeof(Main.var\"##347\".xsec1))\n min: Float64 -Inf\n max: Float64 Inf\n weight: Float64 1.0\n, 21.6, (stat = 0.8, syst = 1.8, another_unc = 2.3), true), Meas2 = Measurement(Observable\n prediction: xsec2 (function of type typeof(Main.var\"##347\".xsec2))\n min: Int64 0\n max: Float64 Inf\n weight: Float64 1.0\n, 1.9, (stat = 0.6, syst = 0.9, another_unc = 1.1), true), MeasDist = BinnedMeasurement(Observable[Observable(Main.var\"##347\".var\"#1#2\"{Int64}(1), -Inf, Inf, 1.0), Observable(Main.var\"##347\".var\"#1#2\"{Int64}(2), -Inf, Inf, 1.0), Observable(Main.var\"##347\".var\"#1#2\"{Int64}(3), -Inf, Inf, 1.0)], [1.9, 2.93, 4.4], (stat = [0.7, 1.1, 1.2], syst = [0.7, 0.9, 1.3], another_unc = [1.0, 1.2, 1.9]), Bool[1, 0, 1], [:bin1, :bin2, :bin3]))" }, "metadata": {}, "execution_count": 7 @@ -231,7 +232,7 @@ " uncertainties = (stat=0.6, syst=unc_syst[2], another_unc=1.1), active=true),\n", "\n", "\n", - " MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4],\n", + " MeasDist = BinnedMeasurement(diff_xsec, [1.9, 2.93, 4.4],\n", " uncertainties = (stat = [0.7, 1.1, 1.2], syst= unc_syst[3:5], another_unc = [1.0, 1.2, 1.9]),\n", " active=[true, false, true]),\n", ")" @@ -252,7 +253,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "5×5 Array{Float64,2}:\n 1.0 0.4 0.1 0.1 0.1\n 0.4 1.0 0.0 0.0 0.0\n 0.1 0.0 1.0 0.5 0.0\n 0.1 0.0 0.5 1.0 0.3\n 0.1 0.0 0.0 0.3 1.0" + "text/plain": "5×5 Matrix{Float64}:\n 1.0 0.4 0.1 0.1 0.1\n 0.4 1.0 0.0 0.0 0.0\n 0.1 0.0 1.0 0.5 0.0\n 0.1 0.0 0.5 1.0 0.3\n 0.1 0.0 0.0 0.3 1.0" }, "metadata": {}, "execution_count": 8 @@ -279,7 +280,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "(stat = EFTfitter.NoCorrelation\n active: Bool true\n, syst = EFTfitter.Correlation([1.0 0.5 … 0.2 0.2; 0.5 1.0 … 0.2 0.2; … ; 0.2 0.2 … 1.0 0.2; 0.2 0.2 … 0.2 1.0], true), another_unc = EFTfitter.Correlation([1.0 0.4 … 0.1 0.1; 0.4 1.0 … 0.0 0.0; … ; 0.1 0.0 … 1.0 0.3; 0.1 0.0 … 0.3 1.0], true))" + "text/plain": "(stat = NoCorrelation\n active: Bool true\n, syst = Correlation{LinearAlgebra.Symmetric{Float64, Matrix{Float64}}}([1.0 0.5 … 0.2 0.2; 0.5 1.0 … 0.2 0.2; … ; 0.2 0.2 … 1.0 0.2; 0.2 0.2 … 0.2 1.0], true), another_unc = Correlation{LinearAlgebra.Symmetric{Float64, Matrix{Float64}}}([1.0 0.4 … 0.1 0.1; 0.4 1.0 … 0.0 0.0; … ; 0.1 0.0 … 1.0 0.3; 0.1 0.0 … 0.3 1.0], true))" }, "metadata": {}, "execution_count": 9 @@ -317,7 +318,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "(ρ1 = EFTfitter.NuisanceCorrelation(:syst, :Meas1, :Meas2, Distributions.Uniform{Float64}(a=-1.0, b=1.0)), ρ2 = EFTfitter.NuisanceCorrelation(:syst, :MeasDist_bin1, :MeasDist_bin3, Truncated(Distributions.Normal{Float64}(μ=0.5, σ=0.1), range=(-1.0, 1.0))))" + "text/plain": "(ρ1 = NuisanceCorrelation(:syst, :Meas1, :Meas2, Uniform{Float64}(a=-1.0, b=1.0)), ρ2 = NuisanceCorrelation(:syst, :MeasDist_bin1, :MeasDist_bin3, Truncated(Normal{Float64}(μ=0.5, σ=0.1); lower=-1.0, upper=1.0)))" }, "metadata": {}, "execution_count": 10 @@ -367,21599 +368,19123 @@ "name": "stdout", "output_type": "stream", "text": [ - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Trying to generate 4 viable MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:56\n", - "┌ Info: Selected 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:174\n", - "┌ Info: Begin tuning of 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:35\n", - "┌ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 2 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 3 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 4 finished, 4 chains, 4 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC tuning of 4 chains successful after 4 cycle(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:71\n" + "nui: NuisanceCorrelation(:syst, :Meas1, :Meas2, Uniform{Float64}(a=-1.0, b=1.0))\n", + "nui_k: ρ1\n", + "nui: NuisanceCorrelation(:syst, :MeasDist_bin1, :MeasDist_bin3, Truncated(Normal{Float64}(μ=0.5, σ=0.1); lower=-1.0, upper=1.0))\n", + "nui_k: ρ2\n", + "[ Info: MCMCChainPoolInit: trying to generate 4 viable MCMC chain(s).\n", + "[ Info: Selected 4 MCMC chain(s).\n", + "[ Info: Begin tuning of 4 MCMC chain(s).\n", + "[ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 2 finished, 4 chains, 0 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 3 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 4 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 5 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 6 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 7 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 8 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 9 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 10 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 11 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 12 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 13 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 14 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 15 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 16 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 17 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 18 finished, 4 chains, 3 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 19 finished, 4 chains, 4 tuned, 4 converged.\n", + "[ Info: MCMC tuning of 4 chains successful after 19 cycle(s).\n", + "[ Info: Running post-tuning stabilization steps for 4 MCMC chain(s).\n" ] }, { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=58}", - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJjU30J6CVUFZ2WvAAAAAElFTkSuQmCC\n", + "\" transform=\"translate(318, 658)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAIA7/geYxWNTrs5r5gAAAABJRU5ErkJggg==\n", + "\" transform=\"translate(318, 1858)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAQ/8GGzFf3eOQDaUAAAAASUVORK5CYII=\n", + "\" transform=\"translate(1342, 1858)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAAAAAADY0a/VHQA41b/++vrP6///9z9dk4E5/rG6AwAAzGW0yf95TSSkEQDwmSSAAACHkfAw\n", + "hWQRAPYhAQQAOIwkppDUCwDYkQQQAAAAAAAA4GOoSzuQ2kTYn+8pUEkNIADAYYwqeRzJyBl8zgB1\n", + "JIAAAIcxql7sNeX4+pJ0wEy+f8CpJIAAAIdxAwgAcBjTHQBMY3EP7EECCABwGKOvBzKCBgAiJIAA\n", + "AIeRHkGRlqTWY0gAWEECCABwGGnDm13r63btF8B3XLN+ZgaAlSSAAACHMdo43G4j0KvU4L2f370G\n", + "Wkim5lADe7ZP/Z590vuSAAIAHOaRd6+fdAd+54TU6+o93sl8/3ftf9JxHnHK94z9ORchnwQQAOAw\n", + "RlIP8cQR8Eifd3qfVQnsTu/xKRyz76mh45P4ns8lAQQAOIw7bC49cTQ2u8+nJDCnnAvR95l5nJ54\n", + "zHflWK71xO/FJ50zV+9FAggAcJhH39XCnU8awe3q0xJQ58z3VhwXzxF8thmf386f/xOuJRJAAIDD\n", + "uAEEADjMtFhypzh0p76caPXxX93+Cp/0UPGqgvKM/UW1/CnE1X1c4fT3X6Xy/PeZfW+n4yIBBAA4\n", + "jLvyGzPu1EdGYJV/vuyTkiL+pyVZeuczj9lppM/3npIAr97XSJuvVh9XvicBBAA4TPiuPHsEFa2B\n", + "6V16nj0yedqo/4kJ0IkPAt2pL6/UEHGaU66ZHsPz+SSAAACHGbpbHxkBVY3mP3kEcuKfpdrpPVd5\n", + "Qh/f7XouRWton3L8d7K6tiyaYGXOJj3RU96XesJ6EkAAgMMcfyc9q4bxk+ycBs5Imp/yuVY9U+6T\n", + "jsXT+/KUGZCnJMivVjyHcafz9FXrUwRmPC1j1vF/tdNvSeaxkAACABzm14pVfKtrMHZKlqJtfvIf\n", + "075S+fntdM5F23m1+jyvOv471wDumuascHoNeOZzOHf6/Xriiug7p31nJYAAAIe5vcNdfTc8ez4+\n", + "e9/R9p++CupudPi3kTTo7rzMTJBGRu1X+/okVSsye/a3i0/+/kZlzmCsPpar2x+xos+71np+kszU\n", + "VQIIAHCY5gTwykgC0Lp9yzbRVVynJBArVrS1iCYAIzJrcKLbZP5Vm5/2d7KqlXcj37/VnlIDOeMz\n", + "W10P/G7X82envrwa+f2YdS4+IYGVAAIAHGbanfxTVkG27Hf1Hfzq0VhrDd6rWSPbqlF/63m1+rN5\n", + "gswalieugp+18nOFp/QzyxMT+J3Pv9mp6xM+r1Etx1ICCABwGDeAAACH2S7+nPVnfqraeHqkHH2M\n", + "yquR6YToFPjIwokrVY+RmbX9rnaeJsxcOLXrIojKNnutnsLPfpD4jIV3IyU4r3b6zu12/dr52lRB\n", + "AggAcJihO9yRgvpXK0bDu7Uzo/0nFL5mPxKhahHNikdH7LqvqMoEZcYinmgCXWn1o0+qjl/m57/T\n", + "Y8Cij8Ga9Vletbn6+GXrTVCf8v6vzgUJIADAYcJ3q7s9iHlGApRptxFD70hz1ue3egSfmRquTola\n", + "7VT3NvL5j3xnd7r+PLEGMDPBezVSzzty/kTb7N0XMdEa6p3N6L8EEADgML9mrYJq2dfdNpUrNyP7\n", + "Wi17BJRZw5PZr0yf9CDU7ATsal93bUb2O/JZtFqdgL2adf6vroHNNLse9Kf9tWzfu69oO9k1qLO3\n", + "3znBe8r3JEICCABwmPAq4HfRBLG3/dXPQRpJMCtryEZWbl29rrdfd68baa83zeh5XYtdV6uvTiMr\n", + "V6rPqCHNlLkiNdtOacSK1GxGAveut82R45I5gzFSQ9nazxkq09zK+4SWNqK//y39lwACABzmd3QH\n", + "K0aWI6sAo6t9r7aflQBEE4zMZCQ6gqw8Zi2vG1lF3Np+VQ1hVbLROoIcOU9m7Csq+v7vzp+qVcyz\n", + "6tmqaoBb+7M6gcqsBxxpI/r59+73rj8jMyvRc2FE5meWmQCPvOcZ20gAAQAOM5QARkdmIwnMiN7R\n", + "dMb20VVQVaI1hJnt37XXm5rc9b83DfyuPxGZaeaMvoxsMzKazq77fJU5Al+t5Zi3nr+ZNcit22fW\n", + "YGbOoKw+F0ZmE6pmQCplJshX+x35/Z11/9Hbr+/68902mTMAEkAAgMM03+3OSoaiCVpvajBrFWN0\n", + "FdDVNpU1fCPbRGuYZtdwZtfwzEp0W0SP5avMepiqNGjkddnn1Yy6p2g93OpzIVo3nJmGZWwT2T56\n", + "/Y3+fo707SkJaubK29Y2ZieI0RpeCSAAwGHcAAIAHCYcV2bG+a3b36mK3Vv1FrGPPIaicgr1qi9X\n", + "bWRs07L9lexFFJmLUFraeBfdvmVfmSUAI+fv1X57Xncls/0Z0zmtVpRAVE27jnx/qn4zshckZU67\n", + "z5iOnvX73dqv6O9fS/tX7Y20mX39yDz/W0gAAQAOM+1B0Nmv6zVrEUhvm5VFpJmj0ZE0IDONbenL\n", + "XZuZCV5U9PhVJti9stOsGe955PxZ8RiV1+0zv3N3r49eJ3uPf+t/a02AqhLczAUFrQlO9Po58v5b\n", + "rp+totfSqgUtrcc4eixGPv+WfbX2paUdCSAAwGH+SAAz5+CvjIyGr7YfSeB6X3PXfmvforV50Xqc\n", + "VlfbtP57tAan5ZiNJHizakiuth+p4aySWcP3rjeBbd1+5PW958JPfWt5TTRB7P3Ojnz/MtOIWTWU\n", + "VedPdoI226wZjJEEOjoDlvn9jdZwtrTRun30unr1W3jX/tW/SwABAA7ze2QVTKWWufpov6I1QCNG\n", + "EqCRNCL6OWUmeNE2RuoeMusOq1ZrZr/nkXauXlOZDv3075WqEqR3mSsvW8yqwc5MgFplnvOrf9eu\n", + "+vKu9/x5f01VDWur6Pkf1dtm9gxa5vZX+xqpgb36dwkgAMBhbkcCs0YNVzLTnFkrd6rqJlutGHW1\n", + "9CUzDaisgVydgM46T1pU1bNlr5yMiNZARmuQWs1e3fpuVv8za9B3reGLHvOqa2lG+zOuGdHvwuoZ\n", + "gNa+XIney7ySAAIAHOaPu8LMGq6rbaKiq/ii/coeNX2SaGqzOgEbSX1eVa28zEyjr17Tuu/KupkZ\n", + "q2gza7Du9p2Z2mWeM6u/Y6+yZ2Yyv78zErDsGu7eNmfNYFTVMEf3G71/uFP1PYuuYVADCABwsF+Z\n", + "aULP6757/bsZtQ6tNUDRfmWOwKJtZu73XVUNZWtfqpKOWccymmBnHv+WfmXWo4xsn11DudP7n30t\n", + "am1npxmg7HZGUrOs/Y7IrsHt3X71+Xf3upY2q5LJUVU16GoAAQD4+voqSAB793VnRjuVq4ijdq3V\n", + "qVy59GrFKtxe0RHYiu9fVGWCVHWcZqU2s2s9M1fU/vTfevp118+R9ivb7DWrBjezhnPW9aP3Pa++\n", + "lt15wucX/f2TAAIAHGZaDWDmCLByFdiVXWs4ZrX/lFHblZ36P/JderW6/083q24quop019mEzFW0\n", + "lQn67HrQbDudC63HIpoAZm5/1c+dEtTKmcWWfUsAAQAO4wYQAOAwzVPAT7fTFOCd2VFzdgS/k2gR\n", + "793rfnp9tF+r9JZHzFpEUyVzOrPndb19y3wMxp3eqbJoEXpr+61WT/X1fmYrSpjuRPvfK/ORNNn9\n", + "qboWVT7GxiIQAABu/X7/h9l3+rslIFVaRxazH30TfSTCXfsrHr3Qu010vyOjuejCj2gR9Z2RhVst\n", + "Mh/vcqf3PUeLyEf6UpXGjeyrVdVjcFrP32gC2yp6zHu/P9nX36u+vMo8l7K1fOYrjllUa5+jCXDv\n", + "sZEAAgAc5o8awKoaiFnbR82uAdi5hmLGoxdG2r+zaw1IVYIy0mblY5Rmnc+97c04rneve1VZ2zvj\n", + "nLkTrWHq3e+d3tmQu+1XPy6kpb1Wn/q7+hSVMwi9v98SQACAw4RXAbcmOLMenjij/adYnTRmjqBX\n", + "r8JdsQpuRgI58v3NTDOjq9iyZzBmiB6/FatjW/rY2n50fyPn70hfWkR//1avQo9efzJXtLa+btY1\n", + "M2r1iuIWEkAAgMPc3j1Ga7haZKd50RqinWo4qmplVtfdtLaRmdRdtVk5Aq8aQbdanYZ9Uj1lZvur\n", + "E5CRBHXWuZS5Wnyn63frNlfbz0p9n1CDO0tVDfUsagABAPhDaQ3g1esyR83R9rNX0a22om7rSmY9\n", + "zoqRVVUNW+v2O40mo6LvJTMNq6yBW536XrVTdcyzz8uqPo9s/yozAZp1/F5lzqDcmTED2NrejOt3\n", + "q6q68+hsngQQAOAwQzWAq1fhto7Aevv43f4i7c9YYbd6FetdOzulVrPe/9NkJ/hVVrd/1Zd3lStM\n", + "Z7RRNYOy+vOrquFtbXPXVfBPScCqtlmdQI5sk3n/JQEEADjMH3eSmTVMI9tfmTWCytwmavWKvCor\n", + "arCqVo7uVkOaec7suor1qo3ovu72PeNY9uyvt52okf7PmA3Z6fv29TX/96cywa065n6/avpy5+pz\n", + "lQACABwmnAC+m72Kd6QvlWa3WbkKdbUnjPora4hG2o/s625/I6sDV6xC773mzKqhnZGG3u3v6de/\n", + "Gfu923c0aWl5/YiRBLZqpfRI+yMqE/So6P1Pi8ztJYAAAIdxAwgAcJjmKeDVhY9PaX/2YwSi21TG\n", + "+TMKwldMwVbKnGq82n5k2nHFIpoVZR+V02PfyZ4OryoB8b1aOwXd2pfo9OpVX2YsCLnb3+rv9ci+\n", + "otOzmfu9akMCCABwmKE7ydXFyZkPb3xKEWnL69897b08xcgIvCrB6enbT30cab9qlPu+76rUuTJB\n", + "m7VwpkpVGjrr+htdhBE9f2YsyKlMEJ84AzRj+5F9V/U5OoMiAQQAOMyv7AQjus3V9iPbXLU5Mm/f\n", + "emfdO1LaORmLLl3PrGd4SjJSlQDOes+zP/ORGs4V9bgjMhOkna8TLUauf9FtZhyz3WaQolbPYGSq\n", + "SuNWyKz7eyUBBAA4zO1dZTTB693v+75HEoDMBO9K5orMjG1a9jVrpLNT0hldRfpq1iralr5EzUoQ\n", + "R9qcUXc20n40daya9Zh1XVixCrSqhi+aQF+9vnWb1v1VzYCNbN9q9vHLnkGJzuDNWi3eoqV9CSAA\n", + "wGHCCcOKVTSVekcQO9ewzVgF+WlW14fMSKAqR/lVq9hXj8Az28g8fhlttrxuRQJ497pI+9EEdEUN\n", + "4sgq0JHtW/Y1YueVu7PN+v5bBQwAwB+GUrXKVbSZRuq5Zo96suf2exOg1TUUd1avAs2sJ5u1fVWC\n", + "2NvHu+1n1WDNTgPv2lmdoLVuH9nX3b53Sn1GvguvVv9mtbz+bpudzKoBHNnfjAS8UkufJYAAAIf5\n", + "4w4xOupv2ddIAlBVGzjS/t32Lfu6ek3rvqMj2JY2etqZIbMGdFYCfCXzM69M4Hr3dSdz+2jqMVJ3\n", + "WHXNqfz+txg5/yuv/6vNuP5nrshdnYC32qkvrXZa0fsqcwZJAggAcJjbvwSSWcM1soqvZb93qmrw\n", + "ojLrTiprCK+2qTxm0RHsjFqNaILd2q/MGtbVNSyVqUfLvqLXn9bjOiMpiH4XovuqnHUYaTNiJEGr\n", + "rGG9Muv8e1pSF02wZ9Vzrr7OWgUMAMDX19cPNYAznh0UrWGIJiB3ZtRgRGuAottER+PZ9VQrVp62\n", + "qFpR3GqnurGr/d7JrE2KJsOt59+scz6yfWYaeNeXkf1m9nnW6s7smsqf2sycDao047NY3ZfW/VUm\n", + "e9EEufc8kwACABzGDSAAwGFupwWqFoFk7vddNIKvit2rHinxLnMKeoXoFOaMzz9zQcO7FdNer3oX\n", + "TmQvDquagqn6zLJLUKqmTVeUYGSW8LSKTptnLuKKqiqBWn1dGlG1ILCyBK1yqrpFS58lgAAAh7l9\n", + "DMyVWQlMVbF9ZgJXOZoaGXVmjlRnjKaj519lgjl7QdHovlvaWVEEPyNpyF6E0Dvq362IP7OIvLe9\n", + "ke2jMtPsu33PWjgVPedb9pv5Xai0uv0rK/pVtYhKAggAcJjmkUTVvHt2DVZVDU5re5mJVNVo8K6N\n", + "aN3gjBqqFefCrO2rakha27/qy8i+Vydw0W1a9vVudg3higSisv2qz/9T7ZbA7vp5RM/fGWsD7mTW\n", + "oKsBBAA4WPMq4CvZq9sya4BGVK5Q/k7rKqLWNnYaHc9audVr51WoVzLTxGibd+1nrpzc6VweMbue\n", + "eQdV73l1UjNixSrolvZnfa9mr8h+l1kDu+KYtYj2RQIIAHCY3+//0DuCz54Dr1r519tGz+ta+5bV\n", + "/uoRXOV+o+20jDRbR1ktr6uswdxp+5FzYXaacdfmriP4O1XXn5E2ou+r9fhHE/jo9rNT61mzOZkr\n", + "11t/f6Op49XrVnz/VyS4vX0ZIQEEADjM0KguOhrKrEeKrqJrbbN1ZDhjBP6UlX9VqzUrV9H21q2s\n", + "qOG5ek2r1v6vrmG6kllntlsN3ZXVCeZIDXfU7HMpo82dahBbVNbwX21/9/rodS6z1nFGDW+rkQS2\n", + "hQQQAOAw0xLAke1b9htdRdyz7wqZK5re97f6/VclcJWqRqAtbbxvk5lAZ44gq1Y03+07mgbPEq0B\n", + "zpxBmDXr0dL+TglYZppUdYzvtpml6mkL0brHzGvx3TZVovcvmd8rCSAAwGF+z6rhGFl5mVmDNTKC\n", + "q3qOUmUyFl0Fl7nNiN4EYlaaFV059tpO5ncsWg8Z/V62vu7q/UdXhN7JnIEY6XNlUtq7fevnv9MM\n", + "wgzRGrbK2bCWa0b0uxhNoFpFV/5WreK9U3Uu7/S9kAACABym+U5+ZBXPSOowY957ZAQUTc1eRWsg\n", + "Ws1YkbZ6ddZdOy3bZH8WVavgRvq1OsGuSiCiRvr/qjWB33UVYWubVX1ecf0Z6Uvm+bvr9ad1+6t9\n", + "zZqBau1j5vfvqs1ZtYUzroUSQACAw7gBBAA4zB9/Cq5F68KJ6L5fY88VEepIQWxLsXDmFObd9tHp\n", + "9JbXRYuYsx+jED1/evsZXRAwMgWauQim1a7F/SOLwEaMLBy7+vfMab/WKejMRWSt7V+9rrIEIHPh\n", + "04iqsp2q39WR6dSRhWNX+23dvvVaHi176f3Nb11E1NvGaPstXreXAAIAHGZoVLF6QceKItLe19z1\n", + "bVZxeNWCnLu+9I60Rx7DsOLxGpkLH0b6lplmZBaEt+57xXc+87OIJmiZiwCiCUSrqjR1pM0RVcdv\n", + "ZOHQ1faZv0V3fYmmYa2qrv+tbUSvn5nf3xbZn39vgikBBAA4TNlI7t1IDV3VSHNWmpQ5Ap2RJt29\n", + "LtqX1j7OqtWK7DdqVoLbu6+Rfs46f2Z9rlUJRG8brftqbafq+tG6TUsfM7bv7ddIApN5LO9k1u1F\n", + "ZR6/lv2+b1P1+Y20edd+7zbZNbAtJIAAAAf7YxXwjASusoYk2v7sUV/2segd9VQmMCvSuN6R5ki/\n", + "MhPUu21GVgT2rty7G8H2ruicJTN1rEzwKuszW9qIfv+iNVxVCWZr+y37rerXXTuVCdDsBPuu/yMz\n", + "AL2zVtmff7QGsPfciibgURJAAIDD/JEAzkj9KhOczFFv5QrdFi2j3vf2elOjylWELQlqdBVW6+e/\n", + "uh4wWsNTleBW1sBFE5CWf69cETxyLahKoDO/v6sT1LvXZyYoVb9lI22sSGBHRM+flm0qk/HeGbxo\n", + "DX+rkfZH9PZNAggAcJiltXirVK486m0zczQxIroKtNLIKrLZqVlrAlG1CvdOdBV4VV92fv+9CVh2\n", + "/2ckwHdmHPPK7XvbyKwHG22nSuYq3JY2WreJbr/6uN7JvP6PkAACAHDr14o7+KidRwC9ognEaDtZ\n", + "+8quwYmOoGafD9EatOg2uyXIMxK0zBXpI/1veX3r9iP7i85gtLY3a6ahpT9V15XsdnbqS+b35Oo1\n", + "72YktdHa/KrjMiKaAEb7IgEEADhMOAGcZdfUL5og3NnpfVbJPv+qRo0t7Y3st/L9t7bZIrPubUXd\n", + "X7SN1auwVydYO12/ZiXYq39zZqeRle206k0gs78LmQnoyDVjdiIoAQQAOMxtAvjEEdCKuomr7V+N\n", + "rGLNFD2Wr6pSulnbr1ZZQ5kpuop2Rd3q6uM3Kym8klnr1NtGazurP6NWO9Vdt+w3Y9/Rvuz0+xXd\n", + "1+o0sKVf0f1JAAEADuMGEADgMNPi4lkRbu9jRKI+uYi2qv2r179vM/uzvOvbyBT+ro9xWC06BbPi\n", + "8SSvZj2G6Amf5YhZi4A+6ZhVyb7+Zl7/W7fp3b513zOu2atLKCSAAACH+bgRUlXh7VUbsx6kW9V+\n", + "ttXHv3fhwm7Hr8XOi2hm9K2qOP/djDRhRZqx8yKk1e1f2bVf72ak45WLwKoWUWX6pMcQSQABAA4T\n", + "vqtcvSR9txq8J1g9ml3dPvvY+fs7I83euf0W2Z+fa0ONnWYNnjKD1vtIpJ5970ICCABwmKE71Fmp\n", + "39Pupnd2+rFc8f53bfP0c6FVdBU4/KT1/Hnid/bpTzEYeULAq9X9byEBBAA4zPZ3qN9ZPUpYXcNQ\n", + "KTNBWv05VYkm4DuvYn3aKrqd21/9Pnf19OPy9P6fbtZTADJVnXMSQACAwzzmL4E88a79U61IAI26\n", + "Yxy/fqv/Eg0/swr52sgq8qef8094juBOJIAAAIf5+Dvc3e1WA0jM7BrK6CrCT16FuKvTa2ijHJfz\n", + "zFpRPPvcWv37LwEEADhM+DmAn7yKb9f2oz55FfNsq/8SDjzN06+fIyTwz7PTMbcKGACAFG4AAQAO\n", + "I0o+XHQK99OmgGc8BmH11MLq9pnD5/w/mY8hO/1YUmf2n/KUAAIAHMZI5k3LA6eNAKkSfZBplWgR\n", + "+4x+rWifzyX149NJAAEADmNUQ8hIAuNBuGvt9BggCR7AGhJAAIDD/F7dAZ4nmiBJeea4+px2Ov47\n", + "9YU2T0nmn9LPK0/vP/uTAAIAHGb5qEINEFeePgLeqf879aXVJz17sYoaTBh3+vkvAQQAOMx2d7uf\n", + "OlK/cvoIBACYTwIIAHAYaRNAsdNmNoD9SQABAA5jJHqIpyQQVf18yvtfLXqcHGeAZ5AAAgAcxgh9\n", + "Y9IUqGUVPiu1nn9+C6ggAQQAOIwbQACAw4iS6WY6Avbku8nfnAt85/W8kAACABxm+ahAETbwKaQu\n", + "33NcYA8SQACAgxmJAQB8qPeZ1r9JAAEADvN7dQcAZlKPBiABBAA4jtEvkEa6BrCXq+uyBBAA4DBq\n", + "AIE0LamflPA8PnPYjwQQAAAAAAAA4GMsr8W4+1vA6kYA4Ax+8+dSAwgAcBh32ABAEynd55AAAgAc\n", + "xg0gAMBhxLcAlDJtCPuRAAIAHMZIDAB4nLvHyPEzCSAAAAAAAADAxzBf/sZqNSCb6wqM8/2poQYQ\n", + "AOAw7qQBgP8jdft8EkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n", + "AAAAAAAAPtSv1R2AE/zrr6///P2///1P3zsA1vrH6g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA\n", + "R/AnqeAw/iwdAP4UHADAYYz+Ab4hKQU+mQQQAAAAAAAAAAAAAAAAAAAAAGCp/wLfMhs/WbsQhAAA\n", + "AABJRU5ErkJggg==\n", + "\" transform=\"translate(2336, 1858)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJjU30J6CVUFZ2WvAAAAAElFTkSuQmCC\n", + "\" transform=\"translate(318, 658)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAIA7/geYxWNTrs5r5gAAAABJRU5ErkJggg==\n", + "\" transform=\"translate(318, 1858)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAQ/8GGzFf3eOQDaUAAAAASUVORK5CYII=\n", + "\" transform=\"translate(1342, 1858)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n", + "AAAAAAAAAADY0a/VHQA41b/++vrP6///9z9dk4E5/rG6AwAAzGW0yf95TSSkEQDwmSSAAACHkfAw\n", + "hWQRAPYhAQQAOIwkppDUCwDYkQQQAAAAAAAA4GOoSzuQ2kTYn+8pUEkNIADAYYwqeRzJyBl8zgB1\n", + "JIAAAIcxql7sNeX4+pJ0wEy+f8CpJIAAAIdxAwgAcBjTHQBMY3EP7EECCABwGKOvBzKCBgAiJIAA\n", + "AIeRHkGRlqTWY0gAWEECCABwGGnDm13r63btF8B3XLN+ZgaAlSSAAACHMdo43G4j0KvU4L2f370G\n", + "Wkim5lADe7ZP/Z590vuSAAIAHOaRd6+fdAd+54TU6+o93sl8/3ftf9JxHnHK94z9ORchnwQQAOAw\n", + "RlIP8cQR8Eifd3qfVQnsTu/xKRyz76mh45P4ns8lAQQAOIw7bC49cTQ2u8+nJDCnnAvR95l5nJ54\n", + "zHflWK71xO/FJ50zV+9FAggAcJhH39XCnU8awe3q0xJQ58z3VhwXzxF8thmf386f/xOuJRJAAIDD\n", + "uAEEADjMtFhypzh0p76caPXxX93+Cp/0UPGqgvKM/UW1/CnE1X1c4fT3X6Xy/PeZfW+n4yIBBAA4\n", + "jLvyGzPu1EdGYJV/vuyTkiL+pyVZeuczj9lppM/3npIAr97XSJuvVh9XvicBBAA4TPiuPHsEFa2B\n", + "6V16nj0yedqo/4kJ0IkPAt2pL6/UEHGaU66ZHsPz+SSAAACHGbpbHxkBVY3mP3kEcuKfpdrpPVd5\n", + "Qh/f7XouRWton3L8d7K6tiyaYGXOJj3RU96XesJ6EkAAgMMcfyc9q4bxk+ycBs5Imp/yuVY9U+6T\n", + "jsXT+/KUGZCnJMivVjyHcafz9FXrUwRmPC1j1vF/tdNvSeaxkAACABzm14pVfKtrMHZKlqJtfvIf\n", + "075S+fntdM5F23m1+jyvOv471wDumuascHoNeOZzOHf6/Xriiug7p31nJYAAAIe5vcNdfTc8ez4+\n", + "e9/R9p++CupudPi3kTTo7rzMTJBGRu1X+/okVSsye/a3i0/+/kZlzmCsPpar2x+xos+71np+kszU\n", + "VQIIAHCY5gTwykgC0Lp9yzbRVVynJBArVrS1iCYAIzJrcKLbZP5Vm5/2d7KqlXcj37/VnlIDOeMz\n", + "W10P/G7X82envrwa+f2YdS4+IYGVAAIAHGbanfxTVkG27Hf1Hfzq0VhrDd6rWSPbqlF/63m1+rN5\n", + "gswalieugp+18nOFp/QzyxMT+J3Pv9mp6xM+r1Etx1ICCABwGDeAAACH2S7+nPVnfqraeHqkHH2M\n", + "yquR6YToFPjIwokrVY+RmbX9rnaeJsxcOLXrIojKNnutnsLPfpD4jIV3IyU4r3b6zu12/dr52lRB\n", + "AggAcJihO9yRgvpXK0bDu7Uzo/0nFL5mPxKhahHNikdH7LqvqMoEZcYinmgCXWn1o0+qjl/m57/T\n", + "Y8Cij8Ga9Vletbn6+GXrTVCf8v6vzgUJIADAYcJ3q7s9iHlGApRptxFD70hz1ue3egSfmRquTola\n", + "7VT3NvL5j3xnd7r+PLEGMDPBezVSzzty/kTb7N0XMdEa6p3N6L8EEADgML9mrYJq2dfdNpUrNyP7\n", + "Wi17BJRZw5PZr0yf9CDU7ATsal93bUb2O/JZtFqdgL2adf6vroHNNLse9Kf9tWzfu69oO9k1qLO3\n", + "3znBe8r3JEICCABwmPAq4HfRBLG3/dXPQRpJMCtryEZWbl29rrdfd68baa83zeh5XYtdV6uvTiMr\n", + "V6rPqCHNlLkiNdtOacSK1GxGAveut82R45I5gzFSQ9nazxkq09zK+4SWNqK//y39lwACABzmd3QH\n", + "K0aWI6sAo6t9r7aflQBEE4zMZCQ6gqw8Zi2vG1lF3Np+VQ1hVbLROoIcOU9m7Csq+v7vzp+qVcyz\n", + "6tmqaoBb+7M6gcqsBxxpI/r59+73rj8jMyvRc2FE5meWmQCPvOcZ20gAAQAOM5QARkdmIwnMiN7R\n", + "dMb20VVQVaI1hJnt37XXm5rc9b83DfyuPxGZaeaMvoxsMzKazq77fJU5Al+t5Zi3nr+ZNcit22fW\n", + "YGbOoKw+F0ZmE6pmQCplJshX+x35/Z11/9Hbr+/68902mTMAEkAAgMM03+3OSoaiCVpvajBrFWN0\n", + "FdDVNpU1fCPbRGuYZtdwZtfwzEp0W0SP5avMepiqNGjkddnn1Yy6p2g93OpzIVo3nJmGZWwT2T56\n", + "/Y3+fo707SkJaubK29Y2ZieI0RpeCSAAwGHcAAIAHCYcV2bG+a3b36mK3Vv1FrGPPIaicgr1qi9X\n", + "bWRs07L9lexFFJmLUFraeBfdvmVfmSUAI+fv1X57Xncls/0Z0zmtVpRAVE27jnx/qn4zshckZU67\n", + "z5iOnvX73dqv6O9fS/tX7Y20mX39yDz/W0gAAQAOM+1B0Nmv6zVrEUhvm5VFpJmj0ZE0IDONbenL\n", + "XZuZCV5U9PhVJti9stOsGe955PxZ8RiV1+0zv3N3r49eJ3uPf+t/a02AqhLczAUFrQlO9Po58v5b\n", + "rp+totfSqgUtrcc4eixGPv+WfbX2paUdCSAAwGH+SAAz5+CvjIyGr7YfSeB6X3PXfmvforV50Xqc\n", + "VlfbtP57tAan5ZiNJHizakiuth+p4aySWcP3rjeBbd1+5PW958JPfWt5TTRB7P3Ojnz/MtOIWTWU\n", + "VedPdoI226wZjJEEOjoDlvn9jdZwtrTRun30unr1W3jX/tW/SwABAA7ze2QVTKWWufpov6I1QCNG\n", + "EqCRNCL6OWUmeNE2RuoeMusOq1ZrZr/nkXauXlOZDv3075WqEqR3mSsvW8yqwc5MgFplnvOrf9eu\n", + "+vKu9/x5f01VDWur6Pkf1dtm9gxa5vZX+xqpgb36dwkgAMBhbkcCs0YNVzLTnFkrd6rqJlutGHW1\n", + "9CUzDaisgVydgM46T1pU1bNlr5yMiNZARmuQWs1e3fpuVv8za9B3reGLHvOqa2lG+zOuGdHvwuoZ\n", + "gNa+XIney7ySAAIAHOaPu8LMGq6rbaKiq/ii/coeNX2SaGqzOgEbSX1eVa28zEyjr17Tuu/KupkZ\n", + "q2gza7Du9p2Z2mWeM6u/Y6+yZ2Yyv78zErDsGu7eNmfNYFTVMEf3G71/uFP1PYuuYVADCABwsF+Z\n", + "aULP6757/bsZtQ6tNUDRfmWOwKJtZu73XVUNZWtfqpKOWccymmBnHv+WfmXWo4xsn11DudP7n30t\n", + "am1npxmg7HZGUrOs/Y7IrsHt3X71+Xf3upY2q5LJUVU16GoAAQD4+voqSAB793VnRjuVq4ijdq3V\n", + "qVy59GrFKtxe0RHYiu9fVGWCVHWcZqU2s2s9M1fU/vTfevp118+R9ivb7DWrBjezhnPW9aP3Pa++\n", + "lt15wucX/f2TAAIAHGZaDWDmCLByFdiVXWs4ZrX/lFHblZ36P/JderW6/083q24quop019mEzFW0\n", + "lQn67HrQbDudC63HIpoAZm5/1c+dEtTKmcWWfUsAAQAO4wYQAOAwzVPAT7fTFOCd2VFzdgS/k2gR\n", + "793rfnp9tF+r9JZHzFpEUyVzOrPndb19y3wMxp3eqbJoEXpr+61WT/X1fmYrSpjuRPvfK/ORNNn9\n", + "qboWVT7GxiIQAABu/X7/h9l3+rslIFVaRxazH30TfSTCXfsrHr3Qu010vyOjuejCj2gR9Z2RhVst\n", + "Mh/vcqf3PUeLyEf6UpXGjeyrVdVjcFrP32gC2yp6zHu/P9nX36u+vMo8l7K1fOYrjllUa5+jCXDv\n", + "sZEAAgAc5o8awKoaiFnbR82uAdi5hmLGoxdG2r+zaw1IVYIy0mblY5Rmnc+97c04rneve1VZ2zvj\n", + "nLkTrWHq3e+d3tmQu+1XPy6kpb1Wn/q7+hSVMwi9v98SQACAw4RXAbcmOLMenjij/adYnTRmjqBX\n", + "r8JdsQpuRgI58v3NTDOjq9iyZzBmiB6/FatjW/rY2n50fyPn70hfWkR//1avQo9efzJXtLa+btY1\n", + "M2r1iuIWEkAAgMPc3j1Ga7haZKd50RqinWo4qmplVtfdtLaRmdRdtVk5Aq8aQbdanYZ9Uj1lZvur\n", + "E5CRBHXWuZS5Wnyn63frNlfbz0p9n1CDO0tVDfUsagABAPhDaQ3g1esyR83R9rNX0a22om7rSmY9\n", + "zoqRVVUNW+v2O40mo6LvJTMNq6yBW536XrVTdcyzz8uqPo9s/yozAZp1/F5lzqDcmTED2NrejOt3\n", + "q6q68+hsngQQAOAwQzWAq1fhto7Aevv43f4i7c9YYbd6FetdOzulVrPe/9NkJ/hVVrd/1Zd3lStM\n", + "Z7RRNYOy+vOrquFtbXPXVfBPScCqtlmdQI5sk3n/JQEEADjMH3eSmTVMI9tfmTWCytwmavWKvCor\n", + "arCqVo7uVkOaec7suor1qo3ovu72PeNY9uyvt52okf7PmA3Z6fv29TX/96cywa065n6/avpy5+pz\n", + "lQACABwmnAC+m72Kd6QvlWa3WbkKdbUnjPora4hG2o/s625/I6sDV6xC773mzKqhnZGG3u3v6de/\n", + "Gfu923c0aWl5/YiRBLZqpfRI+yMqE/So6P1Pi8ztJYAAAIdxAwgAcJjmKeDVhY9PaX/2YwSi21TG\n", + "+TMKwldMwVbKnGq82n5k2nHFIpoVZR+V02PfyZ4OryoB8b1aOwXd2pfo9OpVX2YsCLnb3+rv9ci+\n", + "otOzmfu9akMCCABwmKE7ydXFyZkPb3xKEWnL69897b08xcgIvCrB6enbT30cab9qlPu+76rUuTJB\n", + "m7VwpkpVGjrr+htdhBE9f2YsyKlMEJ84AzRj+5F9V/U5OoMiAQQAOMyv7AQjus3V9iPbXLU5Mm/f\n", + "emfdO1LaORmLLl3PrGd4SjJSlQDOes+zP/ORGs4V9bgjMhOkna8TLUauf9FtZhyz3WaQolbPYGSq\n", + "SuNWyKz7eyUBBAA4zO1dZTTB693v+75HEoDMBO9K5orMjG1a9jVrpLNT0hldRfpq1iralr5EzUoQ\n", + "R9qcUXc20n40daya9Zh1XVixCrSqhi+aQF+9vnWb1v1VzYCNbN9q9vHLnkGJzuDNWi3eoqV9CSAA\n", + "wGHCCcOKVTSVekcQO9ewzVgF+WlW14fMSKAqR/lVq9hXj8Az28g8fhlttrxuRQJ497pI+9EEdEUN\n", + "4sgq0JHtW/Y1YueVu7PN+v5bBQwAwB+GUrXKVbSZRuq5Zo96suf2exOg1TUUd1avAs2sJ5u1fVWC\n", + "2NvHu+1n1WDNTgPv2lmdoLVuH9nX3b53Sn1GvguvVv9mtbz+bpudzKoBHNnfjAS8UkufJYAAAIf5\n", + "4w4xOupv2ddIAlBVGzjS/t32Lfu6ek3rvqMj2JY2etqZIbMGdFYCfCXzM69M4Hr3dSdz+2jqMVJ3\n", + "WHXNqfz+txg5/yuv/6vNuP5nrshdnYC32qkvrXZa0fsqcwZJAggAcJjbvwSSWcM1soqvZb93qmrw\n", + "ojLrTiprCK+2qTxm0RHsjFqNaILd2q/MGtbVNSyVqUfLvqLXn9bjOiMpiH4XovuqnHUYaTNiJEGr\n", + "rGG9Muv8e1pSF02wZ9Vzrr7OWgUMAMDX19cPNYAznh0UrWGIJiB3ZtRgRGuAottER+PZ9VQrVp62\n", + "qFpR3GqnurGr/d7JrE2KJsOt59+scz6yfWYaeNeXkf1m9nnW6s7smsqf2sycDao047NY3ZfW/VUm\n", + "e9EEufc8kwACABzGDSAAwGFupwWqFoFk7vddNIKvit2rHinxLnMKeoXoFOaMzz9zQcO7FdNer3oX\n", + "TmQvDquagqn6zLJLUKqmTVeUYGSW8LSKTptnLuKKqiqBWn1dGlG1ILCyBK1yqrpFS58lgAAAh7l9\n", + "DMyVWQlMVbF9ZgJXOZoaGXVmjlRnjKaj519lgjl7QdHovlvaWVEEPyNpyF6E0Dvq362IP7OIvLe9\n", + "ke2jMtPsu33PWjgVPedb9pv5Xai0uv0rK/pVtYhKAggAcJjmkUTVvHt2DVZVDU5re5mJVNVo8K6N\n", + "aN3gjBqqFefCrO2rakha27/qy8i+Vydw0W1a9vVudg3higSisv2qz/9T7ZbA7vp5RM/fGWsD7mTW\n", + "oKsBBAA4WPMq4CvZq9sya4BGVK5Q/k7rKqLWNnYaHc9audVr51WoVzLTxGibd+1nrpzc6VweMbue\n", + "eQdV73l1UjNixSrolvZnfa9mr8h+l1kDu+KYtYj2RQIIAHCY3+//0DuCz54Dr1r519tGz+ta+5bV\n", + "/uoRXOV+o+20jDRbR1ktr6uswdxp+5FzYXaacdfmriP4O1XXn5E2ou+r9fhHE/jo9rNT61mzOZkr\n", + "11t/f6Op49XrVnz/VyS4vX0ZIQEEADjM0KguOhrKrEeKrqJrbbN1ZDhjBP6UlX9VqzUrV9H21q2s\n", + "qOG5ek2r1v6vrmG6kllntlsN3ZXVCeZIDXfU7HMpo82dahBbVNbwX21/9/rodS6z1nFGDW+rkQS2\n", + "hQQQAOAw0xLAke1b9htdRdyz7wqZK5re97f6/VclcJWqRqAtbbxvk5lAZ44gq1Y03+07mgbPEq0B\n", + "zpxBmDXr0dL+TglYZppUdYzvtpml6mkL0brHzGvx3TZVovcvmd8rCSAAwGF+z6rhGFl5mVmDNTKC\n", + "q3qOUmUyFl0Fl7nNiN4EYlaaFV059tpO5ncsWg8Z/V62vu7q/UdXhN7JnIEY6XNlUtq7fevnv9MM\n", + "wgzRGrbK2bCWa0b0uxhNoFpFV/5WreK9U3Uu7/S9kAACABym+U5+ZBXPSOowY957ZAQUTc1eRWsg\n", + "Ws1YkbZ6ddZdOy3bZH8WVavgRvq1OsGuSiCiRvr/qjWB33UVYWubVX1ecf0Z6Uvm+bvr9ad1+6t9\n", + "zZqBau1j5vfvqs1ZtYUzroUSQACAw7gBBAA4zB9/Cq5F68KJ6L5fY88VEepIQWxLsXDmFObd9tHp\n", + "9JbXRYuYsx+jED1/evsZXRAwMgWauQim1a7F/SOLwEaMLBy7+vfMab/WKejMRWSt7V+9rrIEIHPh\n", + "04iqsp2q39WR6dSRhWNX+23dvvVaHi176f3Nb11E1NvGaPstXreXAAIAHGZoVLF6QceKItLe19z1\n", + "bVZxeNWCnLu+9I60Rx7DsOLxGpkLH0b6lplmZBaEt+57xXc+87OIJmiZiwCiCUSrqjR1pM0RVcdv\n", + "ZOHQ1faZv0V3fYmmYa2qrv+tbUSvn5nf3xbZn39vgikBBAA4TNlI7t1IDV3VSHNWmpQ5Ap2RJt29\n", + "LtqX1j7OqtWK7DdqVoLbu6+Rfs46f2Z9rlUJRG8brftqbafq+tG6TUsfM7bv7ddIApN5LO9k1u1F\n", + "ZR6/lv2+b1P1+Y20edd+7zbZNbAtJIAAAAf7YxXwjASusoYk2v7sUV/2segd9VQmMCvSuN6R5ki/\n", + "MhPUu21GVgT2rty7G8H2ruicJTN1rEzwKuszW9qIfv+iNVxVCWZr+y37rerXXTuVCdDsBPuu/yMz\n", + "AL2zVtmff7QGsPfciibgURJAAIDD/JEAzkj9KhOczFFv5QrdFi2j3vf2elOjylWELQlqdBVW6+e/\n", + "uh4wWsNTleBW1sBFE5CWf69cETxyLahKoDO/v6sT1LvXZyYoVb9lI22sSGBHRM+flm0qk/HeGbxo\n", + "DX+rkfZH9PZNAggAcJiltXirVK486m0zczQxIroKtNLIKrLZqVlrAlG1CvdOdBV4VV92fv+9CVh2\n", + "/2ckwHdmHPPK7XvbyKwHG22nSuYq3JY2WreJbr/6uN7JvP6PkAACAHDr14o7+KidRwC9ognEaDtZ\n", + "+8quwYmOoGafD9EatOg2uyXIMxK0zBXpI/1veX3r9iP7i85gtLY3a6ahpT9V15XsdnbqS+b35Oo1\n", + "72YktdHa/KrjMiKaAEb7IgEEADhMOAGcZdfUL5og3NnpfVbJPv+qRo0t7Y3st/L9t7bZIrPubUXd\n", + "X7SN1auwVydYO12/ZiXYq39zZqeRle206k0gs78LmQnoyDVjdiIoAQQAOMxtAvjEEdCKuomr7V+N\n", + "rGLNFD2Wr6pSulnbr1ZZQ5kpuop2Rd3q6uM3Kym8klnr1NtGazurP6NWO9Vdt+w3Y9/Rvuz0+xXd\n", + "1+o0sKVf0f1JAAEADuMGEADgMNPi4lkRbu9jRKI+uYi2qv2r179vM/uzvOvbyBT+ro9xWC06BbPi\n", + "8SSvZj2G6Amf5YhZi4A+6ZhVyb7+Zl7/W7fp3b513zOu2atLKCSAAACH+bgRUlXh7VUbsx6kW9V+\n", + "ttXHv3fhwm7Hr8XOi2hm9K2qOP/djDRhRZqx8yKk1e1f2bVf72ak45WLwKoWUWX6pMcQSQABAA4T\n", + "vqtcvSR9txq8J1g9ml3dPvvY+fs7I83euf0W2Z+fa0ONnWYNnjKD1vtIpJ5970ICCABwmKE71Fmp\n", + "39Pupnd2+rFc8f53bfP0c6FVdBU4/KT1/Hnid/bpTzEYeULAq9X9byEBBAA4zPZ3qN9ZPUpYXcNQ\n", + "KTNBWv05VYkm4DuvYn3aKrqd21/9Pnf19OPy9P6fbtZTADJVnXMSQACAwzzmL4E88a79U61IAI26\n", + "Yxy/fqv/Eg0/swr52sgq8qef8094juBOJIAAAIf5+Dvc3e1WA0jM7BrK6CrCT16FuKvTa2ijHJfz\n", + "zFpRPPvcWv37LwEEADhM+DmAn7yKb9f2oz55FfNsq/8SDjzN06+fIyTwz7PTMbcKGACAFG4AAQAO\n", + "I0o+XHQK99OmgGc8BmH11MLq9pnD5/w/mY8hO/1YUmf2n/KUAAIAHMZI5k3LA6eNAKkSfZBplWgR\n", + "+4x+rWifzyX149NJAAEADmNUQ8hIAuNBuGvt9BggCR7AGhJAAIDD/F7dAZ4nmiBJeea4+px2Ov47\n", + "9YU2T0nmn9LPK0/vP/uTAAIAHGb5qEINEFeePgLeqf879aXVJz17sYoaTBh3+vkvAQQAOMx2d7uf\n", + "OlK/cvoIBACYTwIIAHAYaRNAsdNmNoD9SQABAA5jJHqIpyQQVf18yvtfLXqcHGeAZ5AAAgAcxgh9\n", + "Y9IUqGUVPiu1nn9+C6ggAQQAOIwbQACAw4iS6WY6Avbku8nfnAt85/W8kAACABxm+ahAETbwKaQu\n", + "33NcYA8SQACAgxmJAQB8qPeZ1r9JAAEADvN7dQcAZlKPBiABBAA4jtEvkEa6BrCXq+uyBBAA4DBq\n", + "AIE0LamflPA8PnPYjwQQAAAAAAAA4GMsr8W4+1vA6kYA4Ax+8+dSAwgAcBh32ABAEynd55AAAgAc\n", + "xg0gAMBhxLcAlDJtCPuRAAIAHMZIDAB4nLvHyPEzCSAAAAAAAADAxzBf/sZqNSCb6wqM8/2poQYQ\n", + "AOAw7qQBgP8jdft8EkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n", + "AAAAAAAAPtSv1R2AE/zrr6///P2///1P3zsA1vrH6g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA\n", + "R/AnqeAw/iwdAP4UHADAYYz+Ab4hKQU+mQQQAAAAAAAAAAAAAAAAAAAAAGCp/wLfMhs/WbsQhAAA\n", + "AABJRU5ErkJggg==\n", + "\" transform=\"translate(2336, 1858)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -21969,7 +19494,7 @@ ], "cell_type": "code", "source": [ - "model = EFTfitterModel(parameters, measurements, correlations, nuisance_correlations)\n", + "model = EFTfitterModel(parameters, measurements, correlations, nuisances = nuisance_correlations)\n", "\n", "posterior = PosteriorMeasure(model)\n", "\n", @@ -22021,104 +19546,96 @@ "name": "stdout", "output_type": "stream", "text": [ - "┌ Info: Begin ranking of measurements\n", - "└ @ EFTfitter /home/cornelius/Projects/julia/EFTfitter.jl/src/ranking/ranking.jl:123\n", - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Trying to generate 4 viable MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:56\n", - "┌ Info: Selected 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:174\n", - "┌ Info: Begin tuning of 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:35\n", - "┌ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 2 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 3 finished, 4 chains, 4 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC tuning of 4 chains successful after 3 cycle(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:71\n", - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Trying to generate 4 viable MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:56\n", - "┌ Info: Selected 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:174\n", - "┌ Info: Begin tuning of 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:35\n", - "┌ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 2 finished, 4 chains, 4 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC tuning of 4 chains successful after 2 cycle(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:71\n", - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Trying to generate 4 viable MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:56\n", - "┌ Info: Selected 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:174\n", - "┌ Info: Begin tuning of 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:35\n", - "┌ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 2 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 3 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 4 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 5 finished, 4 chains, 4 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC tuning of 4 chains successful after 5 cycle(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:71\n", - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Trying to generate 4 viable MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:56\n", - "┌ Info: Selected 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:174\n", - "┌ Info: Begin tuning of 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:35\n", - "┌ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 2 finished, 4 chains, 4 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC tuning of 4 chains successful after 2 cycle(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:71\n", - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Trying to generate 4 viable MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:56\n", - "┌ Info: Selected 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:174\n", - "┌ Info: Begin tuning of 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:35\n", - "┌ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 2 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 3 finished, 4 chains, 4 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC tuning of 4 chains successful after 3 cycle(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:71\n" + "[ Info: Begin ranking of measurements\n", + "nui: NuisanceCorrelation(:syst, :Meas1, :Meas2, Uniform{Float64}(a=-1.0, b=1.0))\n", + "nui_k: ρ1\n", + "nui: NuisanceCorrelation(:syst, :MeasDist_bin1, :MeasDist_bin3, Truncated(Normal{Float64}(μ=0.5, σ=0.1); lower=-1.0, upper=1.0))\n", + "nui_k: ρ2\n", + "[ Info: MCMCChainPoolInit: trying to generate 4 viable MCMC chain(s).\n", + "[ Info: Selected 4 MCMC chain(s).\n", + "[ Info: Begin tuning of 4 MCMC chain(s).\n", + "[ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 2 finished, 4 chains, 1 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 3 finished, 4 chains, 1 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 4 finished, 4 chains, 1 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 5 finished, 4 chains, 1 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 6 finished, 4 chains, 1 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 7 finished, 4 chains, 1 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 8 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 9 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 10 finished, 4 chains, 4 tuned, 4 converged.\n", + "[ Info: MCMC tuning of 4 chains successful after 10 cycle(s).\n", + "[ Info: Running post-tuning stabilization steps for 4 MCMC chain(s).\n", + "[ Info: MCMCChainPoolInit: trying to generate 4 viable MCMC chain(s).\n", + "[ Info: Selected 4 MCMC chain(s).\n", + "[ Info: Begin tuning of 4 MCMC chain(s).\n", + "[ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 2 finished, 4 chains, 1 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 3 finished, 4 chains, 1 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 4 finished, 4 chains, 1 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 5 finished, 4 chains, 1 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 6 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 7 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 8 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 9 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 10 finished, 4 chains, 3 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 11 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 12 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 13 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 14 finished, 4 chains, 4 tuned, 4 converged.\n", + "[ Info: MCMC tuning of 4 chains successful after 14 cycle(s).\n", + "[ Info: Running post-tuning stabilization steps for 4 MCMC chain(s).\n", + "[ Info: MCMCChainPoolInit: trying to generate 4 viable MCMC chain(s).\n", + "[ Info: Selected 4 MCMC chain(s).\n", + "[ Info: Begin tuning of 4 MCMC chain(s).\n", + "[ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 2 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 3 finished, 4 chains, 4 tuned, 4 converged.\n", + "[ Info: MCMC tuning of 4 chains successful after 3 cycle(s).\n", + "[ Info: Running post-tuning stabilization steps for 4 MCMC chain(s).\n", + "[ Info: MCMCChainPoolInit: trying to generate 4 viable MCMC chain(s).\n", + "[ Info: Selected 4 MCMC chain(s).\n", + "[ Info: Begin tuning of 4 MCMC chain(s).\n", + "[ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 2 finished, 4 chains, 1 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 3 finished, 4 chains, 1 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 4 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 5 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 6 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 7 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 8 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 9 finished, 4 chains, 4 tuned, 4 converged.\n", + "[ Info: MCMC tuning of 4 chains successful after 9 cycle(s).\n", + "[ Info: Running post-tuning stabilization steps for 4 MCMC chain(s).\n", + "[ Info: MCMCChainPoolInit: trying to generate 4 viable MCMC chain(s).\n", + "[ Info: Selected 4 MCMC chain(s).\n", + "[ Info: Begin tuning of 4 MCMC chain(s).\n", + "[ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 2 finished, 4 chains, 0 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 3 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 4 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 5 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 6 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 7 finished, 4 chains, 3 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 8 finished, 4 chains, 3 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 9 finished, 4 chains, 3 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 10 finished, 4 chains, 3 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 11 finished, 4 chains, 3 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 12 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 13 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 14 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 15 finished, 4 chains, 3 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 16 finished, 4 chains, 3 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 17 finished, 4 chains, 4 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 18 finished, 4 chains, 4 tuned, 4 converged.\n", + "[ Info: MCMC tuning of 4 chains successful after 18 cycle(s).\n", + "[ Info: Running post-tuning stabilization steps for 4 MCMC chain(s).\n" ] }, { "output_type": "execute_result", "data": { - "text/plain": "EFTfitter.MeasurementRanks([:Meas1, :MeasDist_bin1, :Meas2, :MeasDist_bin3], [2.7570704834362316, 0.47045521036775545, 0.34062653274475296, -0.11294862772695285], EFTfitter.SumOfSmallestIntervals{Int64}\n p: Float64 0.9\n bins: Int64 200\n)" + "text/plain": "EFTfitter.MeasurementRanks([:Meas1, :MeasDist_bin1, :Meas2, :MeasDist_bin3], [2.345332257196664, 0.11993543179983858, 0.11825396825396817, -6.312090500754853e-15], SumOfSmallestIntervals{Int64}\n p: Float64 0.9\n bins: Int64 200\n)" }, "metadata": {}, "execution_count": 12 @@ -22145,237 +19662,113 @@ "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=1}", - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -22403,225 +19796,118 @@ "name": "stdout", "output_type": "stream", "text": [ - "┌ Info: Begin ranking of uncertainties\n", - "└ @ EFTfitter /home/cornelius/Projects/julia/EFTfitter.jl/src/ranking/ranking.jl:164\n", - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n" + "[ Info: Begin ranking of uncertainties\n", + "nui: NuisanceCorrelation(:syst, :Meas1, :Meas2, Uniform{Float64}(a=-1.0, b=1.0))\n", + "nui_k: ρ1\n", + "nui: NuisanceCorrelation(:syst, :MeasDist_bin1, :MeasDist_bin3, Truncated(Normal{Float64}(μ=0.5, σ=0.1); lower=-1.0, upper=1.0))\n", + "nui_k: ρ2\n" ] }, { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=1}", - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -22663,11 +19949,11 @@ "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.5.3" + "version": "1.9.1" }, "kernelspec": { - "name": "julia-1.5", - "display_name": "Julia 1.5.3", + "name": "julia-1.9", + "display_name": "Julia 1.9.1", "language": "julia" } }, diff --git a/examples/notebooks/BLUE.ipynb b/examples/notebooks/BLUE.ipynb index 683ad04..60e6b24 100644 --- a/examples/notebooks/BLUE.ipynb +++ b/examples/notebooks/BLUE.ipynb @@ -55,7 +55,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "ValueShapes.NamedTupleDist{(:τ,),Tuple{Distributions.Uniform{Float64}},Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}(\n_internal_distributions: (τ = Distributions.Uniform{Float64}(a=8.0, b=14.0),)\n_internal_shape: ValueShapes.NamedTupleShape{(:τ,),Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}((τ = ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}(ValueShapes.ScalarShape{Real}(), 0, 1),), 1)\n)\n" + "text/plain": "NamedTupleDist((τ = Uniform{Float64}(a=8.0, b=14.0),))" }, "metadata": {}, "execution_count": 2 @@ -108,7 +108,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "4×4 Array{Float64,2}:\n 2.74 1.15 0.86 1.31\n 1.15 1.67 0.82 1.32\n 0.86 0.82 2.12 1.05\n 1.31 1.32 1.05 2.93" + "text/plain": "4×4 Matrix{Float64}:\n 2.74 1.15 0.86 1.31\n 1.15 1.67 0.82 1.32\n 0.86 0.82 2.12 1.05\n 1.31 1.32 1.05 2.93" }, "metadata": {}, "execution_count": 4 @@ -137,7 +137,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "(stat = EFTfitter.Correlation([1.0 0.5376062677719541 0.35682497116489126 0.46234078289360164; 0.5376062677719541 1.0 0.4358004620316949 0.5967355144471027; 0.35682497116489126 0.4358004620316949 1.0 0.4212962160310593; 0.46234078289360164 0.5967355144471027 0.4212962160310593 1.0], true),)" + "text/plain": "(stat = Correlation{LinearAlgebra.Symmetric{Float64, Matrix{Float64}}}([1.0 0.5376062677719541 0.35682497116489126 0.46234078289360164; 0.5376062677719541 1.0 0.4358004620316949 0.5967355144471027; 0.35682497116489126 0.4358004620316949 1.0 0.4212962160310593; 0.46234078289360164 0.5967355144471027 0.4212962160310593 1.0], true),)" }, "metadata": {}, "execution_count": 5 @@ -191,30 +191,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Trying to generate 4 viable MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:56\n", - "┌ Info: Selected 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:174\n", - "┌ Info: Begin tuning of 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:35\n", - "┌ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 2 finished, 4 chains, 0 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 3 finished, 4 chains, 4 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC tuning of 4 chains successful after 3 cycle(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:71\n" + "[ Info: MCMCChainPoolInit: trying to generate 4 viable MCMC chain(s).\n", + "[ Info: Selected 4 MCMC chain(s).\n", + "[ Info: Begin tuning of 4 MCMC chain(s).\n", + "[ Info: MCMC Tuning cycle 1 finished, 4 chains, 4 tuned, 4 converged.\n", + "[ Info: MCMC tuning of 4 chains successful after 1 cycle(s).\n", + "[ Info: Running post-tuning stabilization steps for 4 MCMC chain(s).\n" ] }, { "output_type": "execute_result", "data": { - "text/plain": "1291354-element StructArray(::ValueShapes.ShapedAsNTArray{NamedTuple{(:τ,),Tuple{Float64}},1,ArraysOfArrays.ArrayOfSimilarArrays{Float64,1,1,2,ElasticArrays.ElasticArray{Float64,2,1,Array{Float64,1}}},ValueShapes.NamedTupleShape{(:τ,),Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}}, ::Array{Float64,1}, ::Array{Int64,1}, StructArray(::Array{Int32,1}, ::Array{Int32,1}, ::Array{Int64,1}, ::Array{Int64,1}), ::Array{Nothing,1}) with eltype BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}:\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 11.580451743448599,), -7.94182231363417, 5, BAT.MCMCSampleID(8, 4, 0, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 11.317447751934166,), -7.8235686644533695, 1, BAT.MCMCSampleID(8, 4, 5, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 11.842818449147352,), -8.166970915826278, 1, BAT.MCMCSampleID(8, 4, 6, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 11.244241467183485,), -7.809791509383995, 1, BAT.MCMCSampleID(8, 4, 7, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 12.503860389345547,), -9.208884774702598, 2, BAT.MCMCSampleID(8, 4, 8, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 12.006854280496809,), -8.362125479451034, 1, BAT.MCMCSampleID(8, 4, 10, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 10.945952737503209,), -7.839820490486886, 1, BAT.MCMCSampleID(8, 4, 11, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 10.870803207924308,), -7.869207644848254, 6, BAT.MCMCSampleID(8, 4, 12, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 11.360582711932489,), -7.835588695559164, 9, BAT.MCMCSampleID(8, 4, 18, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 10.495691807342531,), -8.14722637292226, 2, BAT.MCMCSampleID(8, 4, 27, 1), nothing)\n ⋮\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 10.665652237589125,), -7.9941456567098905, 1, BAT.MCMCSampleID(20, 4, 999958, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 10.762047410470686,), -7.92728870401696, 16, BAT.MCMCSampleID(20, 4, 999959, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 10.474506888014012,), -8.169456032937548, 3, BAT.MCMCSampleID(20, 4, 999975, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 9.97177777038716,), -8.90178180219304, 1, BAT.MCMCSampleID(20, 4, 999978, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 11.588084783930794,), -7.946860645824977, 3, BAT.MCMCSampleID(20, 4, 999979, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 11.79272844405585,), -8.115718477390288, 1, BAT.MCMCSampleID(20, 4, 999982, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 10.962428407863293,), -7.834551519521218, 1, BAT.MCMCSampleID(20, 4, 999983, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 12.338051590747323,), -8.883691838633222, 6, BAT.MCMCSampleID(20, 4, 999984, 1), nothing)\n BAT.DensitySample{NamedTuple{(:τ,),Tuple{Float64}},Float64,Int64,BAT.MCMCSampleID,Nothing}((τ = 10.274256722184335,), -8.41406138157286, 4, BAT.MCMCSampleID(20, 4, 999990, 1), nothing)" + "text/plain": "DensitySampleVector, StructArray with 5 columns and 1251455 rows:\n v logd weight info aux\n ┌─────────────────────────────────────────────────────────────────────\n 1 │ (τ = 11.0342,) -4.80414 4 MCMCSampleID(4, 4, 0, 1) nothing\n 2 │ (τ = 10.615,) -4.91343 2 MCMCSampleID(4, 4, 4, 1) nothing\n 3 │ (τ = 10.5756,) -4.93072 7 MCMCSampleID(4, 4, 6, 1) nothing\n 4 │ (τ = 10.6357,) -4.90482 1 MCMCSampleID(4, 4, 13, 1) nothing\n 5 │ (τ = 11.949,) -5.04013 10 MCMCSampleID(4, 4, 14, 1) nothing\n 6 │ (τ = 10.6858,) -4.88535 2 MCMCSampleID(4, 4, 24, 1) nothing\n 7 │ (τ = 10.5544,) -4.94053 2 MCMCSampleID(4, 4, 26, 1) nothing\n 8 │ (τ = 11.9003,) -5.01118 6 MCMCSampleID(4, 4, 28, 1) nothing\n 9 │ (τ = 11.2322,) -4.80004 1 MCMCSampleID(4, 4, 34, 1) nothing\n 10 │ (τ = 10.6518,) -4.89835 1 MCMCSampleID(4, 4, 35, 1) nothing\n 11 │ (τ = 10.8776,) -4.82897 3 MCMCSampleID(4, 4, 36, 1) nothing\n 12 │ (τ = 12.2734,) -5.28014 1 MCMCSampleID(4, 4, 39, 1) nothing\n 13 │ (τ = 10.276,) -5.10173 3 MCMCSampleID(4, 4, 40, 1) nothing\n 14 │ (τ = 9.88828,) -5.42662 1 MCMCSampleID(4, 4, 43, 1) nothing\n 15 │ (τ = 11.8455,) -4.98077 5 MCMCSampleID(4, 4, 44, 1) nothing\n 16 │ (τ = 10.974,) -4.81142 1 MCMCSampleID(4, 4, 49, 1) nothing\n 17 │ (τ = 10.7406,) -4.86632 1 MCMCSampleID(4, 4, 50, 1) nothing\n ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮" }, "metadata": {}, "execution_count": 7 @@ -241,806 +229,136 @@ "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=6}", - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, "metadata": {}, @@ -1067,8 +385,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mode: fill(11.159830807423306)\n", - "Mean: fill(11.157048014558068) ± fill(0.800971609231456)\n" + "Mode: 11.159830552626662\n", + "Mean: 11.151364198549913 ± 1.0944477422710148\n" ] } ], @@ -1093,7 +411,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "BLUE: 11.159830517412002 ± 1.2860408471758553\n", + "BLUE: 11.159830517412002 ± 1.1340374099542991\n", "BLUE weights: [0.14507475718273513, 0.4695773808477563, 0.3472970547995881, 0.03805080716992032]\n" ] } @@ -1123,11 +441,11 @@ "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.5.3" + "version": "1.9.1" }, "kernelspec": { - "name": "julia-1.5", - "display_name": "Julia 1.5.3", + "name": "julia-1.9", + "display_name": "Julia 1.9.1", "language": "julia" } }, diff --git a/examples/notebooks/EmptyTemplate.ipynb b/examples/notebooks/EmptyTemplate.ipynb index 4c218a9..61c9185 100644 --- a/examples/notebooks/EmptyTemplate.ipynb +++ b/examples/notebooks/EmptyTemplate.ipynb @@ -32,7 +32,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "ValueShapes.NamedTupleDist{(:p1,),Tuple{Distributions.Uniform{Float64}},Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}(\n_internal_distributions: (p1 = Distributions.Uniform{Float64}(a=-2.0, b=2.0),)\n_internal_shape: ValueShapes.NamedTupleShape{(:p1,),Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}((p1 = ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}(ValueShapes.ScalarShape{Real}(), 0, 1),), 1)\n)\n" + "text/plain": "NamedTupleDist((p1 = Uniform{Float64}(a=-2.0, b=2.0),))" }, "metadata": {}, "execution_count": 2 @@ -40,7 +40,7 @@ ], "cell_type": "code", "source": [ - "parameters = BAT.NamedTupleDist(\n", + "parameters = BAT.distprod(\n", " p1 = -2..2,\n", ")" ], @@ -86,7 +86,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "(Meas1 = EFTfitter.Measurement(EFTfitter.Observable(Main.##434.observable1, -Inf, Inf), 0.0, (unc1 = 0.1,), true),)" + "text/plain": "(Meas1 = Measurement(Observable\n prediction: observable1 (function of type typeof(Main.var\"##369\".observable1))\n min: Float64 -Inf\n max: Float64 Inf\n weight: Float64 1.0\n, 0.0, (unc1 = 0.1,), true),)" }, "metadata": {}, "execution_count": 4 @@ -97,7 +97,7 @@ "measurements = (\n", " Meas1 = Measurement(observable1, 0.0, uncertainties = (unc1 = 0.1,), active=true),\n", "\n", - " #MeasDist = MeasurementDistribution(obs_array, values_array, uncertainties = (unc1 = unc1_array,), active=false),\n", + " #MeasDist = BinnedMeasurement(obs_array, values_array, uncertainties = (unc1 = unc1_array,), active=false),\n", ")" ], "metadata": {}, @@ -115,7 +115,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "(unc1 = EFTfitter.NoCorrelation\n active: Bool true\n,)" + "text/plain": "(unc1 = NoCorrelation\n active: Bool true\n,)" }, "metadata": {}, "execution_count": 5 @@ -146,7 +146,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "EFTfitter.EFTfitterModel(ValueShapes.NamedTupleDist{(:p1,),Tuple{Distributions.Uniform{Float64}},Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}(\n_internal_distributions: (p1 = Distributions.Uniform{Float64}(a=-2.0, b=2.0),)\n_internal_shape: ValueShapes.NamedTupleShape{(:p1,),Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}((p1 = ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}(ValueShapes.ScalarShape{Real}(), 0, 1),), 1)\n)\n, (Meas1 = EFTfitter.Measurement(EFTfitter.Observable(Main.##434.observable1, -Inf, Inf), 0.0, (unc1 = 0.1,), true),), NamedTuple(), (unc1 = EFTfitter.Correlation([1.0], true),), nothing)" + "text/plain": "EFTfitterModel(NamedTupleDist((p1 = Uniform{Float64}(a=-2.0, b=2.0),)), (Meas1 = Measurement(Observable\n prediction: observable1 (function of type typeof(Main.var\"##369\".observable1))\n min: Float64 -Inf\n max: Float64 Inf\n weight: Float64 1.0\n, 0.0, (unc1 = 0.1,), true),), NamedTuple(), nothing, (unc1 = Correlation{LinearAlgebra.Symmetric{Float64, Matrix{Float64}}}([1.0;;], true),), nothing, Matrix{Float64})" }, "metadata": {}, "execution_count": 6 @@ -188,26 +188,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Trying to generate 4 viable MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:56\n", - "┌ Info: Selected 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:174\n", - "┌ Info: Begin tuning of 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:35\n", - "┌ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 2 finished, 4 chains, 1 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 3 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 4 finished, 4 chains, 4 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC tuning of 4 chains successful after 4 cycle(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:71\n" + "[ Info: MCMCChainPoolInit: trying to generate 4 viable MCMC chain(s).\n", + "[ Info: Selected 4 MCMC chain(s).\n", + "[ Info: Begin tuning of 4 MCMC chain(s).\n", + "[ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 2 finished, 4 chains, 1 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 3 finished, 4 chains, 4 tuned, 4 converged.\n", + "[ Info: MCMC tuning of 4 chains successful after 3 cycle(s).\n", + "[ Info: Running post-tuning stabilization steps for 4 MCMC chain(s).\n" ] } ], @@ -222,16 +210,25 @@ { "cell_type": "markdown", "source": [ - "create and display a `SampledDensity` object for a quick overview of results:" + "let's get a quick overview of results:" ], "metadata": {} }, { - "outputs": [], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "\u001b[1m Sampling result\u001b[22m\n\u001b[1m –––––––––––––––––\u001b[22m\n\n • Total number of samples: 134892\n\n • Total weight of samples: 399992\n\n • Effective sample size: between 57389 and 57389\n\n\u001b[1m Marginals\u001b[22m\n\u001b[1m -----------\u001b[22m\n\n Parameter Mean Std. dev. Gobal mode Marg. mode Cred. interval Histogram \n ––––––––– –––––––––––– ––––––––– –––––––––– –––––––––– –––––––––––––––––––––– ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n p1 -0.000306637 0.0998748 1.11995e-6 0.025 -0.0951686 .. 0.104682 ⠀⠀-0.418[⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▂▃▄▅▆▇█████▆▅▄▃▂▁▁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀[0.447⠀⠀⠀", + "text/markdown": "### Sampling result\n\n * Total number of samples: 134892\n * Total weight of samples: 399992\n * Effective sample size: between 57389 and 57389\n\n#### Marginals\n\n| Parameter | Mean | Std. dev. | Gobal mode | Marg. mode | Cred. interval | Histogram |\n|:--------- |:------------ |:--------- |:---------- |:---------- |:----------------------:|:---------------------------------------------------------- |\n| p1 | -0.000306637 | 0.0998748 | 1.11995e-6 | 0.025 | -0.0951686 .. 0.104682 | ⠀⠀-0.418[⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▂▃▄▅▆▇█████▆▅▄▃▂▁▁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀[0.447⠀⠀⠀ |\n" + }, + "metadata": {}, + "execution_count": 9 + } + ], "cell_type": "code", "source": [ - "sd = SampledDensity(posterior, samples)\n", - "display(sd)" + "bat_report(samples)" ], "metadata": {}, "execution_count": 9 @@ -249,753 +246,107 @@ "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=4}", - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -1026,11 +377,11 @@ "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.5.3" + "version": "1.9.1" }, "kernelspec": { - "name": "julia-1.5", - "display_name": "Julia 1.5.3", + "name": "julia-1.9", + "display_name": "Julia 1.9.1", "language": "julia" } }, diff --git a/examples/notebooks/Tutorial.ipynb b/examples/notebooks/Tutorial.ipynb index 06a943c..57705b7 100644 --- a/examples/notebooks/Tutorial.ipynb +++ b/examples/notebooks/Tutorial.ipynb @@ -69,7 +69,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "ValueShapes.NamedTupleDist{(:C1, :C2),Tuple{Distributions.Uniform{Float64},Distributions.Normal{Float64}},Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}},ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}(\n_internal_distributions: (C1 = Distributions.Uniform{Float64}(a=-3.0, b=3.0), C2 = Distributions.Normal{Float64}(μ=0.0, σ=0.5))\n_internal_shape: ValueShapes.NamedTupleShape{(:C1, :C2),Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}},ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}((C1 = ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}(ValueShapes.ScalarShape{Real}(), 0, 1), C2 = ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}(ValueShapes.ScalarShape{Real}(), 1, 1)), 2)\n)\n" + "text/plain": "NamedTupleDist((C1 = Uniform{Float64}(a=-3.0, b=3.0), C2 = Normal{Float64}(μ=0.0, σ=0.5)))" }, "metadata": {}, "execution_count": 2 @@ -77,7 +77,7 @@ ], "cell_type": "code", "source": [ - "parameters = BAT.NamedTupleDist(\n", + "parameters = BAT.distprod(\n", " C1 = -3..3, # short for: Uniform(-3, 3)\n", " C2 = Normal(0, 0.5) # Normal distribution\n", ")" @@ -162,7 +162,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "3-element Array{Function,1}:\n diff_xsec_bin1 (generic function with 1 method)\n diff_xsec_bin2 (generic function with 1 method)\n diff_xsec_bin3 (generic function with 1 method)" + "text/plain": "3-element Vector{Function}:\n diff_xsec_bin1 (generic function with 1 method)\n diff_xsec_bin2 (generic function with 1 method)\n diff_xsec_bin3 (generic function with 1 method)" }, "metadata": {}, "execution_count": 4 @@ -209,7 +209,7 @@ "We can now enter measurements of the observables.\n", "This is done by defining a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types)\n", "consisting of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement)\n", - "and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution) objects." + "and [`BinnedMeasurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.BinnedMeasurement) objects." ], "metadata": {} }, @@ -222,7 +222,7 @@ "object or as a `Function`. When using the latter, the observable is assumed to be unconstrained.\n", "The uncertainties are passed as a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types).\n", "Each measurement has to provide uncertainty values for all of the (active) uncertainty\n", - "types (see next section on `Correlations`). For a `MeasurementDistribution`,\n", + "types (see next section on `Correlations`). For a `BinnedMeasurement`,\n", "the corresponding inputs have to be passed as `Vectors`, where each element\n", "represents one bin of the distribution." ], @@ -232,7 +232,7 @@ "cell_type": "markdown", "source": [ "A `Measurement` can be excluded from the model by setting the switch `active=false`.\n", - "For a `MeasurementDistribution`, the keyword `active` accepts `true` or `false`\n", + "For a `BinnedMeasurement`, the keyword `active` accepts `true` or `false`\n", "to (de)activate the whole distribution or a vector of booleans for (de)activating only certain bins." ], "metadata": {} @@ -242,7 +242,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "(Meas1 = EFTfitter.Measurement(EFTfitter.Observable(Main.##402.xsec1, -Inf, Inf), 21.6, (stat = 0.8, syst = 1.8, another_unc = 2.3), true), Meas2 = EFTfitter.Measurement(EFTfitter.Observable(Main.##402.xsec2, 0.0, Inf), 1.9, (stat = 0.6, syst = 0.9, another_unc = 1.1), true), MeasDist = EFTfitter.MeasurementDistribution(EFTfitter.Observable[EFTfitter.Observable(Main.##402.diff_xsec_bin1, -Inf, Inf), EFTfitter.Observable(Main.##402.diff_xsec_bin2, -Inf, Inf), EFTfitter.Observable(Main.##402.diff_xsec_bin3, -Inf, Inf)], [1.9, 2.93, 4.4], (stat = [0.7, 1.1, 1.2], syst = [0.7, 0.8, 1.3], another_unc = [1.0, 1.2, 1.9]), Bool[1, 0, 1], [:bin1, :bin2, :bin3]))" + "text/plain": "(Meas1 = Measurement(Observable\n prediction: xsec1 (function of type typeof(Main.var\"##339\".xsec1))\n min: Float64 -Inf\n max: Float64 Inf\n weight: Float64 1.0\n, 21.6, (stat = 0.8, syst = 1.8, another_unc = 2.3), true), Meas2 = Measurement(Observable\n prediction: xsec2 (function of type typeof(Main.var\"##339\".xsec2))\n min: Int64 0\n max: Float64 Inf\n weight: Float64 1.0\n, 1.9, (stat = 0.6, syst = 0.9, another_unc = 1.1), true), MeasDist = BinnedMeasurement(Observable[Observable(Main.var\"##339\".diff_xsec_bin1, -Inf, Inf, 1.0), Observable(Main.var\"##339\".diff_xsec_bin2, -Inf, Inf, 1.0), Observable(Main.var\"##339\".diff_xsec_bin3, -Inf, Inf, 1.0)], [1.9, 2.93, 4.4], (stat = [0.7, 1.1, 1.2], syst = [0.7, 0.8, 1.3], another_unc = [1.0, 1.2, 1.9]), Bool[1, 0, 1], [:bin1, :bin2, :bin3]))" }, "metadata": {}, "execution_count": 5 @@ -257,7 +257,7 @@ " Meas2 = Measurement(Observable(xsec2, min=0), 1.9,\n", " uncertainties = (stat=0.6, syst=0.9, another_unc=1.1), active=true),\n", "\n", - " MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4],\n", + " MeasDist = BinnedMeasurement(diff_xsec, [1.9, 2.93, 4.4],\n", " uncertainties = (stat = [0.7, 1.1, 1.2], syst= [0.7, 0.8, 1.3], another_unc = [1.0, 1.2, 1.9]),\n", " active=[true, false, true]), # `active = false`: exclude all bins from fit, `active = [true, true, false]`: exclude only third bin from fit\n", ")" @@ -269,7 +269,7 @@ "cell_type": "markdown", "source": [ "Further information on the constructors see the API documentation of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement)\n", - "and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution)." + "and [`BinnedMeasurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.BinnedMeasurement)." ], "metadata": {} }, @@ -291,10 +291,10 @@ "of [`Correlation`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Correlation)\n", "objects that contain the corresponding correlation matrices.\n", "The correlation matrix for each type of uncertainty needs to have a size\n", - "of ``N \\times N``, where ``N`` is the number of measurements, counting each bin of a distribution.\n", + "of $N \\times N$, where $N$ is the number of measurements, counting each bin of a distribution.\n", "When a certain type of uncertainty should not be considered, it can be deactivated\n", "by setting `active = false`. This means that the uncertainty values given in the\n", - "corresponding `Measurement` and `MeasurementDistribution` objects will not be used." + "corresponding `Measurement` and `BinnedMeasurement` objects will not be used." ], "metadata": {} }, @@ -314,8 +314,8 @@ "With the function `to_correlation_matrix`, it is possible to enter a correlation\n", "matrix by simply specifying the names of the measurements that should be correlated\n", "and the value of the corresponding correlation coefficient.\n", - "When using a `MeasurementDistribution`, the inter-bin correlations can also be\n", - "entered by passing a matrix. By appending `_binX` to the name of a `MeasurementDistribution`,\n", + "When using a `BinnedMeasurement`, the inter-bin correlations can also be\n", + "entered by passing a matrix. By appending `_binX` to the name of a `BinnedMeasurement`,\n", "the Xth bin of the distribution can be accessed.\n", "Note: This function is evaluated from top to bottom, so if you overwrite a\n", "specific correlation value, the last value entered will be used." @@ -327,7 +327,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "5×5 Array{Float64,2}:\n 1.0 0.4 0.1 0.1 0.1\n 0.4 1.0 0.0 0.0 0.0\n 0.1 0.0 1.0 0.5 0.0\n 0.1 0.0 0.5 1.0 0.3\n 0.1 0.0 0.0 0.3 1.0" + "text/plain": "5×5 Matrix{Float64}:\n 1.0 0.4 0.1 0.1 0.1\n 0.4 1.0 0.0 0.0 0.0\n 0.1 0.0 1.0 0.5 0.0\n 0.1 0.0 0.5 1.0 0.3\n 0.1 0.0 0.0 0.3 1.0" }, "metadata": {}, "execution_count": 6 @@ -354,7 +354,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "(stat = EFTfitter.NoCorrelation\n active: Bool true\n, syst = EFTfitter.Correlation([1.0 0.5 … 0.2 0.2; 0.5 1.0 … 0.2 0.2; … ; 0.2 0.2 … 1.0 0.2; 0.2 0.2 … 0.2 1.0], false), another_unc = EFTfitter.Correlation([1.0 0.4 … 0.1 0.1; 0.4 1.0 … 0.0 0.0; … ; 0.1 0.0 … 1.0 0.3; 0.1 0.0 … 0.3 1.0], true))" + "text/plain": "(stat = NoCorrelation\n active: Bool true\n, syst = Correlation{LinearAlgebra.Symmetric{Float64, Matrix{Float64}}}([1.0 0.5 … 0.2 0.2; 0.5 1.0 … 0.2 0.2; … ; 0.2 0.2 … 1.0 0.2; 0.2 0.2 … 0.2 1.0], false), another_unc = Correlation{LinearAlgebra.Symmetric{Float64, Matrix{Float64}}}([1.0 0.4 … 0.1 0.1; 0.4 1.0 … 0.0 0.0; … ; 0.1 0.0 … 1.0 0.3; 0.1 0.0 … 0.3 1.0], true))" }, "metadata": {}, "execution_count": 7 @@ -398,7 +398,7 @@ { "output_type": "execute_result", "data": { - "text/plain": "EFTfitter.EFTfitterModel(ValueShapes.NamedTupleDist{(:C1, :C2),Tuple{Distributions.Uniform{Float64},Distributions.Normal{Float64}},Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}},ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}(\n_internal_distributions: (C1 = Distributions.Uniform{Float64}(a=-3.0, b=3.0), C2 = Distributions.Normal{Float64}(μ=0.0, σ=0.5))\n_internal_shape: ValueShapes.NamedTupleShape{(:C1, :C2),Tuple{ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}},ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}}}((C1 = ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}(ValueShapes.ScalarShape{Real}(), 0, 1), C2 = ValueShapes.ValueAccessor{ValueShapes.ScalarShape{Real}}(ValueShapes.ScalarShape{Real}(), 1, 1)), 2)\n)\n, (Meas1 = EFTfitter.Measurement(EFTfitter.Observable(Main.##402.xsec1, -Inf, Inf), 21.6, (stat = 0.8, another_unc = 2.3), true), Meas2 = EFTfitter.Measurement(EFTfitter.Observable(Main.##402.xsec2, 0.0, Inf), 1.9, (stat = 0.6, another_unc = 1.1), true), MeasDist_bin1 = EFTfitter.Measurement(EFTfitter.Observable(Main.##402.diff_xsec_bin1, -Inf, Inf), 1.9, (stat = 0.7, another_unc = 1.0), true), MeasDist_bin3 = EFTfitter.Measurement(EFTfitter.Observable(Main.##402.diff_xsec_bin3, -Inf, Inf), 4.4, (stat = 1.2, another_unc = 1.9), true)), (MeasDist = EFTfitter.MeasurementDistribution(EFTfitter.Observable[EFTfitter.Observable(Main.##402.diff_xsec_bin1, -Inf, Inf), EFTfitter.Observable(Main.##402.diff_xsec_bin3, -Inf, Inf)], [1.9, 4.4], (stat = [0.7, 1.2], another_unc = [1.0, 1.9]), Bool[1, 1], [:bin1, :bin3]),), (stat = EFTfitter.Correlation([1.0 0.0 0.0 0.0; 0.0 1.0 0.0 0.0; 0.0 0.0 1.0 0.0; 0.0 0.0 0.0 1.0], true), another_unc = EFTfitter.Correlation([1.0 0.4 0.1 0.1; 0.4 1.0 0.0 0.0; 0.1 0.0 1.0 0.0; 0.1 0.0 0.0 1.0], true)), nothing)" + "text/plain": "EFTfitterModel(NamedTupleDist((C1 = Uniform{Float64}(a=-3.0, b=3.0), C2 = Normal{Float64}(μ=0.0, σ=0.5))), (Meas1 = Measurement(Observable\n prediction: xsec1 (function of type typeof(Main.var\"##339\".xsec1))\n min: Float64 -Inf\n max: Float64 Inf\n weight: Float64 1.0\n, 21.6, (stat = 0.8, another_unc = 2.3), true), Meas2 = Measurement(Observable\n prediction: xsec2 (function of type typeof(Main.var\"##339\".xsec2))\n min: Int64 0\n max: Float64 Inf\n weight: Float64 1.0\n, 1.9, (stat = 0.6, another_unc = 1.1), true), MeasDist_bin1 = Measurement(Observable\n prediction: diff_xsec_bin1 (function of type typeof(Main.var\"##339\".diff_xsec_bin1))\n min: Float64 -Inf\n max: Float64 Inf\n weight: Float64 1.0\n, 1.9, (stat = 0.7, another_unc = 1.0), true), MeasDist_bin3 = Measurement(Observable\n prediction: diff_xsec_bin3 (function of type typeof(Main.var\"##339\".diff_xsec_bin3))\n min: Float64 -Inf\n max: Float64 Inf\n weight: Float64 1.0\n, 4.4, (stat = 1.2, another_unc = 1.9), true)), (MeasDist = BinnedMeasurement(Observable[Observable(Main.var\"##339\".diff_xsec_bin1, -Inf, Inf, 1.0), Observable(Main.var\"##339\".diff_xsec_bin3, -Inf, Inf, 1.0)], [1.9, 4.4], (stat = [0.7, 1.2], another_unc = [1.0, 1.9]), Bool[1, 1], [:bin1, :bin3]),), nothing, (stat = Correlation{LinearAlgebra.Symmetric{Float64, Matrix{Float64}}}([1.0 0.0 0.0 0.0; 0.0 1.0 0.0 0.0; 0.0 0.0 1.0 0.0; 0.0 0.0 0.0 1.0], true), another_unc = Correlation{LinearAlgebra.Symmetric{Float64, Matrix{Float64}}}([1.0 0.4 0.1 0.1; 0.4 1.0 0.0 0.0; 0.1 0.0 1.0 0.0; 0.1 0.0 0.0 1.0], true)), nothing, Matrix{Float64})" }, "metadata": {}, "execution_count": 8 @@ -425,32 +425,29 @@ "name": "stdout", "output_type": "stream", "text": [ - "┌ Info: Initializing new RNG of type Random123.Philox4x{UInt64,10}\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Using tranform algorithm BAT.PriorSubstitution()\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/algotypes/bat_default.jl:44\n", - "┌ Info: Trying to generate 4 viable MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:56\n", - "┌ Info: Selected 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/chain_pool_init.jl:174\n", - "┌ Info: Begin tuning of 4 MCMC chain(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:35\n", - "┌ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 2 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 3 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 4 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 5 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 6 finished, 4 chains, 3 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC Tuning cycle 7 finished, 4 chains, 4 tuned, 4 converged.\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:65\n", - "┌ Info: MCMC tuning of 4 chains successful after 7 cycle(s).\n", - "└ @ BAT /home/cornelius/Projects/julia/BAT.jl/src/samplers/mcmc/multi_cycle_burnin.jl:71\n" + "[ Info: MCMCChainPoolInit: trying to generate 4 viable MCMC chain(s).\n", + "[ Info: Selected 4 MCMC chain(s).\n", + "[ Info: Begin tuning of 4 MCMC chain(s).\n", + "[ Info: MCMC Tuning cycle 1 finished, 4 chains, 0 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 2 finished, 4 chains, 0 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 3 finished, 4 chains, 0 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 4 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 5 finished, 4 chains, 2 tuned, 0 converged.\n", + "[ Info: MCMC Tuning cycle 6 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 7 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 8 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 9 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 10 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 11 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 12 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 13 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 14 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 15 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 16 finished, 4 chains, 2 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 17 finished, 4 chains, 3 tuned, 4 converged.\n", + "[ Info: MCMC Tuning cycle 18 finished, 4 chains, 4 tuned, 4 converged.\n", + "[ Info: MCMC tuning of 4 chains successful after 18 cycle(s).\n", + "[ Info: Running post-tuning stabilization steps for 4 MCMC chain(s).\n" ] } ], @@ -476,17 +473,26 @@ { "cell_type": "markdown", "source": [ - "We can then inspect the results of the sampling using BAT.jl's `SampledDensity`,\n", + "We can then inspect the results of the sampling using BAT.jl's `bat_report`,\n", "giving a summary of the sampling and the results of the model parameters." ], "metadata": {} }, { - "outputs": [], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "\u001b[1m Sampling result\u001b[22m\n\u001b[1m –––––––––––––––––\u001b[22m\n\n • Total number of samples: 127947\n\n • Total weight of samples: 399998\n\n • Effective sample size: between 12062 and 12096\n\n\u001b[1m Marginals\u001b[22m\n\u001b[1m -----------\u001b[22m\n\n Parameter Mean Std. dev. Gobal mode Marg. mode Cred. interval Histogram \n ––––––––– ––––––––– ––––––––– –––––––––– –––––––––– –––––––––––––––––––––––– ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n C1 0.882258 0.413107 0.818934 0.85 0.411998 .. 1.22798 ⠀⠀-0.414[⠀⠀⠀⠀⠀⠀▁▁▂▄▅▆▇██████▇▆▅▄▃▂▂▁▁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀[2.7⠀⠀⠀⠀⠀\n C2 0.0118892 0.0252422 0.0156424 0.0125 -0.00942632 .. 0.0406642 ⠀⠀-0.109[⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▁▂▂▃▄▅▆▇█████▇▅▄▃▂▁⠀⠀⠀⠀⠀⠀⠀[0.0965⠀⠀", + "text/markdown": "### Sampling result\n\n * Total number of samples: 127947\n * Total weight of samples: 399998\n * Effective sample size: between 12062 and 12096\n\n#### Marginals\n\n| Parameter | Mean | Std. dev. | Gobal mode | Marg. mode | Cred. interval | Histogram |\n|:--------- |:--------- |:--------- |:---------- |:---------- |:------------------------:|:---------------------------------------------------------- |\n| C1 | 0.882258 | 0.413107 | 0.818934 | 0.85 | 0.411998 .. 1.22798 | ⠀⠀-0.414[⠀⠀⠀⠀⠀⠀▁▁▂▄▅▆▇██████▇▆▅▄▃▂▂▁▁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀[2.7⠀⠀⠀⠀⠀ |\n| C2 | 0.0118892 | 0.0252422 | 0.0156424 | 0.0125 | -0.00942632 .. 0.0406642 | ⠀⠀-0.109[⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▁▂▂▃▄▅▆▇█████▇▅▄▃▂▁⠀⠀⠀⠀⠀⠀⠀[0.0965⠀⠀ |\n" + }, + "metadata": {}, + "execution_count": 10 + } + ], "cell_type": "code", "source": [ - "sd = SampledDensity(posterior, samples)\n", - "display(sd)" + "bat_report(samples)" ], "metadata": {}, "execution_count": 10 @@ -505,8 +511,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "lower interval edges: [0.38]\n", - "upper interval edges: [1.32]\n" + "lower interval edges: [0.22]\n", + "upper interval edges: [1.5799999999999998]\n" ] } ], @@ -542,1286 +548,1062 @@ "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=15}", - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAWgOcPbGA9CgzAAAAAElFTkSu\n", + "QmCC\n", + "\" transform=\"translate(345, 1275)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAWgOcPbGA9CgzAAAAAElFTkSu\n", + "QmCC\n", + "\" transform=\"translate(345, 1275)\"/>\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -4224,197 +3016,89 @@ "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=2}", - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -4454,11 +3138,11 @@ "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.5.3" + "version": "1.9.1" }, "kernelspec": { - "name": "julia-1.5", - "display_name": "Julia 1.5.3", + "name": "julia-1.9", + "display_name": "Julia 1.9.1", "language": "julia" } }, diff --git a/examples/tutorial/plotting.jl b/examples/tutorial/plotting.jl index 4bf2f5b..1f02230 100644 --- a/examples/tutorial/plotting.jl +++ b/examples/tutorial/plotting.jl @@ -1,4 +1,5 @@ # EFTfitter.jl - Plotting Tutorial + # EFTfitter includes several recipes for plotting its datatypes # using [Plots.jl](http://docs.juliaplots.org/latest/) using EFTfitter @@ -49,7 +50,10 @@ for meas in get_measurements(model) end p -# When plotting observables, the default title contains the values of the fixed# parameters. In case the title is too long for one line, linebreaks can be inserted# using the keyword `titlewidth`. e.g.: +# When plotting observables, the default title contains the values of the fixed +# parameters. In case the title is too long for one line, linebreaks can be inserted +# using the keyword `titlewidth`. e.g.: + plot(get_observables(model).xsec1, (C1=-10:0.01:10, C2=0, C3=100, C4=200), titlewidth=13) # ---------- Plotting Measurements ------------------------- @@ -71,8 +75,8 @@ plot!(get_measurements(model), :Meas1, uncertainties=(:stat, :another_unc)) # When mutliple types of uncertainties are given, the sum of the squares is used as the total uncertainty. # By default, all uncertainties included in the `EFTfitterModel` are used. -# ---------- Plotting MeasurementDistributions ------------------------- -# `MeasurementDistribution`s can be plotted for fixed parameters: +# ---------- Plotting BinnedMeasurements ------------------------- +# `BinnedMeasurement`s can be plotted for fixed parameters: plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) plot!(get_measurement_distributions(model), :MeasDist) @@ -80,7 +84,7 @@ plot!(get_measurement_distributions(model), :MeasDist) plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) plot!(get_measurement_distributions(model), :MeasDist, st=:scatter) -# Also for `MeasurementDistribution`s the uncertainty types to be plotted can be specified. +# Also for `BinnedMeasurement`s the uncertainty types to be plotted can be specified. # The names of the bins can be customized using the `bin_names` keyword. plot(get_measurement_distributions(model).MeasDist.observable, (C1=1.2, C2=0)) plot!(get_measurement_distributions(model), :MeasDist, st=:scatter, uncertainties=(:stat,), bin_names=("First bin", "Second bin")) @@ -108,4 +112,3 @@ p = plot(samples, 0.9, bins = 400, atol=0.01, y_offset=-0.1, label = "Samples A" p = plot!(samples, 0.9, bins = 100, atol=0.05, y_offset=0.1, msw = 5, ms=8, msc=:red, label = "Samples B") # This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jl - diff --git a/examples/tutorial/runTutorial.jl b/examples/tutorial/runTutorial.jl index 1b20644..4acf268 100644 --- a/examples/tutorial/runTutorial.jl +++ b/examples/tutorial/runTutorial.jl @@ -32,10 +32,9 @@ samples = bat_sample(posterior, algorithm).result; # see the BAT.jl [tutorial](https://bat.github.io/BAT.jl/dev/tutorial/#Parameter-Space-Exploration-via-MCMC) # and [documentation](https://bat.github.io/BAT.jl/dev/stable_api/#BAT.bat_sample). -# We can then inspect the results of the sampling using BAT.jl's `SampledDensity`, +# We can then inspect the results of the sampling using BAT.jl's `bat_report`, # giving a summary of the sampling and the results of the model parameters. -sd = SampledDensity(posterior, samples) -display(sd) +bat_report(samples) # Information about the smallest 1d intervals containing p% proability can be # obtained using the `get_smallest_interval_edges` function: diff --git a/examples/tutorial/tutorial_inputs.jl b/examples/tutorial/tutorial_inputs.jl index 2d39f6f..82e12fe 100644 --- a/examples/tutorial/tutorial_inputs.jl +++ b/examples/tutorial/tutorial_inputs.jl @@ -16,7 +16,7 @@ # For our example, we consider two parameters with the names `C1` and `C2`. # For `C1` we choose a uniform (flat) prior in the range (-3, 3). # For `C2` we choose a gaussian prior with μ=0 and σ=0.5. -parameters = BAT.NamedTupleDist( +parameters = BAT.distprod( C1 = -3..3, # short for: Uniform(-3, 3) C2 = Normal(0, 0.5) # Normal distribution ) @@ -85,7 +85,7 @@ diff_xsec = [diff_xsec_bin1, diff_xsec_bin2, diff_xsec_bin3] # We can now enter measurements of the observables. # This is done by defining a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types) # consisting of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) -# and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution) objects. +# and [`BinnedMeasurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.BinnedMeasurement) objects. # A `Measurement` consists of the observable, the measured numerical value and # numerical values for the (multiple types of) uncertainties. @@ -93,12 +93,12 @@ diff_xsec = [diff_xsec_bin1, diff_xsec_bin2, diff_xsec_bin3] # object or as a `Function`. When using the latter, the observable is assumed to be unconstrained. # The uncertainties are passed as a [`NamedTuple`](https://docs.julialang.org/en/v1/manual/types/#Named-Tuple-Types). # Each measurement has to provide uncertainty values for all of the (active) uncertainty -# types (see next section on `Correlations`). For a `MeasurementDistribution`, +# types (see next section on `Correlations`). For a `BinnedMeasurement`, # the corresponding inputs have to be passed as `Vectors`, where each element # represents one bin of the distribution. # A `Measurement` can be excluded from the model by setting the switch `active=false`. -# For a `MeasurementDistribution`, the keyword `active` accepts `true` or `false` +# For a `BinnedMeasurement`, the keyword `active` accepts `true` or `false` # to (de)activate the whole distribution or a vector of booleans for (de)activating only certain bins. measurements = ( @@ -108,13 +108,13 @@ measurements = ( Meas2 = Measurement(Observable(xsec2, min=0), 1.9, uncertainties = (stat=0.6, syst=0.9, another_unc=1.1), active=true), - MeasDist = MeasurementDistribution(diff_xsec, [1.9, 2.93, 4.4], + MeasDist = BinnedMeasurement(diff_xsec, [1.9, 2.93, 4.4], uncertainties = (stat = [0.7, 1.1, 1.2], syst= [0.7, 0.8, 1.3], another_unc = [1.0, 1.2, 1.9]), active=[true, false, true]), # `active = false`: exclude all bins from fit, `active = [true, true, false]`: exclude only third bin from fit ) # Further information on the constructors see the API documentation of [`Measurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.Measurement) -# and [`MeasurementDistribution`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.MeasurementDistribution). +# and [`BinnedMeasurement`](https://tudo-physik-e4.github.io/EFTfitter.jl/dev/api/#EFTfitter.BinnedMeasurement). # Note: When using only one measurement or only one type of uncertainties, @@ -131,7 +131,7 @@ measurements = ( # of ``N \times N``, where ``N`` is the number of measurements, counting each bin of a distribution. # When a certain type of uncertainty should not be considered, it can be deactivated # by setting `active = false`. This means that the uncertainty values given in the -# corresponding `Measurement` and `MeasurementDistribution` objects will not be used. +# corresponding `Measurement` and `BinnedMeasurement` objects will not be used. # When assuming the uncertainties of all measurements are uncorrelated, you can # use the `NoCorrelation` object for easily passing an identity matrix of the correct size. @@ -141,8 +141,8 @@ measurements = ( # With the function `to_correlation_matrix`, it is possible to enter a correlation # matrix by simply specifying the names of the measurements that should be correlated # and the value of the corresponding correlation coefficient. -# When using a `MeasurementDistribution`, the inter-bin correlations can also be -# entered by passing a matrix. By appending `_binX` to the name of a `MeasurementDistribution`, +# When using a `BinnedMeasurement`, the inter-bin correlations can also be +# entered by passing a matrix. By appending `_binX` to the name of a `BinnedMeasurement`, # the Xth bin of the distribution can be accessed. # Note: This function is evaluated from top to bottom, so if you overwrite a # specific correlation value, the last value entered will be used. diff --git a/src/EFTfitterLikelihood.jl b/src/EFTfitterLikelihood.jl index 8a00380..cfa999e 100644 --- a/src/EFTfitterLikelihood.jl +++ b/src/EFTfitterLikelihood.jl @@ -2,7 +2,7 @@ function iswithinbounds(r::Float64, min::Float64, max::Float64) return min <= r <= max end -# TODO: add dispatch, return 1 by default + function check_observable_bounds(cb::NoBoundsCheck, predictions, mins::Vector{Float64}, maxs::Vector{Float64}) return 1.0 end @@ -93,7 +93,6 @@ function add_model_uncertainties_to_cov!(mus::NoModelUncertainties, covmatrix, p end -#TODO: need type for covariance matrix function get_current_cov(nc::NuisanceCorrelations, D, params) for nui in D.nuisance_correlations.nuisance_correlations #TODO: rethink naming i = nui.i; j = nui.j diff --git a/src/EFTfitterModel.jl b/src/EFTfitterModel.jl index 0a3be49..9e177a3 100755 --- a/src/EFTfitterModel.jl +++ b/src/EFTfitterModel.jl @@ -14,7 +14,7 @@ Only active `Measurement` and `Correlation` objects will be considered. Fields: * `parameters::BAT.NamedTupleDist` * `measurements::NamedTuple{<:Any, <:Tuple{Vararg{Measurement}}}` -* `measurementdistributions::NamedTuple{<:Any, <:Tuple{Vararg{MeasurementDistribution}}}` +* `BinnedMeasurements::NamedTuple{<:Any, <:Tuple{Vararg{BinnedMeasurement}}}` * `correlations::NamedTuple{<:Any, <:Tuple{Vararg{Correlation}}}` * `nuisances::Union{NamedTuple{<:Any, <:Tuple{Vararg{NuisanceCorrelation}}}, Nothing}` @@ -41,7 +41,7 @@ model = EFTfitterModel(parameters, measurements, correlations, nuisances) # with struct EFTfitterModel parameters::BAT.NamedTupleDist measurements::NamedTuple{<:Any, <:Tuple{Vararg{Measurement}}} - measured_distributions::NamedTuple{<:Any, <:Tuple{Vararg{MeasurementDistribution}}} + measured_distributions::NamedTuple{<:Any, <:Tuple{Vararg{BinnedMeasurement}}} limits::Union{NamedTuple{<:Any, <:Tuple{Vararg{AbstractLimit}}}, Nothing} correlations::NamedTuple{<:Any, <:Tuple{Vararg{Correlation}}} nuisances::Union{NamedTuple{<:Any, <:Tuple{Vararg{NuisanceCorrelation}}}, Nothing} @@ -60,7 +60,7 @@ function EFTfitterModel( measurement_vec, measurement_keys = unpack(measurements) correlation_vec, uncertainty_keys = unpack(correlations) - # convert elements of MeasurementDistribution to Measurement for each bin + # convert elements of BinnedMeasurement to Measurement for each bin binned_measurements, binned_measurement_keys = convert_to_bins(measurement_vec, measurement_keys) active_measurements, active_measurement_keys, all_correlations = only_active_measurements(binned_measurements, binned_measurement_keys, correlation_vec) @@ -99,9 +99,9 @@ get_measurements(m::EFTfitterModel) = m.measurements """ get_measurement_distributions(m::EFTfitterModel) -Returns a `NamedTuple` with the `MeasurementDistribution`s in the `EFTfitterModel`. +Returns a `NamedTuple` with the `BinnedMeasurement`s in the `EFTfitterModel`. """ -get_measurement_distributions(m::EFTfitterModel) = m.measurementdistributions +get_measurement_distributions(m::EFTfitterModel) = m.BinnedMeasurements """ @@ -162,7 +162,7 @@ function convert_to_bins(m::Measurement) end -function convert_to_bins(md::MeasurementDistribution) +function convert_to_bins(md::BinnedMeasurement) nbins = length(md.value) uncertainties = [[u[i] for u in md.uncertainties] for i in 1:nbins] @@ -232,7 +232,7 @@ function create_distributions( m::NamedTuple{<:Any, <:Tuple{Vararg{AbstractMeasurement}}}, uncertainty_keys::Vector{Symbol} ) - active_idxs = [i for i in 1:length(m) if (isa(m[i], MeasurementDistribution) && any(m[i].active))] + active_idxs = [i for i in 1:length(m) if (isa(m[i], BinnedMeasurement) && any(m[i].active))] dists = [only_active_bins(m[i], uncertainty_keys) for i in active_idxs] dists_keys = [keys(m)[i] for i in active_idxs] @@ -243,7 +243,7 @@ function create_distributions( end end -function only_active_bins(md::MeasurementDistribution, uncertainty_keys::Vector{Symbol}) +function only_active_bins(md::BinnedMeasurement, uncertainty_keys::Vector{Symbol}) obs = md.observable[md.active] vals = md.value[md.active] @@ -251,7 +251,7 @@ function only_active_bins(md::MeasurementDistribution, uncertainty_keys::Vector{ uncertainties = namedtuple(uncertainty_keys, unc) bin_names = md.bin_names[md.active] - return MeasurementDistribution(obs, vals, uncertainties=uncertainties, bin_names=bin_names) + return BinnedMeasurement(obs, vals, uncertainties=uncertainties, bin_names=bin_names) end @@ -259,7 +259,7 @@ function keys_of_bins(m::Measurement, key::Symbol) return key end -function keys_of_bins(md::MeasurementDistribution, key::Symbol) +function keys_of_bins(md::BinnedMeasurement, key::Symbol) return [Symbol(String(key)*"_"*String(b)) for b in md.bin_names] end diff --git a/src/datatypes.jl b/src/datatypes.jl index 7af6528..7849cd4 100755 --- a/src/datatypes.jl +++ b/src/datatypes.jl @@ -1,7 +1,7 @@ export Observable export Measurement -export MeasurementDistribution +export BinnedMeasurement export Correlation export NoCorrelation @@ -111,7 +111,7 @@ end #----- Measurement Distribution----------------------------------------- """ - struct MeasurementDistribution + struct BinnedMeasurement Fields: * `observable::Array{Observable, 1}`: Observables that are measured. @@ -122,7 +122,7 @@ Fields: Constructors: ```julia -MeasurementDistribution( +BinnedMeasurement( observable::Array{Observable, 1}, values::Array{<:Real, 1}; uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Union{Vector{Float64}, Vector{Int64}}}}}, @@ -132,7 +132,7 @@ MeasurementDistribution( ``` ```julia -MeasurementDistribution( +BinnedMeasurement( observable::Array{Function, 1}, values::Array{<:Real, 1}; uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Union{Vector{Float64}, Vector{Int64}}}}}, @@ -141,7 +141,7 @@ MeasurementDistribution( ) ``` """ -struct MeasurementDistribution <: AbstractMeasurement +struct BinnedMeasurement <: AbstractMeasurement observable::Array{Observable, 1} value::Array{Float64, 1} uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Array{Float64, 1}}}} @@ -150,7 +150,7 @@ struct MeasurementDistribution <: AbstractMeasurement end # constructor with default value active=true and names "bin1", ... -function MeasurementDistribution( +function BinnedMeasurement( observables::Array{Observable, 1}, value::Array{<:Real, 1}; uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Vector{<:Real}}}}, @@ -160,11 +160,11 @@ function MeasurementDistribution( isa(active, Bool) ? active = fill(active, length(value)) : nothing unc = namedtuple(keys(uncertainties), float.(NamedTupleTools.values(uncertainties))) - MeasurementDistribution(observables, value, unc, active, bin_names) + BinnedMeasurement(observables, value, unc, active, bin_names) end # constructor converting Function to Observable with default value active=true and names "bin1", ... -function MeasurementDistribution( +function BinnedMeasurement( observables::Array{Function, 1}, value::Array{<:Real, 1}; uncertainties::NamedTuple{<:Any, <:Tuple{Vararg{Vector{<:Real}}}}, @@ -175,7 +175,7 @@ function MeasurementDistribution( isa(active, Bool) ? active = fill(active, length(value)) : nothing unc = namedtuple(keys(uncertainties), float.(NamedTupleTools.values(uncertainties))) - MeasurementDistribution(obs, value, unc, active, bin_names) + BinnedMeasurement(obs, value, unc, active, bin_names) end #----- TODO: Limits ----------------------------------------- diff --git a/src/plotting/plot_measurements.jl b/src/plotting/plot_measurements.jl index 8279f0a..105ca3f 100755 --- a/src/plotting/plot_measurements.jl +++ b/src/plotting/plot_measurements.jl @@ -19,9 +19,9 @@ end -# plot recipe for plotting a MeasurementDistribution object +# plot recipe for plotting a BinnedMeasurement object @recipe function f( - measurement::MeasurementDistribution; + measurement::BinnedMeasurement; uncertainties = true, bin_names = String.(measurement.bin_names) ) @@ -75,7 +75,7 @@ end end end -# plot recipe for plotting a particular MeasurementDistribution from a NamedTuple +# plot recipe for plotting a particular BinnedMeasurement from a NamedTuple @recipe function f( measurements::NamedTuple{<:Any, <:Tuple{Vararg{AbstractMeasurement}}}, name::Symbol; @@ -90,7 +90,7 @@ end function total_uncertainty( - measurement::Union{Measurement, MeasurementDistribution}, + measurement::Union{Measurement, BinnedMeasurement}, uncertainty::Symbol ) return measurement.uncertainties[uncertainty] @@ -98,7 +98,7 @@ end # calculate the total uncertainty of a measurement by adding the quadratures function total_uncertainty( - measurement::Union{Measurement, MeasurementDistribution}, + measurement::Union{Measurement, BinnedMeasurement}, uncertainty::Union{Tuple{Vararg{Symbol}}, Vector{Symbol}} ) total = zeros(length(measurement.uncertainties[1])) diff --git a/src/utils.jl b/src/utils.jl index 0a888c6..df4cdb5 100755 --- a/src/utils.jl +++ b/src/utils.jl @@ -109,7 +109,7 @@ julia> tbl, benchmarks = run_speed_test(model) function run_speed_test( m::EFTfitterModel; matrix_types = [Matrix, sparse, Symmetric], - vs = rand(m.parameters, 10), + vs = rand(m.parameters, 10), #TODO: this won't work for models with nuisance correlations verbose=true ) @info "Running speed comparisons to find optimal data type for (inverse) covariance matrix!" diff --git a/test/test_datatypes.jl b/test/test_datatypes.jl index aa95068..1ccb06d 100644 --- a/test/test_datatypes.jl +++ b/test/test_datatypes.jl @@ -20,10 +20,10 @@ @test meas1 == meas2 @test keys(meas1.uncertainties) == (:unc1, :unc2) - #Test type MeasurementDistribution: - measdist1 = MeasurementDistribution([obs1, obs1], [50.0, 49.9], + #Test type BinnedMeasurement: + measdist1 = BinnedMeasurement([obs1, obs1], [50.0, 49.9], uncertainties=(unc1=[0.5, 0.4], unc2=[0.3, 0.29]), active=[true, false]) - measdist2 = MeasurementDistribution([obs1, obs1], [50.0, 49.9], + measdist2 = BinnedMeasurement([obs1, obs1], [50.0, 49.9], uncertainties=(unc1=[0.5, 0.4], unc2=[0.3, 0.29]), active=true) @test measdist1.active == [true, false] @test measdist2.active == [true, true] diff --git a/test/test_inputs/test_likelihood.jl b/test/test_inputs/test_likelihood.jl index 54b3692..b4eab38 100644 --- a/test/test_inputs/test_likelihood.jl +++ b/test/test_inputs/test_likelihood.jl @@ -57,7 +57,7 @@ function create_model(N; use_model_uncertainties = false) measurements = ( #meas1 = Measurement(testfunc, 3000.0, uncertainties = (unc = 50.1,)), - meas = MeasurementDistribution(func_arr, meas_arr, + meas = BinnedMeasurement(func_arr, meas_arr, uncertainties = (unc = unc_arr,)), ) diff --git a/test/test_inputs/test_nuisance_inputs.jl b/test/test_inputs/test_nuisance_inputs.jl index 205da70..0615597 100644 --- a/test/test_inputs/test_nuisance_inputs.jl +++ b/test/test_inputs/test_nuisance_inputs.jl @@ -24,7 +24,7 @@ using BAT meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 333.3, uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), - meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], + meas4 = BinnedMeasurement(Function[testfunc1, testfunc1, testfunc1], [10, 20, 30], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), active = [true, false, true], bin_names=[Symbol("0_5"), Symbol("5_10"), Symbol("10_20")]) ) diff --git a/test/test_modelunc.jl b/test/test_modelunc.jl index 3757bfc..58c4ce1 100644 --- a/test/test_modelunc.jl +++ b/test/test_modelunc.jl @@ -28,7 +28,7 @@ measurements = ( meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 333.3, uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), - meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], + meas4 = BinnedMeasurement(Function[testfunc1, testfunc1, testfunc1], [10, 20, 30], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), active = [true, false, true], bin_names=[Symbol("0_5"), Symbol("5_10"), Symbol("10_20")]) ) diff --git a/test/test_nuisance.jl b/test/test_nuisance.jl index e6b20f1..d9672c1 100644 --- a/test/test_nuisance.jl +++ b/test/test_nuisance.jl @@ -26,7 +26,7 @@ measurements = ( meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 333.3, uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), - meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], + meas4 = BinnedMeasurement(Function[testfunc1, testfunc1, testfunc1], [10, 20, 30], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), active = [true, false, true], bin_names=[Symbol("0_5"), Symbol("5_10"), Symbol("10_20")]) ) diff --git a/test/test_plain.jl b/test/test_plain.jl index 0e83d69..a74a874 100644 --- a/test/test_plain.jl +++ b/test/test_plain.jl @@ -26,7 +26,7 @@ measurements = ( meas3 = Measurement(Observable(testfunc1, min=0, max=25000), 333.3, uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), - meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], + meas4 = BinnedMeasurement(Function[testfunc1, testfunc1, testfunc1], [10, 20, 30], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), active = [true, false, true], bin_names=[Symbol("0_5"), Symbol("5_10"), Symbol("10_20")]) ) diff --git a/test/test_ranking.jl b/test/test_ranking.jl index 6fc3bf8..8b12da0 100644 --- a/test/test_ranking.jl +++ b/test/test_ranking.jl @@ -19,7 +19,7 @@ meas3 = Measurement(Observable(testfunc1, min=0, max=1000), 0.3, uncertainties = (unc1=30.1, unc2=30.2, unc3=30.3), active=true), - meas4 = MeasurementDistribution(Function[testfunc1, testfunc1, testfunc1], + meas4 = BinnedMeasurement(Function[testfunc1, testfunc1, testfunc1], [0.28, 0.27, 0.29], uncertainties = (unc1=[0.11, 0.12, 0.13], unc2=[0.21, 0.22, 0.23], unc3=[0.31, 0.32, 0.33]), active = [true, false, true]) )