From 547c1dfb9f297720534651d2416f2260927e3611 Mon Sep 17 00:00:00 2001
From: Mauro Donega <mauro.donega@cern.ch>
Date: Fri, 8 May 2020 23:51:55 +0200
Subject: [PATCH] how to fit with minuit and probfit in python

---
 iMinuit.ipynb         | 165 ++++++--
 probfit-iMinuit.ipynb | 848 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 987 insertions(+), 26 deletions(-)
 create mode 100644 probfit-iMinuit.ipynb

diff --git a/iMinuit.ipynb b/iMinuit.ipynb
index 1fd7069..0826732 100644
--- a/iMinuit.ipynb
+++ b/iMinuit.ipynb
@@ -83,9 +83,114 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table>\n",
+       "<tr style=\"background-color:#F4F4F4;\">\n",
+       "<td/>\n",
+       "<th title=\"Variable name\">\n",
+       "Name\n",
+       "</th>\n",
+       "<th title=\"Value of parameter\">\n",
+       "Value\n",
+       "</th>\n",
+       "<th title=\"Hesse error\">\n",
+       "Hesse Error\n",
+       "</th>\n",
+       "<th title=\"Minos lower error\">\n",
+       "Minos Error-\n",
+       "</th>\n",
+       "<th title=\"Minos upper error\">\n",
+       "Minos Error+\n",
+       "</th>\n",
+       "<th title=\"Lower limit of the parameter\">\n",
+       "Limit-\n",
+       "</th>\n",
+       "<th title=\"Upper limit of the parameter\">\n",
+       "Limit+\n",
+       "</th>\n",
+       "<th title=\"Is the parameter fixed in the fit\">\n",
+       "Fixed\n",
+       "</th>\n",
+       "</tr>\n",
+       "<tr style=\"background-color:#FFFFFF;\">\n",
+       "<td>\n",
+       "0\n",
+       "</td>\n",
+       "<td>\n",
+       "a\n",
+       "</td>\n",
+       "<td>\n",
+       "5.00\n",
+       "</td>\n",
+       "<td>\n",
+       "0.10\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "0\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "yes\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr style=\"background-color:#F4F4F4;\">\n",
+       "<td>\n",
+       "1\n",
+       "</td>\n",
+       "<td>\n",
+       "b\n",
+       "</td>\n",
+       "<td>\n",
+       "5.00\n",
+       "</td>\n",
+       "<td>\n",
+       "0.10\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "0\n",
+       "</td>\n",
+       "<td>\n",
+       "10\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>\n"
+      ],
+      "text/plain": [
+       "------------------------------------------------------------------------------------------\n",
+       "|   | Name |   Value   | Hesse Err | Minos Err- | Minos Err+ | Limit-  | Limit+  | Fixed |\n",
+       "------------------------------------------------------------------------------------------\n",
+       "| 0 | a    |   5.00    |   0.10    |            |            |    0    |         |  yes  |\n",
+       "| 1 | b    |   5.00    |   0.10    |            |            |    0    |   10    |       |\n",
+       "------------------------------------------------------------------------------------------"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# Minuit uses introspection to detect the parameter names of your function - it means \n",
     "#\n",
@@ -114,7 +219,15 @@
     "\n",
     "m.get_param_states()\n",
     "\n",
-    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "# Once Minuit is constructed you can still fix/release parameters as:\n",
     "m.fixed[\"a\"] = False\n",
     "m.fixed[\"b\"] = True\n",
@@ -137,7 +250,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -332,7 +445,7 @@
        "------------------------------------------------------------------------------------------"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -417,7 +530,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -444,7 +557,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -547,7 +660,7 @@
        "------------------------------------------------------------------------------------------"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -566,7 +679,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -616,7 +729,7 @@
        "---------------------"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -628,7 +741,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -658,7 +771,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -708,7 +821,7 @@
        "-----------------"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -720,7 +833,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -757,7 +870,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -778,7 +891,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -937,7 +1050,7 @@
        "-------------------------------------------------"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -948,7 +1061,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
@@ -1051,7 +1164,7 @@
        "------------------------------------------------------------------------------------------"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1062,7 +1175,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -1096,16 +1209,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.contour.ContourSet at 0x11e23d690>"
+       "<matplotlib.contour.ContourSet at 0x116874950>"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -1128,7 +1241,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
@@ -1150,7 +1263,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -1172,7 +1285,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
diff --git a/probfit-iMinuit.ipynb b/probfit-iMinuit.ipynb
new file mode 100644
index 0000000..c24015b
--- /dev/null
+++ b/probfit-iMinuit.ipynb
@@ -0,0 +1,848 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# probfit and iMinuit: Likelihood fits\n",
+    "\n",
+    "In this notebook we will be using probfit together with iminuit:\n",
+    "  \n",
+    "probfit:  \n",
+    "https://probfit.readthedocs.io/en/latest/  \n",
+    " \n",
+    "iMinuit:    \n",
+    "https://iminuit.readthedocs.io/en/latest/index.html#  \n",
+    "\n",
+    "Here below a quick summary of:    \n",
+    "http://piti118.github.io/babar_python_tutorial/notebooks/04_Fitting.html  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.stats\n",
+    "from math import exp, pi, sqrt\n",
+    "from probfit import UnbinnedLH\n",
+    "from iminuit import Minuit, describe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate data\n",
+    "# set the seed to always get the same samples\n",
+    "np.random.seed(seed=123456)\n",
+    "\n",
+    "# Generate a toy dataset on an gaussian distribution (signal)\n",
+    "#mu = 125, sigma = 1\n",
+    "gdata = scipy.stats.norm.rvs(loc=0, scale=1, size=1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Entries / bins size = 0.1')"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=[5,5])\n",
+    "plt.subplot(111)\n",
+    "plt.hist(gdata, bins=100, range=[-5,5], color='blue', alpha=0.5)\n",
+    "plt.xlabel(r'x [units]')\n",
+    "plt.ylabel(r'Entries / bins size = 0.1')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['mean', 'sigma']"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from probfit import gaussian\n",
+    "ulh = UnbinnedLH(gaussian, gdata)\n",
+    "describe(ulh)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<table>\n",
+       "<tr style=\"background-color:#F4F4F4;\">\n",
+       "<td/>\n",
+       "<th title=\"Variable name\">\n",
+       "Name\n",
+       "</th>\n",
+       "<th title=\"Value of parameter\">\n",
+       "Value\n",
+       "</th>\n",
+       "<th title=\"Hesse error\">\n",
+       "Hesse Error\n",
+       "</th>\n",
+       "<th title=\"Minos lower error\">\n",
+       "Minos Error-\n",
+       "</th>\n",
+       "<th title=\"Minos upper error\">\n",
+       "Minos Error+\n",
+       "</th>\n",
+       "<th title=\"Lower limit of the parameter\">\n",
+       "Limit-\n",
+       "</th>\n",
+       "<th title=\"Upper limit of the parameter\">\n",
+       "Limit+\n",
+       "</th>\n",
+       "<th title=\"Is the parameter fixed in the fit\">\n",
+       "Fixed\n",
+       "</th>\n",
+       "</tr>\n",
+       "<tr style=\"background-color:#FFFFFF;\">\n",
+       "<td>\n",
+       "0\n",
+       "</td>\n",
+       "<td>\n",
+       "mean\n",
+       "</td>\n",
+       "<td>\n",
+       "0.20\n",
+       "</td>\n",
+       "<td>\n",
+       "0.10\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr style=\"background-color:#F4F4F4;\">\n",
+       "<td>\n",
+       "1\n",
+       "</td>\n",
+       "<td>\n",
+       "sigma\n",
+       "</td>\n",
+       "<td>\n",
+       "1.50\n",
+       "</td>\n",
+       "<td>\n",
+       "0.10\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>\n"
+      ],
+      "text/plain": [
+       "-------------------------------------------------------------------------------------------\n",
+       "|   | Name  |   Value   | Hesse Err | Minos Err- | Minos Err+ | Limit-  | Limit+  | Fixed |\n",
+       "-------------------------------------------------------------------------------------------\n",
+       "| 0 | mean  |   0.20    |   0.10    |            |            |         |         |       |\n",
+       "| 1 | sigma |   1.50    |   0.10    |            |            |         |         |       |\n",
+       "-------------------------------------------------------------------------------------------"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m = Minuit(ulh, \n",
+    "           mean=0.2, sigma=1.5,\n",
+    "           error_mean=0.1, error_sigma=0.1,\n",
+    "           errordef=0.5)#remember up is 0.5 for likelihood and 1 for chi^2\n",
+    "\n",
+    "# Show() is the same thing as draw(). But show the figure immediately.\n",
+    "# For all parameters and return vars:\n",
+    "#    https://probfit.readthedocs.io/en/latest/api.html#probfit.costfunc.UnbinnedLH.draw\n",
+    "ulh.show(m, print_par=True)\n",
+    "m.get_param_states()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<table>\n",
+       "<tr style=\"background-color:#F4F4F4;\">\n",
+       "<td/>\n",
+       "<th title=\"Variable name\">\n",
+       "Name\n",
+       "</th>\n",
+       "<th title=\"Value of parameter\">\n",
+       "Value\n",
+       "</th>\n",
+       "<th title=\"Hesse error\">\n",
+       "Hesse Error\n",
+       "</th>\n",
+       "<th title=\"Minos lower error\">\n",
+       "Minos Error-\n",
+       "</th>\n",
+       "<th title=\"Minos upper error\">\n",
+       "Minos Error+\n",
+       "</th>\n",
+       "<th title=\"Lower limit of the parameter\">\n",
+       "Limit-\n",
+       "</th>\n",
+       "<th title=\"Upper limit of the parameter\">\n",
+       "Limit+\n",
+       "</th>\n",
+       "<th title=\"Is the parameter fixed in the fit\">\n",
+       "Fixed\n",
+       "</th>\n",
+       "</tr>\n",
+       "<tr style=\"background-color:#FFFFFF;\">\n",
+       "<td>\n",
+       "0\n",
+       "</td>\n",
+       "<td>\n",
+       "mean\n",
+       "</td>\n",
+       "<td>\n",
+       "-0.05\n",
+       "</td>\n",
+       "<td>\n",
+       " 0.03\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr style=\"background-color:#F4F4F4;\">\n",
+       "<td>\n",
+       "1\n",
+       "</td>\n",
+       "<td>\n",
+       "sigma\n",
+       "</td>\n",
+       "<td>\n",
+       "1.044\n",
+       "</td>\n",
+       "<td>\n",
+       "0.023\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>\n"
+      ],
+      "text/plain": [
+       "-------------------------------------------------------------------------------------------\n",
+       "|   | Name  |   Value   | Hesse Err | Minos Err- | Minos Err+ | Limit-  | Limit+  | Fixed |\n",
+       "-------------------------------------------------------------------------------------------\n",
+       "| 0 | mean  |   -0.05   |    0.03   |            |            |         |         |       |\n",
+       "| 1 | sigma |   1.044   |   0.023   |            |            |         |         |       |\n",
+       "-------------------------------------------------------------------------------------------"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m.migrad()\n",
+    "ulh.show(m)\n",
+    "m.get_param_states()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table>\n",
+       "<tr>\n",
+       "<td/>\n",
+       "\n",
+       "<th>\n",
+       "mean\n",
+       "</th>\n",
+       "<th>\n",
+       "sigma\n",
+       "</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<th>\n",
+       "mean\n",
+       "</th>\n",
+       "<td>\n",
+       "1.089E-3\n",
+       "</td>\n",
+       "<td style=\"background-color:rgb(250,250,250)\">\n",
+       "0.000E-3\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<th>\n",
+       "sigma\n",
+       "</th>\n",
+       "<td style=\"background-color:rgb(250,250,250)\">\n",
+       "0.000E-3\n",
+       "</td>\n",
+       "<td>\n",
+       "0.545E-3\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>\n"
+      ],
+      "text/plain": [
+       "-----------------------------\n",
+       "|       |     mean    sigma |\n",
+       "-----------------------------\n",
+       "|  mean | 1.089E-3 0.000E-3 |\n",
+       "| sigma | 0.000E-3 0.545E-3 |\n",
+       "-----------------------------"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m.matrix()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table>\n",
+       "<tr>\n",
+       "<th title=\"Parameter name\">\n",
+       "mean\n",
+       "</th>\n",
+       "<td align=\"center\" colspan=\"2\" style=\"background-color:#92CCA6;\">\n",
+       "Valid\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"Lower and upper minos error of the parameter\">\n",
+       "Error\n",
+       "</td>\n",
+       "<td>\n",
+       "-0.03\n",
+       "</td>\n",
+       "<td>\n",
+       " 0.03\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"Validity of lower/upper minos error\">\n",
+       "Valid\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "True\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "True\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"Did scan hit limit of any parameter?\">\n",
+       "At Limit\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"Did scan hit function call limit?\">\n",
+       "Max FCN\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"New minimum found when doing scan?\">\n",
+       "New Min\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>\n",
+       "\n",
+       "<table>\n",
+       "<tr>\n",
+       "<th title=\"Parameter name\">\n",
+       "sigma\n",
+       "</th>\n",
+       "<td align=\"center\" colspan=\"2\" style=\"background-color:#92CCA6;\">\n",
+       "Valid\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"Lower and upper minos error of the parameter\">\n",
+       "Error\n",
+       "</td>\n",
+       "<td>\n",
+       "-0.023\n",
+       "</td>\n",
+       "<td>\n",
+       " 0.024\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"Validity of lower/upper minos error\">\n",
+       "Valid\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "True\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "True\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"Did scan hit limit of any parameter?\">\n",
+       "At Limit\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"Did scan hit function call limit?\">\n",
+       "Max FCN\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "<td title=\"New minimum found when doing scan?\">\n",
+       "New Min\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "<td style=\"background-color:#92CCA6;\">\n",
+       "False\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>\n"
+      ],
+      "text/plain": [
+       "-------------------------------------------------\n",
+       "|      mean       |            Valid            |\n",
+       "-------------------------------------------------\n",
+       "|      Error      |    -0.03     |     0.03     |\n",
+       "|      Valid      |     True     |     True     |\n",
+       "|    At Limit     |    False     |    False     |\n",
+       "|     Max FCN     |    False     |    False     |\n",
+       "|     New Min     |    False     |    False     |\n",
+       "-------------------------------------------------\n",
+       "-------------------------------------------------\n",
+       "|      sigma      |            Valid            |\n",
+       "-------------------------------------------------\n",
+       "|      Error      |    -0.023    |     0.024    |\n",
+       "|      Valid      |     True     |     True     |\n",
+       "|    At Limit     |    False     |    False     |\n",
+       "|     Max FCN     |    False     |    False     |\n",
+       "|     New Min     |    False     |    False     |\n",
+       "-------------------------------------------------"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m.minos()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table>\n",
+       "<tr style=\"background-color:#F4F4F4;\">\n",
+       "<td/>\n",
+       "<th title=\"Variable name\">\n",
+       "Name\n",
+       "</th>\n",
+       "<th title=\"Value of parameter\">\n",
+       "Value\n",
+       "</th>\n",
+       "<th title=\"Hesse error\">\n",
+       "Hesse Error\n",
+       "</th>\n",
+       "<th title=\"Minos lower error\">\n",
+       "Minos Error-\n",
+       "</th>\n",
+       "<th title=\"Minos upper error\">\n",
+       "Minos Error+\n",
+       "</th>\n",
+       "<th title=\"Lower limit of the parameter\">\n",
+       "Limit-\n",
+       "</th>\n",
+       "<th title=\"Upper limit of the parameter\">\n",
+       "Limit+\n",
+       "</th>\n",
+       "<th title=\"Is the parameter fixed in the fit\">\n",
+       "Fixed\n",
+       "</th>\n",
+       "</tr>\n",
+       "<tr style=\"background-color:#FFFFFF;\">\n",
+       "<td>\n",
+       "0\n",
+       "</td>\n",
+       "<td>\n",
+       "mean\n",
+       "</td>\n",
+       "<td>\n",
+       "-0.05\n",
+       "</td>\n",
+       "<td>\n",
+       " 0.03\n",
+       "</td>\n",
+       "<td>\n",
+       "-0.03\n",
+       "</td>\n",
+       "<td>\n",
+       " 0.03\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "</tr>\n",
+       "<tr style=\"background-color:#F4F4F4;\">\n",
+       "<td>\n",
+       "1\n",
+       "</td>\n",
+       "<td>\n",
+       "sigma\n",
+       "</td>\n",
+       "<td>\n",
+       " 1.044\n",
+       "</td>\n",
+       "<td>\n",
+       " 0.023\n",
+       "</td>\n",
+       "<td>\n",
+       "-0.023\n",
+       "</td>\n",
+       "<td>\n",
+       " 0.024\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "<td>\n",
+       "\n",
+       "</td>\n",
+       "</tr>\n",
+       "</table>\n"
+      ],
+      "text/plain": [
+       "-------------------------------------------------------------------------------------------\n",
+       "|   | Name  |   Value   | Hesse Err | Minos Err- | Minos Err+ | Limit-  | Limit+  | Fixed |\n",
+       "-------------------------------------------------------------------------------------------\n",
+       "| 0 | mean  |   -0.05   |    0.03   |   -0.03    |    0.03    |         |         |       |\n",
+       "| 1 | sigma |   1.044   |   0.023   |   -0.023   |    0.024   |         |         |       |\n",
+       "-------------------------------------------------------------------------------------------"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m.get_param_states()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "m.draw_profile('mean');"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "m.draw_profile('sigma');"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "px, py = m.profile('mean', subtract_min=True)\n",
+    "plt.plot(px, py);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.contour.ContourSet at 0x1a226f5b50>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=[5,5])\n",
+    "m.draw_mncontour('mean', 'sigma', nsigma=4, numpoints=100)  # nsigma=4 says: draw four contours from sigma=1 to 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
-- 
GitLab