From 895a3fcfe9d0fc280e643574972b465125ba9bf5 Mon Sep 17 00:00:00 2001
From: "C.A.P. Linssen" <charl@turingbirds.com>
Date: Thu, 22 Feb 2024 02:55:57 -0800
Subject: [PATCH] add GL model tutorial notebook

---
 .../gl_model/gl_model_tutorial.ipynb          | 986 +++++-------------
 1 file changed, 256 insertions(+), 730 deletions(-)

diff --git a/doc/tutorials/gl_model/gl_model_tutorial.ipynb b/doc/tutorials/gl_model/gl_model_tutorial.ipynb
index 0eea8f98b..fb6683afb 100644
--- a/doc/tutorials/gl_model/gl_model_tutorial.ipynb
+++ b/doc/tutorials/gl_model/gl_model_tutorial.ipynb
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -48,46 +48,232 @@
     "import os\n",
     "import random\n",
     "\n",
-    "from pynestml.frontend.pynestml_frontend import generate_nest_target\n",
+    "from pynestml.codegeneration.nest_code_generator_utils import NESTCodeGeneratorUtils\n",
     "\n",
     "import logging\n",
     "logging.getLogger('matplotlib.font_manager').disabled = True"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "GL model with physical units\n",
+    "----------------------------\n"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def fI_curve(neuron_model: str, t_stop: float = 1000., custom_model_opts: Optional[Dict] = None):\n",
-    "    I_stim_vec = np.linspace(0, 1E-9, 40)  # [A]\n",
-    "    rate = float(\"nan\") * np.ones_like(I_stim_vec)\n",
-    "\n",
-    "    for i, I_stim in enumerate(I_stim_vec):\n",
-    "        nest.ResetKernel()\n",
-    "        neuron = nest.Create(neuron_model, params=custom_model_opts)\n",
-    "\n",
-    "        dc = nest.Create(\"dc_generator\", params={\"amplitude\": 1E12 * I_stim})  # 1E12: convert A to pA\n",
-    "        nest.Connect(dc, neuron)\n",
-    "\n",
-    "#         multimeter = nest.Create('multimeter')\n",
-    "#         nest.SetStatus(multimeter, {\"record_from\": [\"U\"]})\n",
-    "#         nest.Connect(multimeter, neuron)\n",
+    "# Neuron parameters\n",
+    "params = {\n",
+    "    'tau_m'   : 10.0,\n",
+    "    't_ref'   : 2.0,\n",
+    "    'C_m'     : 250.0,\n",
+    "    'V_r'     : -65.0,\n",
+    "    'V_reset' : -65.0,\n",
+    "    'a'       : 1.2,\n",
+    "    'b'       : 27.0,\n",
+    "    'V_b'     : -51.3\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nestml_gl_exp_model = \"\"\"\n",
+    "neuron gl_exp:\n",
+    "    state:\n",
+    "        refr_spikes_buffer mV = 0 mV\n",
+    "        refr_tick integer = 0    # Counts number of tick during the refractory period\n",
+    "        V_m mV = V_r     # Membrane potential\n",
+    "\n",
+    "    equations:\n",
+    "        kernel G = delta(t)\n",
+    "        V_m' = -(V_m - V_r) / tau_m + (mV / ms) * convolve(G, spikes) + (I_e + I_stim) / C_m\n",
+    "\n",
+    "    parameters:\n",
+    "        tau_m   ms   = 10 ms              # Membrane time constant\n",
+    "        C_m     pF   = 250 pF             # Capacity of the membrane\n",
+    "        t_ref   ms   = 2 ms               # Duration of refractory period\n",
+    "        tau_syn ms   = 0.5 ms             # Time constant of synaptic current\n",
+    "        V_r     mV   = -65 mV             # Resting membrane potential\n",
+    "        V_reset mV   = -65 mV             # Reset potential of the membrane\n",
+    "        b     real   = 27                 # Parameter for the exponential curve\n",
+    "        a       mV   = 5 mV               # Parameter for the exponential curve\n",
+    "        V_b mV       = -51.3 mV             # Membrane potential at which phi(V)=1/b\n",
+    "        with_refr_input boolean = false # If true, do not discard input during refractory period.\n",
+    "        reset_after_spike boolean = true\n",
+    "\n",
+    "        # constant external input current\n",
+    "        I_e pA = 0 pA\n",
+    "\n",
+    "    internals:\n",
+    "        RefractoryCounts integer = steps(t_ref) # refractory time in steps\n",
+    "\n",
+    "    input:\n",
+    "        spikes <- spike\n",
+    "        I_stim pA <- continuous\n",
+    "\n",
+    "    output:\n",
+    "        spike\n",
+    "\n",
+    "    function phi(V_m mV) real:\n",
+    "        return ((1/b) * exp((V_m - V_b)/mV/a))\n",
+    "\n",
+    "    update:\n",
+    "        if refr_tick == 0: # neuron not refractory\n",
+    "            integrate_odes()\n",
+    "\n",
+    "            # if we have accumulated spikes from refractory period,\n",
+    "            # add and reset accumulator\n",
+    "            if with_refr_input and refr_spikes_buffer != 0.0 mV:\n",
+    "                V_m += refr_spikes_buffer\n",
+    "                refr_spikes_buffer = 0.0 mV\n",
+    "\n",
+    "        else: # neuron is absolute refractory\n",
+    "            # read spikes from buffer and accumulate them, discounting\n",
+    "            # for decay until end of refractory period\n",
+    "            # the buffer is clear automatically\n",
+    "            if with_refr_input:\n",
+    "                refr_spikes_buffer += spikes * exp(-refr_tick * h / tau_m) * mV * s\n",
+    "            refr_tick -= 1\n",
+    "\n",
+    "        tmp real = phi(V_m)\n",
+    "        println(\"{V_m} ---> {tmp}\")\n",
+    "            \n",
+    "        if random_uniform(0, 1) <= 1E-3 * resolution() * phi(V_m):\n",
+    "            refr_tick = RefractoryCounts\n",
+    "            if reset_after_spike:\n",
+    "                V_m = V_reset\n",
+    "            emit_spike()\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "module_name, neuron_model_name = NESTCodeGeneratorUtils.generate_code_for(\n",
+    "    nestml_neuron_model=nestml_gl_exp_model,\n",
+    "    logging_level=\"INFO\"  # try \"INFO\" for more debug information\n",
+    ")\n",
     "\n",
+    "nest.Install(module_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def measure_numerical_Phi_function(neuron_model_name, U_min=0., U_max=10., neuron_model_params=None, neuron_membrane_potential_name=\"U\"):\n",
+    "    nest.ResetKernel()\n",
+    "    nest.resolution = 1.   # check that results are independent of resolution...\n",
+    "    \n",
+    "    t_stop = 25000.\n",
+    "    \n",
+    "    U_range = np.linspace(U_min, U_max, 12)\n",
+    "    n_spikes = np.nan * np.ones_like(U_range)\n",
+    "    for i, U in enumerate(U_range):\n",
+    "        neuron = nest.Create(neuron_model_name)\n",
+    "        if neuron_model_params:\n",
+    "            neuron.set(neuron_model_params)\n",
+    "            \n",
+    "        neuron.set({neuron_membrane_potential_name: U})\n",
+    "        assert neuron.get(neuron_membrane_potential_name) == U\n",
+    "    \n",
     "        sr = nest.Create('spike_recorder')\n",
     "        nest.Connect(neuron, sr)\n",
-    "\n",
+    "    \n",
     "        nest.Simulate(t_stop)\n",
+    "        assert neuron.get(neuron_membrane_potential_name) == U\n",
+    "    \n",
+    "        n_spikes[i] = len(sr.events[\"times\"])\n",
+    "    \n",
+    "    spike_rate = n_spikes / (t_stop / 1E3)\n",
     "\n",
-    "#         Vms = multimeter.events[\"U\"]\n",
-    "#         ts = multimeter.events[\"times\"]\n",
+    "    return U_range, spike_rate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "\n",
-    "        rate[i] = sr.n_events / t_stop * 1000\n",
-    "    \n",
-    "    return I_stim_vec, rate"
+    "# theoretical Phi vs U\n",
+    "U_range_theory = np.linspace(-60., -45., 100)\n",
+    "Phi_of_U_theory = (1 / params['b']) * np.exp((U_range_theory - params['V_b']) / params['a'])\n",
+    "\n",
+    "# numerical Phi vs U\n",
+    "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n",
+    "                                                                     U_min=-60.,\n",
+    "                                                                     U_max=-45.,\n",
+    "                                                                     neuron_model_params={\"reset_after_spike\": False,\n",
+    "                                                                                          \"a\": params['a'],\n",
+    "                                                                                          \"b\": params['b'],\n",
+    "                                                                                          \"V_b\": params['V_b'],\n",
+    "                                                                                          \"tau_m\": 1E99},\n",
+    "                                                                     neuron_membrane_potential_name=\"V_m\")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n",
+    "ax.plot(U_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n",
+    "ax.legend()\n",
+    "ax.set_xlabel(\"$U$\")\n",
+    "ax.set_ylabel(\"Firing rate [Hz]\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "spike_rate_numeric"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -105,7 +291,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -123,7 +309,7 @@
     "    deliver_spike(R_pre - 1, the_delay)\n",
     "\n",
     "  input:\n",
-    "    incoming_spikes real <- spike\n",
+    "    incoming_spikes <- spike\n",
     "  \n",
     "  output:\n",
     "    spike\n",
@@ -142,7 +328,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -158,7 +344,7 @@
     "    reset_after_spike boolean = true\n",
     "\n",
     "  input:\n",
-    "    incoming_spikes real <- spike\n",
+    "    incoming_spikes <- spike\n",
     "\n",
     "  output:\n",
     "    spike\n",
@@ -175,7 +361,7 @@
     "    kernel K = delta(t)\n",
     "    \n",
     "    # R is presynaptic neuron's R and is passed as the spike weight by the synapse\n",
-    "    U' = -U / (1E3/beta) + alpha_over_N * convolve(K, incoming_spikes) / ms\n",
+    "    U' = -U / (1E3 / beta) + alpha_over_N * convolve(K, incoming_spikes) / ms\n",
     "\n",
     "  update:\n",
     "    # integrate spike input\n",
@@ -191,195 +377,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1,GLOBAL, INFO]: List of files that will be processed:\n",
-      "[2,GLOBAL, INFO]: /home/charl/julich/gl_neuron/nestml_gl_ca_model.nestml\n",
-      "[3,GLOBAL, INFO]: /home/charl/julich/gl_neuron/nestml_gl_ca_synapse_model.nestml\n",
-      "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/tmp/nestml-gl-ca-target'\n",
-      "[5,GLOBAL, INFO]: Start processing '/home/charl/julich/gl_neuron/nestml_gl_ca_model.nestml'!\n",
-      "[6,gl_ca_nestml, DEBUG, [2:0;40:0]]: Start building symbol table!\n",
-      "[7,gl_ca_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n",
-      "[8,gl_ca_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n",
-      "[9,gl_ca_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[10,gl_ca_nestml, WARNING, [30:9;30:23]]: Implicit casting from (compatible) type '1 / ms' to 'real'.\n",
-      "[11,gl_ca_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[12,gl_ca_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[13,gl_ca_nestml, WARNING, [37:7;37:58]]: SPL_COMPARISON_OPERATOR_VISITOR : Operands of a logical rhs not compatible.([37:7;37:58])\n",
-      "[14,gl_ca_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[15,GLOBAL, INFO]: Start processing '/home/charl/julich/gl_neuron/nestml_gl_ca_synapse_model.nestml'!\n",
-      "[16,syn_gl_ca_nestml, DEBUG, [2:0;21:0]]: Start building symbol table!\n",
-      "[17,syn_gl_ca_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n",
-      "[18,syn_gl_ca_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[19,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: master\n",
-      "[20,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-upstream/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n",
-      "[21,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-upstream/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n",
-      "[22,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-upstream/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n",
-      "[23,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n",
-      "[24,gl_ca_nestml, DEBUG, [2:0;40:0]]: Start building symbol table!\n",
-      "[25,gl_ca_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n",
-      "[26,gl_ca_nestml, WARNING, [27:4;30:4]]: Variable 'K' has the same name as a physical unit!\n",
-      "[27,gl_ca_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[28,gl_ca_nestml, INFO, [4:13;4:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[29,gl_ca_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[30,gl_ca_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[31,syn_gl_ca_nestml, DEBUG, [2:0;21:0]]: Start building symbol table!\n",
-      "[32,syn_gl_ca_nestml, INFO, [21:17;21:44]]: Implicit casting from (compatible) type 'ms' to 'real'.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:Analysing input:\n",
-      "INFO:{\n",
-      "    \"dynamics\": [\n",
-      "        {\n",
-      "            \"expression\": \"U' = (-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\",\n",
-      "            \"initial_values\": {\n",
-      "                \"U\": \"0\"\n",
-      "            }\n",
-      "        }\n",
-      "    ],\n",
-      "    \"options\": {\n",
-      "        \"output_timestep_symbol\": \"__h\"\n",
-      "    },\n",
-      "    \"parameters\": {\n",
-      "        \"a\": \"3.0\",\n",
-      "        \"alpha_over_N\": \"1.0777744654743957\",\n",
-      "        \"beta\": \"50\",\n",
-      "        \"reset_after_spike\": \"true\"\n",
-      "    }\n",
-      "}\n",
-      "INFO:Processing global options...\n",
-      "INFO:Processing input shapes...\n",
-      "INFO:\n",
-      "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n",
-      "DEBUG:Splitting expression -0.001*U*beta (symbols [U])\n",
-      "DEBUG:\tlinear factors: Matrix([[-0.001*beta]])\n",
-      "DEBUG:\tinhomogeneous term: 0.0\n",
-      "DEBUG:\tnonlinear term: 0.0\n",
-      "DEBUG:Created Shape with symbol U, derivative_factors = [-0.001*beta], inhom_term = 0.0, nonlin_term = 0.0\n",
-      "INFO:\tReturning shape: Shape \"U\" of order 1\n",
-      "INFO:Shape U: reconstituting expression -0.001*U*beta\n",
-      "INFO:All known variables: [U], all parameters used in ODEs: {beta}\n",
-      "INFO:\n",
-      "Processing differential-equation form shape U with defining expression = \"(-U) / (1000.0 / beta) + alpha_over_N * 0 / 1.0\"\n",
-      "DEBUG:Splitting expression -0.001*U*beta (symbols [U, U])\n",
-      "DEBUG:\tlinear factors: Matrix([[-0.001*beta], [0]])\n",
-      "DEBUG:\tinhomogeneous term: 0.0\n",
-      "DEBUG:\tnonlinear term: 0.0\n",
-      "DEBUG:Created Shape with symbol U, derivative_factors = [-0.001*beta], inhom_term = 0.0, nonlin_term = 0\n",
-      "INFO:\tReturning shape: Shape \"U\" of order 1\n",
-      "INFO:Shape U: reconstituting expression -0.001*U*beta\n",
-      "DEBUG:Splitting expression -0.001*U*beta (symbols Matrix([[U]]))\n",
-      "DEBUG:\tlinear factors: Matrix([[-0.001*beta]])\n",
-      "DEBUG:\tinhomogeneous term: 0.0\n",
-      "DEBUG:\tnonlinear term: 0.0\n",
-      "DEBUG:Initializing system of shapes with x = Matrix([[U]]), A = Matrix([[-0.001*beta]]), b = Matrix([[0.0]]), c = Matrix([[0.0]])\n",
-      "INFO:Dependency analysis...\n",
-      "INFO:Shape U: reconstituting expression -0.001*U*beta\n",
-      "DEBUG:Splitting expression -0.001*U*beta (symbols [U])\n",
-      "DEBUG:\tlinear factors: Matrix([[-0.001*beta]])\n",
-      "DEBUG:\tinhomogeneous term: 0.0\n",
-      "DEBUG:\tnonlinear term: 0.0\n",
-      "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_before.dot\n",
-      "DEBUG:write 88 bytes to '/tmp/ode_dependency_graph_before.dot'\n",
-      "DEBUG:run ['dot', '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_before.dot']\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[33,syn_gl_ca_nestml, INFO, [11:13;11:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[34,GLOBAL, INFO]: Analysing/transforming neuron 'gl_ca_nestml'\n",
-      "[35,gl_ca_nestml, INFO, [2:0;40:0]]: Starts processing of the model 'gl_ca_nestml'\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n",
-      "DEBUG:write 88 bytes to '/tmp/ode_dependency_graph.dot'\n",
-      "DEBUG:run ['dot', '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n",
-      "INFO:Generating propagators for the following symbols: U\n",
-      "DEBUG:Initializing system of shapes with x = Matrix([[U]]), A = Matrix([[-0.001*beta]]), b = Matrix([[0.0]]), c = Matrix([[0]])\n",
-      "INFO:In ode-toolbox: returning outdict = \n",
-      "INFO:[\n",
-      "    {\n",
-      "        \"initial_values\": {\n",
-      "            \"U\": \"0\"\n",
-      "        },\n",
-      "        \"parameters\": {\n",
-      "            \"beta\": \"50.0000000000000\"\n",
-      "        },\n",
-      "        \"propagators\": {\n",
-      "            \"__P__U__U\": \"1.0*exp(-0.001*__h*beta)\"\n",
-      "        },\n",
-      "        \"solver\": \"analytical\",\n",
-      "        \"state_variables\": [\n",
-      "            \"U\"\n",
-      "        ],\n",
-      "        \"update_expressions\": {\n",
-      "            \"U\": \"U*__P__U__U\"\n",
-      "        }\n",
-      "    }\n",
-      "]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[36,gl_ca_nestml, DEBUG, [2:0;40:0]]: Start building symbol table!\n",
-      "[37,gl_ca_nestml, INFO, <ADDED_BY_SOLVER>]: Implicit casting from (compatible) type 'ms' to 'real'.\n",
-      "[38,gl_ca_nestml, WARNING, [7:4;7:13]]: Variable 'a' has the same name as a physical unit!\n",
-      "[39,gl_ca_nestml, INFO, [20:13;20:13]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[40,gl_ca_nestml, INFO, [9:16;9:16]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[41,gl_ca_nestml, INFO, [40:14;40:14]]: Implicit casting from (compatible) type 'integer' to 'real'.\n",
-      "[42,GLOBAL, INFO]: Analysing/transforming synapse syn_gl_ca_nestml.\n",
-      "[43,syn_gl_ca_nestml, INFO, [2:0;21:0]]: Starts processing of the model 'syn_gl_ca_nestml'\n",
-      "[44,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/gl_ca_nestml.cpp\n",
-      "[45,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/gl_ca_nestml.h\n",
-      "[46,gl_ca_nestml, INFO, [2:0;40:0]]: Successfully generated code for the model: 'gl_ca_nestml' in: '/tmp/nestml-gl-ca-target' !\n",
-      "[47,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/syn_gl_ca_nestml.h\n",
-      "[48,syn_gl_ca_nestml, INFO, [2:0;21:0]]: Successfully generated code for the model: 'syn_gl_ca_nestml' in: '/tmp/nestml-gl-ca-target' !\n",
-      "[49,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/CMakeLists.txt\n",
-      "[50,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/nestml_gl_ca_module.h\n",
-      "[51,GLOBAL, INFO]: Rendering template /tmp/nestml-gl-ca-target/nestml_gl_ca_module.cpp\n",
-      "[52,GLOBAL, INFO]: Successfully generated NEST module code in '/tmp/nestml-gl-ca-target' !\n"
-     ]
-    }
-   ],
-   "source": [
-    "with open(\"nestml_gl_ca_synapse_model.nestml\", \"w\") as nestml_model_file:\n",
-    "    print(nestml_gl_ca_synapse_model, file=nestml_model_file)\n",
-    "\n",
-    "with open(\"nestml_gl_ca_model.nestml\", \"w\") as nestml_model_file:\n",
-    "    print(nestml_gl_ca_neuron_model, file=nestml_model_file)\n",
-    "\n",
-    "generate_nest_target(input_path=[\"nestml_gl_ca_model.nestml\", \"nestml_gl_ca_synapse_model.nestml\"],\n",
-    "                     target_path=\"/tmp/nestml-gl-ca-target\",\n",
-    "                     module_name=\"nestml_gl_ca_module\",\n",
-    "                     suffix=\"_nestml\",\n",
-    "                     logging_level=\"DEBUG\"#WARNING  # try \"INFO\" for more debug information\n",
-    "                    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "nest.Install(\"nestml_gl_ca_module\")\n"
+    "module_name, neuron_model_name, synapse_model_name = NESTCodeGeneratorUtils.generate_code_for(\n",
+    "    nestml_neuron_model=nestml_gl_ca_neuron_model,\n",
+    "    nestml_synapse_model=nestml_gl_ca_synapse_model,\n",
+    "    logging_level=\"INFO\"  # try \"INFO\" for more debug information\n",
+    ")\n",
+    "\n",
+    "nest.Install(module_name)"
    ]
   },
   {
@@ -397,7 +405,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -433,32 +441,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x7efcb30b4f70>"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "ts, Vms_gl = measure_postsynaptic_response(\"gl_ca_nestml\", \"syn_gl_ca_nestml\", V_m_specifier=\"U\")\n",
     "\n",
@@ -485,79 +470,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "nest.ResetKernel()\n",
-    "nest.resolution = 1.   # check that results are independent of resolution...\n",
-    "\n",
-    "a = 3.\n",
-    "\n",
-    "t_stop = 25000.\n",
-    "\n",
-    "U_range = np.linspace(0., 10., 12)\n",
-    "n_spikes = np.nan * np.ones_like(U_range)\n",
-    "for i, U in enumerate(U_range):\n",
-    "    neuron = nest.Create(\"gl_ca_nestml\", params={\"reset_after_spike\": False})\n",
-    "    neuron.beta = 1E-99   # a very low value, to prevent the membrane potential from decaying\n",
-    "    neuron.U = U\n",
-    "    neuron.a = a\n",
-    "\n",
-    "    sr = nest.Create('spike_recorder')\n",
-    "    nest.Connect(neuron, sr)\n",
-    "\n",
-    "    nest.Simulate(t_stop)\n",
-    "\n",
-    "    n_spikes[i] = len(sr.events[\"times\"])\n",
-    "\n",
-    "spike_rate = n_spikes / (t_stop / 1E3)"
+    "#theoretical Phi vs U\n",
+    "a = 3\n",
+    "U_range_theory = np.linspace(0., 10., 100)\n",
+    "Phi_of_U_theory = (4 * a) / (1 + np.exp(a - U_range_theory)) - (4 * a) / (1 + np.exp(a))\n",
+    "\n",
+    "# numerical Phi vs U\n",
+    "U_range_numeric, spike_rate_numeric = measure_numerical_Phi_function(neuron_model_name=neuron_model_name,\n",
+    "                                                                     neuron_model_params={\"reset_after_spike\": False,\n",
+    "                                                                                          \"beta\": 1E-99,   # a very low value, to prevent the membrane potential from decaying\n",
+    "                                                                                          \"a\": 3.})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": [
-    "_U = np.linspace(0., 10., 100)\n",
-    "Phi_of_U = (4 * a) / (1 + np.exp(a - _U)) - (4 * a) / (1 + np.exp(a))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0, 0.5, 'Firing rate [Hz]')"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "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": [
     "fig, ax = plt.subplots()\n",
-    "ax.plot(_U, Phi_of_U, label=\"theoretical\")\n",
-    "ax.set_xlabel(\"$U$\")\n",
-    "\n",
-    "ax.plot(U_range, spike_rate, marker=\"o\", label=\"numeric\")\n",
+    "ax.plot(U_range_theory, Phi_of_U_theory, label=\"theory\")\n",
+    "ax.plot(U_range_numeric, spike_rate_numeric, marker=\"o\", label=\"numeric\")\n",
     "ax.legend()\n",
     "ax.set_xlabel(\"$U$\")\n",
     "ax.set_ylabel(\"Firing rate [Hz]\")"
@@ -572,7 +509,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -620,7 +557,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -642,27 +579,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "9900 synapses in the network\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'nest.Simulate(sim_time)\\n\\nneuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\\n\\nfig, ax = plt.subplots(nrows=2)\\n\\nU_avg = np.zeros(len(np.unique( multimeter.get(\"events\")[\"times\"])))\\n# R_avg = np.zeros_like(U_avg)\\nfor neuron_id in range(1, N+1):\\n    idx = np.where(neuron_id == multimeter.get(\"events\")[\"senders\"])\\n    times = multimeter.get(\"events\")[\"times\"][idx]\\n    U = multimeter.get(\"events\")[\"U\"][idx]\\n    #R = multimeter.get(\"events\")[\"R\"][idx]\\n    \\n    U_avg += U / N\\n    #R_avg += R / N\\n\\n    if neuron_id < 100:\\n        ax[0].plot(U, label=\"U\")\\n#         ax[1].plot(R, label=\"R\")\\n\\nax[0].plot(U_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[0].set_ylabel(\"U\")\\n# ax[1].plot(R_avg, linewidth=4, linestyle=\"--\", c=\"black\")\\nax[1].set_ylabel(\"R\")\\n\\nfor _ax in ax:\\n    _ax.set_xlim(0, sim_time)\\nax[-1].set_xlabel(\"Time [ms]\")'"
-      ]
-     },
-     "execution_count": 63,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "nest.ResetKernel()\n",
     "nest.resolution = .1 # [ms]\n",
@@ -732,32 +651,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0.5, 0.98, 'R')"
-      ]
-     },
-     "execution_count": 64,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "times = log[\"t\"]\n",
     "R_pre = np.array(log[\"R_pre\"])\n",
@@ -775,32 +671,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0, 0.5, 'Neuron')"
-      ]
-     },
-     "execution_count": 65,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "fig, ax = plt.subplots()\n",
     "ax.scatter(sr.events[\"times\"], sr.events[\"senders\"])\n",
@@ -812,17 +685,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Network average firing rate: 7.22 Hz\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "avg_firing_rate = len(sr.events[\"times\"]) / N / (sim_time / 1E3)\n",
     "print(\"Network average firing rate: \" + str(avg_firing_rate) + \" Hz\")"
@@ -830,32 +695,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0.5, 0.98, 'U')"
-      ]
-     },
-     "execution_count": 67,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "neuron_ids = np.unique(multimeter.get(\"events\")[\"senders\"])\n",
     "\n",
@@ -887,295 +729,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 74,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(0.01, 6)"
-      ]
-     },
-     "execution_count": 74,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02,\n",
-      "       2.e+03, 3.e+03, 4.e+03, 5.e+03, 6.e+03, 7.e+03, 8.e+03, 9.e+03,\n",
-      "       2.e+04, 3.e+04, 4.e+04, 5.e+04, 6.e+04, 7.e+04, 8.e+04, 9.e+04])\n",
-      "DEBUG:vmin 0.1 vmax 150.00000000000003\n",
-      "DEBUG:ticklocs array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([2.e-03, 3.e-03, 4.e-03, 5.e-03, 6.e-03, 7.e-03, 8.e-03, 9.e-03,\n",
-      "       2.e-02, 3.e-02, 4.e-02, 5.e-02, 6.e-02, 7.e-02, 8.e-02, 9.e-02,\n",
-      "       2.e-01, 3.e-01, 4.e-01, 5.e-01, 6.e-01, 7.e-01, 8.e-01, 9.e-01,\n",
-      "       2.e+00, 3.e+00, 4.e+00, 5.e+00, 6.e+00, 7.e+00, 8.e+00, 9.e+00,\n",
-      "       2.e+01, 3.e+01, 4.e+01, 5.e+01, 6.e+01, 7.e+01, 8.e+01, 9.e+01,\n",
-      "       2.e+02, 3.e+02, 4.e+02, 5.e+02, 6.e+02, 7.e+02, 8.e+02, 9.e+02])\n",
-      "DEBUG:vmin 0.01 vmax 6.0\n",
-      "DEBUG:ticklocs array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "def phi(x):\n",
     "    return (4 * a) / (1 + np.exp(a - x)) - (4 * a) / (1 + np.exp(a))\n",
@@ -1221,39 +777,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([1.000001  , 1.000001  , 1.000001  , 1.000001  , 1.000001  ,\n",
-       "       1.000001  , 1.000001  , 1.000001  , 1.000001  , 1.000001  ,\n",
-       "       1.000001  , 1.000001  , 1.000001  , 1.000001  , 1.000001  ,\n",
-       "       1.000001  , 1.000001  , 1.000001  , 1.000001  , 1.000001  ,\n",
-       "       1.000001  , 1.000001  , 1.000001  , 1.000001  , 1.000001  ,\n",
-       "       1.000001  , 1.000001  , 1.000001  , 1.00300352, 1.01745214,\n",
-       "       1.04660356, 1.07771535, 1.0945982 , 1.11059174, 1.13160081,\n",
-       "       1.1537244 , 1.19368034, 1.2296995 , 1.23619288, 1.24299194,\n",
-       "       1.25121745, 1.25996716, 1.27042049, 1.27861199, 1.28137508,\n",
-       "       1.28204592, 1.27888097, 1.28195025, 1.2939256 , 1.31626105,\n",
-       "       1.3502516 , 1.37491056, 1.39127477, 1.40875991, 1.4270297 ,\n",
-       "       1.43653067, 1.44124865, 1.45098255, 1.46280642, 1.46616047,\n",
-       "       1.46690843, 1.47431492, 1.48314824, 1.48885841, 1.49415215,\n",
-       "       1.51117633, 1.52893365, 1.54096831, 1.55291985, 1.56354141,\n",
-       "       1.57463788, 1.5892962 , 1.60229652, 1.60755957, 1.61317211,\n",
-       "       1.61992048, 1.6245497 , 1.62409297, 1.62706259, 1.63631383,\n",
-       "       1.64291825, 1.64574151, 1.65316801, 1.66577316, 1.67533165,\n",
-       "       1.68218202, 1.6861765 , 1.68817186, 1.68556492, 1.68044764,\n",
-       "       1.68633867, 1.69681649, 1.70022491, 1.70145813, 1.69743879,\n",
-       "       1.6922939 , 1.69586305, 1.70059406, 1.70087235, 1.70087235])"
-      ]
-     },
-     "execution_count": 75,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "R_pre_intrp"
    ]
@@ -1302,7 +828,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.2"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,