doc/tutorials/tutorial3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('../../src/')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DidgeLab tutorial part 3 - Optimization through Computational Evolution\n",
    "\n",
    "So in the first tutorial we learned how to create didgeridoo geometries and how to analyze their sonic properties. In the second tutorial, we learned how to generate geometries from parametric shapes. In this tutorial, we will learn how to optimize the shapes through computational evolution.\n",
    "\n",
    "In the first tutorial we defined a didgeridoo geometry and computed its sonic properties. In this tutorial, we want to reverse this: We define sonic properties and then come up with a didgeridoo geometry that has these properties. Because this is 1000x times more interesting, right?\n",
    "ted\n",
    "First I need to explain computational evolution and I try to make this as non-mathematical as possible.\n",
    "\n",
    "Lets say we want to compute a Didgeridoo with a drone frequency of 73.4 Hz (which is D1). So how would you do this using the tools from tutorial 1? You would start with some kind of geometry. Maybe you already have an idea about didgeridoo acoustics, so you add a bell or make it cylindrical or you start with any other basic shape. Then you run the acoustical simulation and find out that that your didgeridoo has drone frequency for example 80 Hz. Then you change the shape. Whenever you get closer to your target (lets say you get a geometry with drone frequency 75 Hz), then you use this geometry and modify it further, until you are closer to the target.\n",
    "\n",
    "### Loss Function\n",
    "\n",
    "Computational evolution is very similar, except that is is automatic. It is a mathematical optimization algorithm. Now we need to get a bit mathematical, excuse me :) So it is an optimization algorithm, but what exactly do we want to optimize? We want to optimize the difference between our target properties and the properties our best geometry has. In DidgeLab, we formulate this differene as the loss function. The loss function defines how far we are away from our target. So, in above example, we could define the loss function as `loss(geo) = | drone_frequency(geo) - 73.4 Hz |`. So the loss function is the difference between the frequency of our didgeridoo and the target frequency. The `|` means that we use the absolute value: So in case our didgeridoo has drone frequency 50 Hz, then `drone_frequency(geo) - 73.4 Hz` would be negative. The absolute function turns all negative values positive. Using a loss function we can compare two didgeridoo shapes with each other and determine which one is closer to the target. The geometry that produces a lower loss is closer to the target.\n",
    "\n",
    "Loss functions can be much more complicated than this. We can say that we want a bell size between 65 and 75mm, a certain drone frequency, certain overblow frequencies, we can add loss if the didgeridoo gets narrower instead of wider along the bore, and much more. The loss function is super important for the artificial evolution.\n",
    "\n",
    "Computational evolution usually uses a fitness function, that determines which of two individuals (which of two didgeridoo shapes) is fitter or better. For reasons I dont remember anymore we use a loss function, so we determine which of two shapes is worse. In the end it really does not matter if you use fitness or loss, so for DidgeLab we go with loss.\n",
    "\n",
    "## Computational evolution\n",
    "\n",
    "So our goal is still the optimization of a didgeridoo geometries. Now we can compare two geometries which each other and find out which of the two is closer to the goal. So how exactly do we utilize that to come up with a shape that is close to the goal? First I explain the basic concept and than I explain the actual implementation, which is a bit more complex than the basic concept.\n",
    "\n",
    "So for the basic concept, we start with a parametric shape (you remember these from tutorial 2?). This parametric shape already has some of our expectations embedded. E.g., we know that our didgeridoo should have a certain mouth piece size, a bell, and more. Also it has a set of parameters (e.g. bell size, length and others). The parameter set determines the geometry which determines the sonic properties. In computational evolution we have the notion of the \"fittest\" individual or the fittest parameter set, which is the individual with the smallest value of the loss function. When we begin, we have only a single individual so this is the fittest individual.\n",
    "\n",
    "Now we randomly mutate this individual. For each mutant we compute the loss. If the loss is smaller than the loss of the fittest individual, than this mutant becomes the next fittest individual. Lets say we run this process over 1000 mutations. Each of these mutations is called a generation. At each of these 1000 generations, we mutate the fittest individual. Over the course of 1000 generations, the loss will never become bigger. The loss should always become smaller. And hopefully at the end of 1000 mutations, our geometry should have the properties which we defined over the loss.\n",
    "\n",
    "So here you should take a deep breath and see if you understood this basic concept. Can you understand why this algorithm leads to geometries that have produce a low loss and can you understand how the loss function relates to the didgeridoo properties that we want to generate?\n",
    "\n",
    "The actual implementation of computational evolution is a bit more complex. First of all, we do not do this one time, but several, usually 10, times. So in the end of the process we have 10 fittest individuals to choose from. We call the group of 10 mutants, that we mutate in parallel, the mutant pool.\n",
    "\n",
    "The evolution has two phases, the exploration phase and the fine tuning phase. In the exporation phase, the mutation changes all parameters in a drastical way. In this way we try to come up with shapes that are close to what we want. In the fine tuning phase, the mutation changes only single parameters and it does not change them so drastically. In the fine tuning phase, we want to push the shapes closer to their target.\n",
    "\n",
    "To better utilize parallelization and multiple CPU cores, each generation has a generation size, of e.g. 100. So each fittest individual in the mutant pool is mutated 100 times. Then these 100 mutations are compared to each other and the next fittest individual is selected. This determines the father shape for the next generation.\n",
    "\n",
    "## Practical example\n",
    "\n",
    "Enough theory. Lets define a loss function and play around with it. First we start with one of the shapes. We print the parameters of MbeyaShape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "                  name    value     min      max  mutable\n",
       "0             l_gerade  1000.00  500.00  1500.00    False\n",
       "1             d_gerade     1.05    0.90     1.20    False\n",
       "2   n_opening_segments     4.00    0.00     8.00    False\n",
       "3     opening_factor_x     0.00   -2.00     2.00    False\n",
       "4     opening_factor_y     0.00   -2.00     2.00    False\n",
       "5       opening_length   850.00  700.00  1000.00    False\n",
       "6           d_pre_bell    45.00   40.00    50.00    False\n",
       "7               l_bell    35.00   20.00    50.00    False\n",
       "8             bellsize    17.50    5.00    30.00    False\n",
       "9         add_bubble_0     0.50    0.00     1.00    False\n",
       "10     bubble_height_0     0.50    0.00     1.00    False\n",
       "11        bubble_pos_0     0.50    0.00     1.00    False\n",
       "12      bubble_width_0   150.00    0.00   300.00    False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from cad.calc.parameters import MbeyaShape\n",
    "from cad.cadsd.cadsd import CADSD\n",
    "\n",
    "parameters = MbeyaShape()\n",
    "parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here are the initial resonant frequencies of the shape. Remember, the first resonant frequency is the drone note, the 2nd is the first toot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>freq</th>\n",
       "      <th>impedance</th>\n",
       "      <th>rel_imp</th>\n",
       "      <th>note-number</th>\n",
       "      <th>cent-diff</th>\n",
       "      <th>note-name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1607</th>\n",
       "      <td>61.9</td>\n",
       "      <td>2.875512e+07</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-34</td>\n",
       "      <td>-4.609349</td>\n",
       "      <td>B1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>147.0</td>\n",
       "      <td>5.573990e+06</td>\n",
       "      <td>0.193843</td>\n",
       "      <td>-19</td>\n",
       "      <td>-1.975158</td>\n",
       "      <td>D2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>229</th>\n",
       "      <td>230.0</td>\n",
       "      <td>5.641366e+06</td>\n",
       "      <td>0.196187</td>\n",
       "      <td>-11</td>\n",
       "      <td>23.043595</td>\n",
       "      <td>A#3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>323</th>\n",
       "      <td>324.0</td>\n",
       "      <td>2.158769e+06</td>\n",
       "      <td>0.075074</td>\n",
       "      <td>-5</td>\n",
       "      <td>29.811653</td>\n",
       "      <td>E3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>409</th>\n",
       "      <td>410.0</td>\n",
       "      <td>1.914547e+06</td>\n",
       "      <td>0.066581</td>\n",
       "      <td>-1</td>\n",
       "      <td>22.255537</td>\n",
       "      <td>G#3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>504</th>\n",
       "      <td>505.0</td>\n",
       "      <td>1.116385e+06</td>\n",
       "      <td>0.038824</td>\n",
       "      <td>2</td>\n",
       "      <td>-38.535837</td>\n",
       "      <td>B4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>591</th>\n",
       "      <td>592.0</td>\n",
       "      <td>9.217152e+05</td>\n",
       "      <td>0.032054</td>\n",
       "      <td>5</td>\n",
       "      <td>-13.712383</td>\n",
       "      <td>D4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>694</th>\n",
       "      <td>695.0</td>\n",
       "      <td>7.223093e+05</td>\n",
       "      <td>0.025119</td>\n",
       "      <td>8</td>\n",
       "      <td>8.588655</td>\n",
       "      <td>F4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>801</th>\n",
       "      <td>802.0</td>\n",
       "      <td>6.221572e+05</td>\n",
       "      <td>0.021636</td>\n",
       "      <td>10</td>\n",
       "      <td>-39.318456</td>\n",
       "      <td>G4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>900</th>\n",
       "      <td>901.0</td>\n",
       "      <td>8.624649e+05</td>\n",
       "      <td>0.029993</td>\n",
       "      <td>12</td>\n",
       "      <td>-40.828299</td>\n",
       "      <td>A5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>993</th>\n",
       "      <td>994.0</td>\n",
       "      <td>8.691892e+05</td>\n",
       "      <td>0.030227</td>\n",
       "      <td>14</td>\n",
       "      <td>-10.890794</td>\n",
       "      <td>B5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       freq     impedance   rel_imp  note-number  cent-diff note-name\n",
       "1607   61.9  2.875512e+07  1.000000          -34  -4.609349        B1\n",
       "146   147.0  5.573990e+06  0.193843          -19  -1.975158        D2\n",
       "229   230.0  5.641366e+06  0.196187          -11  23.043595       A#3\n",
       "323   324.0  2.158769e+06  0.075074           -5  29.811653        E3\n",
       "409   410.0  1.914547e+06  0.066581           -1  22.255537       G#3\n",
       "504   505.0  1.116385e+06  0.038824            2 -38.535837        B4\n",
       "591   592.0  9.217152e+05  0.032054            5 -13.712383        D4\n",
       "694   695.0  7.223093e+05  0.025119            8   8.588655        F4\n",
       "801   802.0  6.221572e+05  0.021636           10 -39.318456        G4\n",
       "900   901.0  8.624649e+05  0.029993           12 -40.828299        A5\n",
       "993   994.0  8.691892e+05  0.030227           14 -10.890794        B5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geo = parameters.make_geo()\n",
    "cadsd = CADSD(geo)\n",
    "cadsd.get_notes()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we define a loss function. Lets say we want to make a Didgeridoo form that has a drone note of D and an octave toot. Also we want to ensure that the first three peaks have an impedance of more than 4e+06 because a peak does not need tuning alone, it also needs a certain impedance to be playable.\n",
    "\n",
    "So here is the source code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cad.calc.loss import LossFunction, TootTuningHelper, diameter_loss, single_note_loss\n",
    "from cad.calc.conv import note_to_freq\n",
    "import tqdm as tqdm\n",
    "from cad.calc.parameters import FinetuningParameters\n",
    "\n",
    "# first we define the loss function\n",
    "class TutorialLoss(LossFunction):\n",
    "\n",
    "    def __init__(self):\n",
    "        \n",
    "        self.target_notes = [-31, -19]\n",
    "        self.target_freqs = [note_to_freq(note) for note in self.target_notes]\n",
    "        self.min_impedance = 4e+6\n",
    "    \n",
    "    # Every loss function implements the get_loss method that computes the loss \n",
    "    # for a geometry. Do not mind the context here, we do not need it.\n",
    "    def get_loss(self, geo, context=None):\n",
    "        \n",
    "        # we do compute the cadsd directly, but we get it from the geometry.\n",
    "        # in case we need it again, we do not need to compute it a 2nd time\n",
    "        # but can use it from the cache in the geo object\n",
    "        cadsd = geo.get_cadsd()\n",
    "        notes = cadsd.get_notes()\n",
    "\n",
    "        # if we have less than 3 resonant peaks then return a super high loss\n",
    "        if len(notes) < 3:\n",
    "            return 1000\n",
    "        \n",
    "        tuning_loss = 0\n",
    "        for i in range(len(self.target_freqs)):\n",
    "            # we compute the squared error for deviations from the target frequency\n",
    "            diff = notes.freq.iloc[i] - self.target_freqs[i]\n",
    "            tuning_loss += diff * diff\n",
    "            \n",
    "        volume_loss = 0\n",
    "        for i in range(len(self.target_freqs)):\n",
    "            imp = notes.impedance.iloc[i]\n",
    "            if imp < self.min_impedance:\n",
    "                diff = 1+(self.min_impedance-imp)/self.min_impedance   # this is a number between 1 and 2, with 1 meaning no deviation and 2 meaning super high deviation from our goal\n",
    "                diff *= 20    # we want to put a high penalty to this\n",
    "                volume_loss += diff\n",
    "\n",
    "        # we return multiple loss values as a dictionary. the evolution considers only the \"loss\" key. the other keys can\n",
    "        # give an insight in how the different parts of the loss influence the evolution.\n",
    "        loss={\n",
    "            \"loss\": tuning_loss + volume_loss,\n",
    "            \"tuning_loss\": tuning_loss,\n",
    "            \"volume_loss\": volume_loss,\n",
    "        }\n",
    "        return loss\n",
    "\n",
    "loss = TutorialLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we defined the loss function. Then we created the parameters for the computational evolution. We can see that the FinetuningParameters define 18 parameters, 2 for each segment of the open didgeridoo geometry. The first two parameters are immutable, because we do not want the mouthpiece position to be anywhere alse than 0 and the diameter of the mouthpiece should stay at 32mm. All the other parameters can be changed within a certain region.\n",
    "\n",
    "Next we perform an evolution. Therefore we define a processing pipeline. This pipeline consists of a single step only, the finetuning step. In this example we do not perform the exploration phase, because our shape is already almost where it should be."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [01:38<00:00,  1.01it/s]\n"
     ]
    }
   ],
   "source": [
    "from cad.calc.pipeline import Pipeline, FinetuningPipelineStep, ExplorePipelineStep\n",
    "from cad.calc.mutation import MutantPool, FinetuningMutator, ExploringMutator\n",
    "from cad.ui.evolution_ui import EvolutionUI\n",
    "from cad.ui.evolution_progress_bar import EvolutionProgressBar\n",
    "\n",
    "# our mutant pool contains only a single mutant. we do not want to mutate several mutants\n",
    "mutant_pool=MutantPool.create_from_father(parameters, 1, loss)\n",
    "\n",
    "# here we define a processing pipeline that consists of fine tuning only\n",
    "pipeline=Pipeline()\n",
    "\n",
    "n_generations=50\n",
    "n_generation_size=10\n",
    "\n",
    "pipeline.add_step(ExplorePipelineStep(ExploringMutator(), loss, mutant_pool, n_generations=n_generations, generation_size=n_generation_size))\n",
    "pipeline.add_step(FinetuningPipelineStep(FinetuningMutator(), loss, n_generations=n_generations, generation_size=n_generation_size))\n",
    "\n",
    "# this is a simple progress bar that shows the number of generations that has passed\n",
    "# we pass the number of generations as a parameter. There are two pipeline steps, each has n_generations, \n",
    "# so in total there are n_generations*2 pipeline steps.\n",
    "EvolutionProgressBar(n_generations*2)\n",
    "\n",
    "# start the pipeline\n",
    "final_mutant_pool=pipeline.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets print the notes and the didgeridoo shape. We are not super close to the target frequencies. But `n_generations` and `n_generation_size` are small. The higher these numbers the closer we will get to the target and the longer the skript runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       freq     impedance   rel_imp  note-number  cent-diff note-name\n",
      "1732   74.4  1.754935e+07  1.000000          -31 -23.045203        D1\n",
      "145   146.0  1.819902e+07  1.037020          -19   9.842186        D2\n",
      "265   266.0  6.429612e+05  0.036637           -9 -28.707266        C3\n",
      "358   359.0  1.333706e+07  0.759975           -4 -47.776384        F3\n",
      "578   579.0  6.738537e+06  0.383977            5  24.728211        D4\n",
      "788   789.0  1.866293e+06  0.106345           10 -11.026132        G4\n",
      "957   958.0  7.387334e+05  0.042095           13 -47.026559       A#5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot: xlabel='x', ylabel='y'>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2EAAADSCAYAAADDush5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAAsTAAALEwEAmpwYAAAlGUlEQVR4nO3de3xU9Z3/8fdkLrmQhEBIgISbIJRCQoIilwBCQEEEli2UauulW9z6291uy7p9WKH60PZXLesV+6jbfagP266VffzWKuLKsqyKoObidZEkoJZFA0pSLgkhCUnmen5/TGYySSY3TM4hk9fz8ZhHznzP95z5ns85gXnnnDljMwzDEAAAAADAFHFWDwAAAAAAhhJCGAAAAACYiBAGAAAAACYihAEAAACAiQhhAAAAAGAiQhgAAAAAmGjIhLBXXnlF119/va699lrt2LHD6uHElCeeeEKrV6/W6tWr9dBDD0mSSkpKtHbtWq1YsULbt28P9/3444+1YcMGrVy5Unfffbd8Pp9Vw44ZDz74oLZs2SKp6/pWVVXppptu0nXXXae//du/1YULF6wc8qD3xhtvaP369bruuut0//33S+KYN8PLL78c/rfmwQcflMQxP5AaGxu1Zs0affnll5L6foyzDy5Ox7r/+7//u9asWaO1a9dq69at8ng8kqh7f+tY95AdO3bolltuCT/vqr719fW6/fbbtWrVKt100006c+aMqeMfrDrW/eDBg/rWt76l1atX6x//8R9j+3g3hoA///nPRmFhoXHu3DnjwoULxtq1a42jR49aPayYUFxcbNxwww2G2+02PB6PceuttxqvvPKKsWTJEuPEiROG1+s1Nm3aZBw4cMAwDMNYvXq1cfDgQcMwDGPr1q3Gjh07LBz94FdSUmLMmzfPuOuuuwzD6Lq+t99+u7F7927DMAzjiSeeMB566CFLxhsLTpw4YSxatMiorq42PB6P8e1vf9s4cOAAx/wAa2pqMq666iqjpqbG8Hq9xje/+U2juLiYY36AfPTRR8aaNWuMmTNnGl988YXR3Nzc52OcfdB3Hev+2WefGddee63R0NBgBAIB4yc/+Ynxu9/9zjAM6t6fOtY95OjRo8bixYuNm2++OdzWVX1//vOfG08++aRhGIbx0ksvGZs3bzZvAwapjnVvaGgwFi5caHz88ceGYRjGHXfcET6uY/F4HxJnwkpKSjR//nylpaUpKSlJK1eu1N69e60eVkzIyMjQli1b5HK55HQ6NWXKFFVWVmrixIkaP368HA6H1q5dq7179+rkyZNqaWlRfn6+JGn9+vXsh6+grq5O27dv19/8zd9IUpf19Xq9ev/997Vy5cp27bg4r732mq6//nqNGTNGTqdT27dvV2JiIsf8APP7/QoEAmpubpbP55PP55PD4eCYHyDPP/+87rvvPmVmZkqSysrK+nSMsw8uTse6u1wu/exnP1NycrJsNpumTZumqqoq6t7POtZdkjwej+69915t3rw53NZdfQ8cOKC1a9dKktasWaO33npLXq/XxK0YfDrWvbi4WPn5+Zo+fbok6Z577tG1114bs8e7w+oBmOH06dPKyMgIP8/MzFRZWZmFI4odU6dODU9XVlZqz549uuWWWzrV+9SpU532Q0ZGhk6dOmXqeGPJvffeqzvuuEPV1dWSOh/nofqeO3dOycnJcjgc7dpxcY4fPy6n06nbbrtNZ86cUWFhoaZOncoxP8CSk5O1efNmrVq1SgkJCZo7d66cTifH/AB54IEH2j2P9v9od8c4++DidKx7dna2srOzJUm1tbXasWOHtm3bRt37Wce6S9Kjjz6qDRs2aNy4ceG27uobuU8cDoeSk5NVW1ur0aNHm7AFg1PHuh8/flxJSUn6wQ9+oBMnTmjOnDnasmWLjhw5EpPH+5A4E2YYRqc2m81mwUhi19GjR7Vp0ybdddddmjBhQqf5NpuN/dCP/vjHP2rs2LFasGBBuK2r+lL3/uX3+1VaWqqHH35Yzz//vMrLyzt9hkCi9v3tk08+0Ysvvqj9+/erqKhIcXFxKi4u7tSPug+Mvv77wj7oX6dOndJ3v/tdbdiwQfPmzaPuA6y4uFjV1dXasGFDu/a+1jcubki8ze43fr9fRUVF2rJli3bt2qXm5mY99dRTMXu8D4kzYaNHj9YHH3wQfn769Ol2p5zx1Xz44Yf60Y9+pJ/+9KdavXq13nvvPZ09ezY8P1Tv0aNHt2s/c+YM++Ei7dmzR2fOnNG6det0/vx5NTU1yWazRa3vyJEj1djYKL/fL7vdTt2/olGjRmnBggUaOXKkJGn58uXau3ev7HZ7uA/HfP8rKirSggULlJ6eLil42ckzzzzDMW+SjsdyT8c4+6D/HDt2TN///vd18803a9OmTZI67w/q3r92796to0ePat26dWpqatLZs2f1D//wD3r44Ye7rG9mZqbOnj2rMWPGyOfzqbGxUWlpadZuyCAzatQo5eXlafz48ZKkVatW6bnnntP69etj8ngfEhG9oKBApaWlqq2tVXNzs1599VVdffXVVg8rJlRXV+sHP/iBHnnkEa1evVqSlJeXp88//1zHjx+X3+/X7t27dfXVVys7O1vx8fH68MMPJUm7du1iP1yk3/3ud9q9e7defvll/ehHP9KyZcu0bdu2qPV1Op2aM2eO9uzZ064dF6ewsFBFRUWqr6+X3+/X22+/reuuu45jfoBNnz5dJSUlampqkmEYeuONNzR37lyOeZP09d919kH/aGxs1G233abNmzeHA5gk6j7Atm3bpv/6r//Syy+/rPvvv185OTl6/PHHu63vkiVLtGvXLknBP5TOmTNHTqfTqk0YlBYtWqTDhw+HP2axf/9+zZw5M2aPd5sR7VxeDHrllVf05JNPyuv16pvf/Ka+//3vWz2kmHD//ffrxRdfbHcJ4o033qhJkyZp27ZtcrvdWrJkibZu3SqbzaZPPvlE99xzjy5cuKAZM2Zo27ZtcrlcFm7B4Ldz50699957+qd/+qcu63vy5Elt2bJFNTU1Gjt2rB577DENHz7c6qEPWi+88IJ+//vfy+v1auHChbrnnnv07rvvcswPsKeeeko7d+6U0+lUbm6u7rvvPn3++ecc8wNo2bJlevbZZzVu3DiVlpb26RhnH1y8UN1ff/11PfLII5oyZUq7eZs3b6buAyDyeA9599139cQTT+gPf/iDJHVZ37q6Om3ZskVffPGFUlJS9Mgjj7RbD7oWWfcDBw5o+/btcrvd+vrXv65f/vKXSkxMjMnjfciEMAAAAAC4FAyJyxEBAAAA4FJBCAMAAAAAExHCAAAAAMBEhDAAAAAAMNGQCWH19fX69a9/rfr6equHMqRQd2tQd+tQe2tQd2tQd2tQd2tQd2vEat2HVAh74oknYm4HXuqouzWou3WovTWouzWouzWouzWouzVite5DJoQBAAAAwKWAEAYAAAAAJiKEAQAAAICJhkwIs9vtys7Olt1ut3ooQwp1twZ1tw61twZ1twZ1twZ1twZ1t0as1t1mGIZh9SAAAAAAYKhwDNSKz527oEDg0sp36enJqqlptHoYQw51twZ1tw61twZ1twZ1twZ1twZ1t8ZgrHtcnE0jRgzrcv6AhbBAwLjkQpikS3JMQwF1twZ1tw61twZ1twZ1twZ1twZ1t0as1X3IfCYMAAAAAC4FhDAAAAAAMBEhDAAAAABMRAgDAAAAABMRwgAAAADARIQwAAAAADARIQwAAAAATEQIAwAAAAATEcIAAAAAwESEMAAAAAAwESEMAAAAAExECAMAAAAAExHCAAAAAMBEhDAAAAAAMBEhDAAAAABMRAgDAAAAABMRwgAAAADARIQwAAAAADARIQwAAAAATEQIAwAAAAATEcIAAAAAwESEMAAAAAAwESEMAAAAAExECAMAAAAAExHCAAAAAMBEhDAAAAAAMBEhDAAAAABMRAgDAAAAABMRwgAAAADARIQwAAAAADARIQwAAAAATEQIAwAAAAATEcIAAAAAwESEMAAAAAAwESEMAAAAAExECAMAAAAAExHCAAAAAMBEhDAAAAAAMBEhDAAAAABMRAgDAAAAABMRwgAAAADARIQwAAAAADARIQwAAAAATEQIAwAAAAATEcIAAAAAwESEMAAAAAAwESEMAAAAAExECAMAAAAAExHCAAAAAMBEhDAAAAAAMBEhDAAAAABMRAgDAAAAABMRwgAAAADARIQwAAAAADARIQwAAAAATOSwegAAAFjJ6/Wqvr5e9fXn1djYoPr6ejU0NLQ+b1RcXJzi4+PlcrnkcoV+usJtwZ/xSkxMVGbmaCUkJFi9SQAwZLS0tMhut8vpdFo9lD4hhAEAYpJhGDp9+pQqKytVWfmZjh+vDD/Onj2jhoYGNTTUq6WlpV9fNz09XVlZ45SVlaWxY7OUlZUd8cjSmDFZSkpK6tfXBIChoL7+vCoqylVefkjl5WUqLy/T0aOfas6cufqP/9hr9fD6hBAGABjU6urOqazskKqqKlVR8XG7sNXc3BzuZ7PZlJWVrYkTJ2natK8pI2O0UlJSlJqaqtTUVCUnpyg1dXi4LSUl2FZRUaapU6fJ43HL7fa0+xk5XV1dpZaWFp08eVLV1Sf1xRdf6L333tG5c+c6jXnUqAzNnJmjnJxZysnJVU7OLE2ZcrkcDv5bBgBJOnXqlCoqgmHrT386ovff/0DHj1eG52dmjlZu7iytXLlK8+cXWDfQi8S/9gCAQaO2tkaHDn2ksrKPVFZ2SIcOfaQTJyrD85OShmnixEmaNGmyli5d3jo9SZMmXaZx4yYoPj5eknTo0EHl5c3u1Wump6dr/PgJPfbrap1NTU2qrj6pqqoqVVWdVFXVSR05cliffXZMTz/9L/J4PJKkhIQETZ/+deXkzNLMmbmtP2cqOTmlV+MEMLQYhqFAICCfzyev1yu/3yev1ye/39epzefztU575fP55fN5I9qC80Nt7R+hNn/EdGgdba/l8/kjpkPtvevTvi24THNzU7s/YE2ePFm5uXn6znduUW7uLOXm5mn06DHh+YcOHbRiF3wlhDAAwCXp/Pk6ffDBe+GwVVb2kb788ovw/IkTJyk/f7ZuvfWvNGtWvoYPT1R+/nzZbDYLR91ZUlKSpkyZqilTpobbQoHN6/Xq6NE/qaKiTBUV5Tp8uFz/+Z//oeee+9dw36lTp6mgYLEKChaqoGBRuzceAHovEAjI6/W2BhFva/jo+Dyyzdeuv8/nV1KSQzU19e3md7ds23N/lNfqeV4oVHWcF1q/VZxOp+x2h5xOpxwOu+x2hxyO4MNut0dMh9rb+rhcLiUmJnbqE7mc0+lSZmamFi5crJycXE2ZMk5nzjRYtr0DgRAGALgknD17Vu+8U6LS0iKVlpbo8OFyGYYhSZo8eYquumquNm26XXl5+crNnaW0tBHtlj9x4k+XXADridPp1IwZMzVjxkx961vflhT863Z1dZUqKoKfdyguflsvvvi8/vVfn5EkXX751HahbMyYsVZuAoYov9/fGhI88niCAcHj8cjr9cjr9bWbDvbxtPbxtrYHQ0bP7W1todfq2/Jt7X6/37T6BIOEUw6HU06no/WnM9zeFmLa5iUmJsnpbL9cW9Bxtpvndrs1fPjw8PqCQcYuh8MZ0WbvMN/Rbp2hZbqf39YWWldcXPDm6n25ouBiDPT6rUYIAwBY4tSpP6ukpEilpcUqLS3Wp59+IklKTEzUnDlzdeedWzVt2te0dOkypaYOt3i05gl9di0rK1srVqzSNdes0MyZuSovP6Ti4iKVlhbppZde0LPP/laSNGXK5SooWKSCgkVavHipMjMzLd4C9JVhGHK73VFCRvvnkdNJSQ6dOXO+y6DSc3vHgNRVcGprj1w+EAgMWD3agopLLlcwdLhcrnB4iWyPj49XcnJyr/u3tLRoxIiR7cJPZDhqCzGRwaktSI0enaaGBneX4SgUfgb6D0KxHlCGAkIYAMAUNTU1evvtA3rrrQMqKSnSZ58dkyQNG5asefPma+PGGzV//kLl58+Wy+WSFHyjMZQCWFccDodmz75Ss2dfqb//+83y+XyqqChTSUmxSkre1q5dO/WHP/xekpSfP1vLl6/QNdes0OzZV4b/ao32DMNoDTZutbS4W3+2yOPxtGuLnHa7g4+u53vkdrd0mO/psN7gtNvdEnGDF8+AbWfo8q9gMAkGkuDD0RpUXK0hwqX4+AQlJyd3ag8u37l/5/UGQ0j0dlcv+zkH9Jj9quElIyMl5i6LgzUIYQCAAeF2u/Xee+/owIE39Oab+1VefkiGYSg1dbhmz75Ct966SQUFC5WTM4u7AvaRw+FQfv4Vys+/Qn/3dz+U3+9XRUWZXn75Jb37bqm2b39Yjz76oEaNGqXCwmt0zTUrtHTpMo0YMdLqocvn87WGmVAYcUc82rdFBp9obV0Fn8i2tunOYag/2Gw2JSQkyOWKV3x8fMT3xyUoPj74MylpmEaMGKH4+ITwd8u19W2bbmlp0ahRo7o9kxNqz8xMU2Ojt9uA5HQ6B90lusBQwf96AIB+YRiGPv74SGvoekPvvFOi5uZmORwOXXXVPN11191asqRQ+flXqKKijEtp+pHdbg/X8957/69qa2t04MAbeu21/9a+fa/qj3/8f4qLi9NVV80LB7Jhw5KjBJ22szO9DUI2W0D19Y1dBCOPIsNVS0tLv13GFgwu3YealJSUdmEoOM/VYbng/Mjlelpv5HOHw9FvQacvZ2k4IwMMboQwAMBFO336tN58843w2a7Tp09JkqZN+5puvvm7WrKkUAUFi7jNuslGjkzX+vUbtX79Rvn9fh08+KFef/1Vvf76q3rggZ/rgQd+flHrdTqdHUKNS0lJiXI4XOHQkpY2olNgaQstPYeh3oQll8vFGR4AgxohDADQa6FLDPfv36cDB95QRUWZpOB3ac2du0DXXXe9liwpVFZWtsUjRYjdbtecOXM1Z85cbdlyj06d+rNKS4tVW1urzMzRUYNPV2Eo2md1OCMDAH1HCAMAdMkwDB09+icdOLBP+/fvU2lpsZqamuR0OjV37nzdffd9KixcrpycWSovP8QlhoPA6NFj9Jd/uYG7qwGAhQhhAHCRDMOI+gh9NibaPClaW+S6Oq83tEx3rxl6+Hy+1psPRN6VLdrNCdrftS36jRJadOTIYZ08+aWk4K3Qv/3tm1VYuJxLDAEA+AqGVAjzer3dvjGSunuDo6hvmKK9oer6zVXHZdRj32iv0/tx9u5NW+R6o29P9+PsrgaSlJKSoPPnm3pYR8/j7P6NaPTlu96mrvdTV/und/u0d2+uO/a/uO3vfpn4eIfcbm+v931ofX09pjv3V9R+3dWqp2O698d/22sM/HESOyI/59P+Dm/xmj59hu64404tXbpMEyZMtHqoAADEhCETwvbs2a1Nm24e0C8XRGyw2Ww9PkL9pK76qF2/tuV6Xmfn/tHaux5n6DWcTrt8vkCXY+vYv7t1xsXFtXvttu3ovl6R6+xu29v69ty/N9seGltP+zOyf8/7vm2f9rQtyckJamryXPRxcvHbLzU1NXX7OZ/g84QeP+cTwiVrAAD0vyETwubMmautW7fKMOzdvsmR1O7NUVdvjNr69fwI6W3f3rxpDfbr3Ru37l6785vQnscp9WX7pZEjk3Xu3IVut6dvb0S7r2fHZfpS+1jCh+WtY2XtCU0AAFz6hkwIy8zM1De+8Q1NmDDN6qEMOYQBAAAAoE3X16AAAAAAAPodIQwAAAAATEQIAwAAAAATEcIAAAAAwEQ9hrAf/vCHKikpMWMsAAAAABDzegxhK1as0G9+8xutXLlSzzzzjOrq6kwYFgAAAADEph5D2Nq1a/Xcc8/pN7/5jWpqarRx40bdeeedKisrM2N8AAAAABBTevWZsEAgoOPHj6uyslI+n0/p6en62c9+pocffnigxwcAAAAAMaXHL2vevn27du7cqfHjx+s73/mOfvWrX8npdKqpqUmFhYW68847zRgnAAAAAMSEHkNYbW2tnn76aU2fPr1de1JSkh599NEBGxgAAAAAxKIeQ9gvfvGLLuctWrSoXwcDAAAAALGO7wkDAAAAABP1eCYsVuzb96r++q+/q0AgIJvNJskmm63zQ5JsNkVpj9Yv+jra+qtXfSOX6b6vOr1+V9vR1Vjb+kfbxuivHe01OveN9hrBR0KCU263r4/b3lN91att77hPu1sm2vb39TjpuEzv97163be3+z8tLUnnzzf1cZt62v+9G2domd5tU9vvSV+P5663p/vfvd4d013vJwAAgK9iyISw6dNn6Hvf+54CgTgZhhF+SJHTajev7aF2/bvu1/kR6hv5OpHri9a3c/+u+0Wur7tloq8n2nq73rZQ/95vf7D2cXGS3x/oVZ263g5F7dv3WhkDdIRhKOlLWO46WHb+o0pPwbrrENrWFggElJo6XC6XSwkJCXK5XIqPj1d8fOR0vFyueCUkBH9GTnec39TUpFmz8gmhAAD0oyETwrKzx+nXv/61zpxpsHooQ05GRsolV/fehLW+h9CuAl/vw3rnYNn7sXZ8nREjhqm2trGHQNu3YN31HyG6H2dPNejLPulurN3/UaXruvV++zv+wSP6comJTjU1ebrdP9G3qfua9TROyVBDQ4NsNpvcbrc8Ho/On6+T2+2Rx+OW2x16tMjj8ailpUWBQKDH35fs7HFaunSZCguXa/HiJRoxYmSvfs8AAEB0QyaEAZGGwuVll2L4HSoGU+19Pl9rYGsLaaGA5na36MiRw9q/f59eeeVl7djxrOLi4jR79hVasmSZCguv0ZVXzpHDwX8lAAD0Bf9zAsAQ5nA45HA4NGzYsKjz58yZq1tv/Z58Pp/+538+1IED+7R//z49/vgjeuyxh5SSkqrFi5do6dJlGjNmjPLyZpu8BQAADD6EMABAjxwOh+bOnae5c+fpJz/5qerqzuntt98Kh7I9e16RJE2cOElLlizT0qXLtHjx1Ro+PM3agSOsublZpaVFeu21/1ZJSbGami50+/nBUFtPnx/MyEiT2x2IMt/Vuq7I5V0xfxUCAPQGIQwA0GdpaSO0du06rV27ToZh6Nix/9Wbb76hN9/cr507/6hnn/1txKWLhVq6dLmuvPIqOZ1Oq4c+pJw4cVyvv/6q9u17VUVFb6m5uVmJiYmaP79ADodDcXFx4ctQ6+vPq6UldGmqp/Wzg23Tfr+/X8YUuvFLW0jra/iLHu6Cy/W03rb5DoeDQAjAMoQwAMBXYrPZdPnlU3X55VN1223/R16vVx9++EE4lD3++KN67LGHNWxYshYuXKQlSwo1alSGcnPzFBfH11X2J6/Xq6Kit8LB69NPP5EUPEN500236pprVqigYLESEhL6vO7Izw+GPjfo8Xg0bJhD1dU17do8Hnd4uu2zhu4O8zt+FrGtrbGxITwduV63u0Vutzt8o5qvwmaz9fHOod2Hv96dUez8WvHx8XyuEhiC+K0HAPQrp9Op+fMXaP78Bbrrrrt1/nydioreDoeyV1/dK0nasuXHmjevQAsWLFRBwULl5MyS3W63ePSDSyAQ0JEjh1VaWhSucVNTk5xOpxYsWKSbb/6urrlmhSZPvvwrn/Xp6vODGRkpysoy70Y0hmG0BsKW8J0/O4a0tulo80N3C42c7+7U5na71dLSrPr681HXG7rLaH+w2+2Kj4+X3W5XQkKinE6nnE6nXC6XHI7gz1Cb0+mSy+XUsGGJMoy4Tu1d9W+b7jwv+jIuORyO1naXnE5Hu3bOIgJfDSEMADCghg9P0+rVa7V69VpJwUvkSkuLVVparJKSIu3d+5+SpJSUVM2dO08LFixSQcFCbvIRRSAQ0OHDFSopeVvFxUV6551i1dXVSZImTJikVavW6C/+4htavHiJkpOTrR3sALHZbOGwYPUmGobRZbjrKvBFflVEx7a6unNyOl3yej3yer3yer3yeDztnjc1XVB9vVenT/vV3NzSrp/P55XH45XX6+m3gNiVUFjrHBi7b+8u3IWmQ8v3tK7ehNXIdoIjLiWEMACAqSZMmKgJEybqhhu+I0mqrq5qDWTFeuedYu3bd58kKSkpSdOmTdeiRVcrLy9fs2bla9Kky4bUGym/36+jR/8UDqylpSU6f75OUvASw+uvX6uCgkUqKFikcePGWzvYIajtksZ401+7p6/CMAxDfr+/UzgLhjaPPB5va3tbwAu1t0175PP5wkGwu2WitweXb2lpVkPDeXm9vqjrjWzvj0tNu+JwOGS32+VyxcvpdMjhCAY2h8MRDm8Oh1MOhz1inrM1HAank5MT5feHzgy3nxe5Lrs9tM6Le51Q/9AyofmheQNZJ5iDEAYAsNTYsVlav36j1q/fKEk6c+aM3nmnRKWlRSouLtKTT/6zvF6vJCk1dbhmzcpTbm6e8vLylZeXr8sumxITny27cOGCPv74sCoqylVRUa7Dh8t05MhhNTc3S5ImTbpMa9b8RTh0ZWePs3jEuJTZbLbwm/jBJBQcO4azjmf5QvNC/TqeMYwWPj0ej+rq6pSQEC+v1yufzxfuH5r2+ULTPvl8wTOPPp83/DwQ8Mvt9rTrH5rn9Xr77QY2vREXFxcOg8Gf9ojpUMgbmPl2u0NnzpzS+++/K7vdET7W7HZ7xLQjvFxf+wyFoDm4fjMBADEvIyMjfOdFSfJ4PPrkkyM6dOgjlZUdUlnZQf32t0/J7XZLkpKTU5SbO0vjx2crN3e2Jk68TBMnTtLEiZOUlJRk5aZEZRiGampqtG/fq+HAVVFRps8+OxZ+0zF8eJpycnJ1yy1/pcsum6xVq9YoKyvb4pEDA89utysxMVGJiYlWDyWqns5ABgKBcEDz+33tAlp3YS9aoAuFurZ5bfPr6uqUmJjQ+twXXp/P5w9Pt71+5/nNzU1R57e9Xtvyfr8vPG4zg1Fq6nDl51+h3NxZWrhwniZOnKbJk6fEzGeHCWEAgEuay+XSrFnByxFDvF6vPv30E5WVfaSyso906NBH2rNnj55//vl2y2Zmjg4HskmTQuHsMtXWnlV29nilpKT066VkhmGotrZWVVUnVV19UlVVVaqqOtn6vCr8s6mpKbzMhAmTlJOTq/XrNyonZ5ZycnI1btz4IXXZJRAr4uLiWu+G6bJ6KAMiEAiEA2Ig4A8Hu1BQCwW5tmlfF31CgdAXddnm5iYdPPg/Onbsf/X00/+if/7nX0mSkpKGacaMmeErInJzZ+lrX/u6xVW5ODZjgCJtTU2jAoFL6zRiT3+9wMCg7tag7tah9tYYNSpZn356XMePf67jxytVWRn8GZquqjoZ9a+48fHxSklJVUpKilJThyslJUUpKalKTU1VcnKyTp8+reHDh0fcHa/t1umhNo/Hrbq6Op07V6uWlpZ267fb7RozZqzGjs1SdvY4jR2bpbS0NC1YsFAzZswc9F9ozfFuDepuDepuPo/Ho7Nnv9Rbb5WqrOwjlZeXqaKiXBcuNEoK3iRm5cpV+u1vn7N4pO3FxdmUnt713YM4EwYAiAk2m03p6elKT0/XFVfM6TTf7Xbryy9PqLLycx07dkx2e5zq6+vV0NCg+vp6NTbWq74++Kis/FwNDcF5NpuUkJAY/ut26Dujgt/7lKjU1FS5XMGzaZMmXabs7GyNHZutrKwsZWVlKzNzdMxcPgMAZnO5XMrLy1NW1mTdeONNkoJn5CorP1N5eZnKy8uUnp5u8Sj7jhAGABgS4uPjNWXKVE2ZMlXLl1s9GgDAxYqLi9PkyZdr8uTLtW7dequHc1EG/+2kAAAAAGAQIYQBAAAAgIkIYQAAAABgIkIYAAAAAJiIEAYAAAAAJiKEAQAAAICJCGEAAAAAYCJCGAAAAACYiBAGAAAAACYihAEAAACAiQhhAAAAAGAiQhgAAAAAmIgQBgAAAAAmIoQBAAAAgIkIYQAAAABgIkIYAAAAAJiIEAYAAAAAJiKEAQAAAICJCGEAAAAAYCJCGAAAAACYiBAGAAAAACYihAEAAACAiQhhAAAAAGAiQhgAAAAAmIgQBgAAAAAmIoQBAAAAgIkIYQAAAABgIkIYAAAAAJiIEAYAAAAAJiKEAQAAAICJCGEAAAAAYCJCGAAAAACYiBAGAAAAACYihAEAAACAiQhhAAAAAGAiQhgAAAAAmIgQBgAAAAAmIoQBAAAAgIkIYQAAAABgIkIYAAAAAJiIEAYAAAAAJiKEAQAAAICJCGEAAAAAYCJCGAAAAACYiBAGAAAAACYihAEAAACAiQhhAAAAAGAiQhgAAAAAmIgQBgAAAAAmIoQBAAAAgIkIYQAAAABgIkIYAAAAAJiIEAYAAAAAJiKEAQAAAICJCGEAAAAAYCJCGAAAAACYiBAGAAAAACZyDNSK4+JsA7Xqr+RSHVeso+7WoO7WofbWoO7WoO7WoO7WoO7WGGx172m8NsMwDJPGAgAAAABDHpcjAgAAAICJCGEAAAAAYCJCGAAAAACYiBAGAAAAACYihAEAAACAiQhhAAAAAGAiQhgAIGa89NJLWr58uS5cuKCmpiatWrVKu3btsnpYAAC0w/eEAQBiyo9//GOlpKTI4/HIbrfrF7/4hdVDAgCgHUIYACCmNDY2at26dUpISNDOnTsVHx9v9ZAAAGiHyxEBADGlpqZGbrdb9fX1On36tNXDAQCgE86EAQBihtfr1Y033qgbb7xRgUBAL7zwgv7t3/5NTqfT6qEBABDGmTAAQMx47LHHlJGRoY0bN+qGG25QWlqatm/fbvWwAABohzNhAAAAAGAizoQBAAAAgIkIYQAAAABgIkIYAAAAAJiIEAYAAAAAJiKEAQAAAICJCGEAAAAAYCJCGAAAAACY6P8Dmiyys4uju20AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from cad.ui.visualization import DidgeVisualizer\n",
    "\n",
    "final_geo=final_mutant_pool.get(0).geo\n",
    "print(final_geo.get_cadsd().get_notes())\n",
    "\n",
    "DidgeVisualizer.vis_didge(final_geo)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "didge",
   "language": "python",
   "name": "didge"
  },
  "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}