Repository: FLClab/pySTED (language: python)

Issue:
added a function to generate a randomly dotted datamap
added a function to generate a randomly dotted datamap


added a function to generate a randomly dotted datamap




Discussion / hints:

Fix patch:
diff --git a/.gitignore b/.gitignore
index 160c4f7..66d6745 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,7 @@
 # User defined
 *cache.pkl
+# Removes the cached files
+panels/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -8,6 +10,7 @@ __pycache__/
 
 # C extensions
 *.so
+*.c
 
 # Distribution / packaging
 .Python
diff --git a/acquire.py b/acquire.py
new file mode 100644
index 0000000..9531f30
--- /dev/null
+++ b/acquire.py
@@ -0,0 +1,171 @@
+
+import numpy
+import time
+import random
+import argparse
+
+from pysted import base, utils, raster, bleach_funcs
+from pysted.microscopes import DyMINMicroscope, RESCueMicroscope
+from matplotlib import pyplot
+
+numpy.random.seed(42)
+random.seed(42)
+
+def datamap_generator(shape, sources, molecules, shape_sources=(1, 1), random_state=None):
+    """
+    Function to generate a datamap with randomly located molecules.
+    :param shape: A tuple representing the shape of the datamap. If only 1 number is passed, a square datamap will be
+                  generated.
+    :param sources: Number of molecule sources to be randomly placed on the datamap.
+    :param molecules: Average number of molecules contained on each source. The actual number of molecules will be
+                      determined by poisson sampling.
+    :param shape_sources : A `tuple` of the shape of the sources
+    :param random_state: Sets the seed of the random number generator.
+    :returns: A datamap containing the randomly placed molecules
+    """
+    numpy.random.seed(random_state)
+    if type(shape) == int:
+        shape = (shape, shape)
+    datamap = numpy.zeros(shape)
+    pos = []
+    for i in range(sources):
+        row, col = numpy.random.randint(0, shape[0] - shape_sources[0]), numpy.random.randint(0, shape[1] - shape_sources[1])
+        datamap[row : row + shape_sources[0], col : col + shape_sources[1]] += numpy.random.poisson(molecules)
+        pos.append([row + shape_sources[0] // 2, row + shape_sources[1] // 2])
+    return datamap, numpy.array(pos)
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--microscope", type=str, default="STED",
+                        help="Choose which microscope to acquire from")
+    args = parser.parse_args()
+
+    START = time.time()
+
+    delta = 1
+    num_mol = 2
+    # molecules_disposition = numpy.zeros((50, 50))
+    # molecules_disposition[
+    #     molecules_disposition.shape[0]//2 - delta : molecules_disposition.shape[0]//2+delta+1,
+    #     molecules_disposition.shape[1]//2 - delta : molecules_disposition.shape[1]//2+delta+1] = num_mol
+    molecules_disposition, positions = datamap_generator(50, 10, num_mol, shape_sources=(2,2), random_state=42)
+    # for j in range(1,4):
+    #     for i in range(1,4):
+    # #         molecules_disposition[
+    # #             i * molecules_disposition.shape[0]//4,
+    # #             j * molecules_disposition.shape[1]//4] = num_mol
+    #         molecules_disposition[
+    #             j * molecules_disposition.shape[0]//4 - delta : j * molecules_disposition.shape[0]//4 + delta + 1,
+    #             i * molecules_disposition.shape[1]//4 - delta : i * molecules_disposition.shape[1]//4 + delta + 1] = num_mol
+
+    print("Setting up the microscope ...")
+    # Microscope stuff
+    # egfp = {"lambda_": 535e-9,
+    #         "qy": 0.6,
+    #         "sigma_abs": {488: 1.15e-20,
+    #                       575: 6e-21},
+    #         "sigma_ste": {560: 1.2e-20,
+    #                       575: 6.0e-21,
+    #                       580: 5.0e-21},
+    #         "sigma_tri": 1e-21,
+    #         "tau": 3e-09,
+    #         "tau_vib": 1.0e-12,
+    #         "tau_tri": 5e-6,
+    #         "phy_react": {488: 1e-7,   # 1e-4
+    #                       575: 1e-11},   # 1e-8
+    #         "k_isc": 0.26e6}
+    egfp = {"lambda_": 535e-9,
+            "qy": 0.6,
+            "sigma_abs": {488: 3e-20,
+                          575: 6e-21},
+            "sigma_ste": {560: 1.2e-20,
+                          575: 6.0e-21,
+                          580: 5.0e-21},
+            "sigma_tri": 1e-21,
+            "tau": 3e-09,
+            "tau_vib": 1.0e-12,
+            "tau_tri": 5e-6,
+            "phy_react": {488: 0.25e-7,   # 1e-4
+                          575: 25.e-11},   # 1e-8
+            "k_isc": 0.26e6}
+    pixelsize = 20e-9
+    bleach = True
+    p_ex = 2e-6
+    p_ex_array = numpy.ones(molecules_disposition.shape) * p_ex
+    p_sted = 2.5e-3
+    p_sted_array = numpy.ones(molecules_disposition.shape) * p_sted
+    pdt = 100e-6
+    pdt_array = numpy.ones(molecules_disposition.shape) * pdt
+    roi = 'max'
+
+    # Generating objects necessary for acquisition simulation
+    laser_ex = base.GaussianBeam(488e-9)
+    laser_sted = base.DonutBeam(575e-9, zero_residual=0.1)
+    detector = base.Detector(noise=True, background=0, pcef=0.1)
+    objective = base.Objective()
+    fluo = base.Fluorescence(**egfp)
+    datamap = base.Datamap(molecules_disposition, pixelsize)
+
+    if args.microscope == "DyMIN":
+        # DyMIN microscope
+        opts = {
+            "scale_power" : [0., 0.25, 1.],
+            "decision_time" : [10e-6, 10e-6, -1],
+            "threshold_count" : [10, 8, 0]
+        }
+        microscope = DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts=opts)
+    elif args.microscope == "RESCue":
+        # RESCue microscope
+        opts = {
+            "lower_threshold" : [2, -1],
+            "upper_threshold" : [6, -1],
+            "decision_time" : [25e-6, -1]
+        }
+        microscope = RESCueMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts=opts)
+    elif args.microscope == "STED":
+        # STED microscope
+        microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo)
+    else:
+        print("Microscope <{}> does not exist...".format(args.microscope))
+        print("Please try again...".format(args.microscope))
+        exit()
+
+    start = time.time()
+    i_ex, i_sted, _ = microscope.cache(datamap.pixelsize, save_cache=True)
+
+    datamap.set_roi(i_ex, roi)
+    print("Setup done...")
+
+    time_start = time.time()
+    # acquisition, bleached, scaled_power = microscope.get_signal_and_bleach(datamap, datamap.pixelsize, pdt, p_ex, p_sted,
+    #                                                                     bleach=bleach, update=False, seed=42)
+
+    experiment = utils.Experiment()
+    experiment.add("microscope", microscope, datamap, params={"pdt":pdt, "p_ex":p_ex, "p_sted":p_sted})
+    histories = experiment.acquire_all(1, bleach=bleach, processes=0)
+    history = histories["microscope"]
+
+    acquisition, bleached, scaled_power = history["acquisition"], history["bleached"], history["other"]
+
+    print(f"ran in {time.time() - time_start} s")
+
+    fig, axes = pyplot.subplots(1, 4, figsize=(10,3), sharey=True, sharex=True)
+
+    axes[0].imshow(history["datamap"][-1])
+    axes[0].set_title(f"Datamap roi")
+
+    axes[1].imshow(bleached[-1], vmin=0, vmax=history["datamap"][-1].max())
+    axes[1].set_title(f"Bleached datamap")
+
+    axes[2].imshow(acquisition[-1])
+    axes[2].set_title(f"Acquired signal (photons)")
+
+    axes[3].imshow(scaled_power[-1])
+    axes[3].set_title(f"Scaled power")
+
+    print("Average molecules left : ", bleached[-1][molecules_disposition != 0].mean(axis=-1))
+
+    print("Total run time : {}".format(time.time() - START))
+
+    pyplot.show()
diff --git a/dymin.ipynb b/dymin.ipynb
new file mode 100644
index 0000000..f442882
--- /dev/null
+++ b/dymin.ipynb
@@ -0,0 +1,1058 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 92,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import numpy\n",
+    "import time\n",
+    "import random\n",
+    "import os\n",
+    "import multiprocessing\n",
+    "\n",
+    "from pysted import base, utils, raster, bleach_funcs, temporal, microscopes\n",
+    "from matplotlib import pyplot\n",
+    "from tqdm.auto import trange\n",
+    "from scipy import optimize\n",
+    "\n",
+    "numpy.random.seed(42)\n",
+    "random.seed(42)\n",
+    "\n",
+    "# molecules_disposition = (numpy.random.rand(40, 40) > 0.9).astype(int) * 10\n",
+    "delta = 1\n",
+    "num_mol = 2\n",
+    "molecules_disposition = numpy.zeros((50, 50))\n",
+    "# molecules_disposition[\n",
+    "#     molecules_disposition.shape[0]//2 - delta : molecules_disposition.shape[0]//2+delta + 1,\n",
+    "#     molecules_disposition.shape[1]//2 - delta : molecules_disposition.shape[1]//2+delta + 1] = num_mol\n",
+    "for j in range(1,4):\n",
+    "    for i in range(1,4):\n",
+    "#         molecules_disposition[\n",
+    "#             i * molecules_disposition.shape[0]//4,\n",
+    "#             j * molecules_disposition.shape[1]//4] = num_mol\n",
+    "        molecules_disposition[\n",
+    "            j * molecules_disposition.shape[0]//4 - delta : j * molecules_disposition.shape[0]//4 + delta + 1,\n",
+    "            i * molecules_disposition.shape[1]//4 - delta : i * molecules_disposition.shape[1]//4 + delta + 1] = num_mol\n",
+    "\n",
+    "egfp = {\"lambda_\": 535e-9,\n",
+    "        \"qy\": 0.6,\n",
+    "        \"sigma_abs\": {488: 3e-20,\n",
+    "                      575: 6e-21},\n",
+    "        \"sigma_ste\": {560: 1.2e-20,\n",
+    "                      575: 6.0e-21,\n",
+    "                      580: 5.0e-21},\n",
+    "        \"sigma_tri\": 1e-21,\n",
+    "        \"tau\": 3e-09,\n",
+    "        \"tau_vib\": 1.0e-12,\n",
+    "        \"tau_tri\": 5e-6,\n",
+    "        \"phy_react\": {488: 0.25e-7,   # 1e-4\n",
+    "                      575: 1e-11},   # 1e-8\n",
+    "        \"k_isc\": 0.26e6}\n",
+    "pixelsize = 20e-9\n",
+    "bleach = True\n",
+    "p_ex = 2e-6\n",
+    "p_ex_array = numpy.ones(molecules_disposition.shape) * p_ex\n",
+    "p_sted = 2.5e-3\n",
+    "p_sted_array = numpy.ones(molecules_disposition.shape) * p_sted\n",
+    "pdt = 100e-6\n",
+    "pdt_array = numpy.ones(molecules_disposition.shape) * pdt\n",
+    "roi = 'max'\n",
+    "\n",
+    "params = {\n",
+    "    \"pdt\":pdt, \n",
+    "    \"p_ex\":p_ex, \n",
+    "    \"p_sted\":p_sted\n",
+    "}\n",
+    "\n",
+    "num_acquisition = 25\n",
+    "\n",
+    "# Generating objects necessary for acquisition simulation\n",
+    "laser_ex = base.GaussianBeam(488e-9)\n",
+    "laser_sted = base.DonutBeam(575e-9, zero_residual=0)\n",
+    "detector = base.Detector(noise=True, background=0)\n",
+    "objective = base.Objective()\n",
+    "fluo = base.Fluorescence(**egfp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def acquire_all(experiment, num_acquisition, bleach=True, processes=0):\n",
+    "    \"\"\"\n",
+    "    Acquires from all microsopes\n",
+    "\n",
+    "    :param num_acquisition: An `int` of the number of acquired frames\n",
+    "    :param bleach: A `bool` whether to bleach the sample\n",
+    "    :param processes: An `int` of the number of processes to use in `multiprocessing`\n",
+    "\n",
+    "    :returns : A `dict` of the history for each microscope\n",
+    "    \"\"\"\n",
+    "    history = {}\n",
+    "    if processes:\n",
+    "        def log_callback(data):\n",
+    "            name, hist = data\n",
+    "            history[name] = hist\n",
+    "        pool = multiprocessing.Pool(processes=processes)\n",
+    "        calls = [pool.apply_async(experiment.acquire, kwds={\"name\":name, \"num_acquisition\":num_acquisition, \"bleach\":bleach, \"verbose\":True}, callback=log_callback)\n",
+    "                    for name in experiment.microscopes.keys()]\n",
+    "        pool.close()\n",
+    "        pool.join()\n",
+    "        for c in calls: c.get()\n",
+    "    else:\n",
+    "        for name in experiment.microscopes.keys():\n",
+    "            name, out = experiment.acquire(name=name, num_acquisition=num_acquisition, bleach=bleach)\n",
+    "            history[name] = out\n",
+    "    return history    \n",
+    "    \n",
+    "def get_resolution(emitter, delta=8):\n",
+    "    def gaussian(x,a,x0,sigma):\n",
+    "        return a*numpy.exp(-(x-x0)**2/(2*sigma**2))\n",
+    "    x, y = numpy.arange(emitter.shape[1]) - emitter.shape[1]//2, emitter[:, emitter.shape[1] // 2 - 2 : emitter.shape[1] // 2 + 2].mean(axis=-1)\n",
+    "    center = len(x) // 2\n",
+    "    x = x[center - delta : center + delta]\n",
+    "    y = y[center - delta : center + delta]\n",
+    "    try:\n",
+    "        popt, pcov = optimize.curve_fit(gaussian, x, y, bounds=((-numpy.inf, -numpy.inf, 0), numpy.inf))\n",
+    "    except RuntimeError:\n",
+    "        return 0.\n",
+    "#     fig, ax = pyplot.subplots()\n",
+    "#     ax.plot(x, y)\n",
+    "#     ax.plot(x, gaussian(x, *popt))\n",
+    "#     pyplot.show()    \n",
+    "    return 2 * numpy.sqrt(2 * numpy.log(2)) * popt[-1] * pixelsize * 1e+9\n",
+    "\n",
+    "def plot_and_gen_gif(histories, savename=None, keys=None, show_res=False):\n",
+    "    from PIL import Image\n",
+    "    def roundint(x, val=10):\n",
+    "        return round(x / val) * val\n",
+    "    def gen_frame(path):\n",
+    "        im = Image.open(path)\n",
+    "        alpha = im.getchannel('A')\n",
+    "\n",
+    "        # Convert the image into P mode but only use 255 colors in the palette out of 256\n",
+    "        im = im.convert('RGB').convert('P', palette=Image.ADAPTIVE, colors=255)\n",
+    "\n",
+    "        # Set all pixel values below 128 to 255 , and the rest to 0\n",
+    "        mask = Image.eval(alpha, lambda a: 255 if a <=128 else 0)\n",
+    "\n",
+    "        # Paste the color of index 255 and use alpha as a mask\n",
+    "        im.paste(255, mask)\n",
+    "\n",
+    "        # The transparency index is 255\n",
+    "        im.info['transparency'] = 255\n",
+    "\n",
+    "        return im        \n",
+    "    \n",
+    "    filenames = []\n",
+    "    if isinstance(keys, type(None)):\n",
+    "        keys = list(sorted(histories.keys()))\n",
+    "    maxvalues = [roundint(histories[key][\"acquisition\"][0].max()) for key in keys]\n",
+    "    print([(key, roundint(histories[key][\"acquisition\"][0].max())) for key in keys])\n",
+    "    for i in range(histories[keys[0]][\"datamap\"].shape[0]):\n",
+    "    \n",
+    "        fig, axes = pyplot.subplots(len(keys), 3, figsize=(5, len(keys)+1), sharex=True, sharey=True)\n",
+    "#         fig, axes = pyplot.subplots(len(keys), 3, figsize=(10, 5))\n",
+    "        for n, key in enumerate(keys):\n",
+    "            axes[n, 0].imshow(histories[key][\"datamap\"][i], vmin=0, vmax=histories[key][\"datamap\"][0].max(), cmap=\"gray\")\n",
+    "            if key == \"STED\":\n",
+    "                axes[n, 1].imshow(numpy.ones_like(histories[key][\"other\"][i]), vmin=0, vmax=1, cmap=\"Blues\")\n",
+    "            else:\n",
+    "                axes[n, 1].imshow(histories[key][\"other\"][i], vmin=0, vmax=1, cmap=\"Blues\")        \n",
+    "            axes[n, 2].imshow(histories[key][\"acquisition\"][i], vmin=0, vmax=max(maxvalues), cmap=\"hot\")\n",
+    "            if show_res:\n",
+    "                axes[n, 2].set_title(\"{:0.1f} nm\".format(get_resolution(histories[key][\"acquisition\"][i])))\n",
+    "            axes[n, 0].set(\n",
+    "                ylabel=key\n",
+    "            )\n",
+    "        axes[0, 0].set(\n",
+    "            title=f\"Frame {i}\"\n",
+    "        )\n",
+    "        for ax in axes.ravel():\n",
+    "            pyplot.setp(ax.get_xticklabels(), visible=False)\n",
+    "            pyplot.setp(ax.get_yticklabels(), visible=False)\n",
+    "            ax.tick_params(axis='both', which='both', length=0)\n",
+    "\n",
+    "        if savename:\n",
+    "            filename = f\"./panels/frame{i}.png\"\n",
+    "            fig.savefig(filename, transparent=True, bbox_inches=\"tight\", dpi=300)\n",
+    "            pyplot.close(\"all\")\n",
+    "            filenames.append(filename)\n",
+    "    \n",
+    "    if savename:\n",
+    "        image = gen_frame(filenames[0])\n",
+    "        append_images = []\n",
+    "        for filename in filenames[1:]:\n",
+    "            append_images.append(gen_frame(filename))\n",
+    "        image.save(savename, save_all=True, append_images=append_images, loop=0, duration=400, disposal=2, optimize=False)\n",
+    "        for filename in filenames:\n",
+    "            os.remove(filename)\n",
+    "\n",
+    "def plot_bleaching_curve(histories, savename=None, keys=None):\n",
+    "    \"\"\"\n",
+    "    Utilitary function to plot the normalized average number of molecules per frame\n",
+    "    \n",
+    "    :param histories: A `dict` of the history\n",
+    "    :param savename: (optional) A `str` of the savepath\n",
+    "    :param keys: (optional): A `list` of keys to access in the histories\n",
+    "    \"\"\"\n",
+    "    fig, ax = pyplot.subplots(figsize=(3, 3), tight_layout=True)\n",
+    "    if isinstance(keys, type(None)):\n",
+    "        keys = list(sorted(histories.keys()))\n",
+    "    for key in keys:\n",
+    "        init_mol = histories[key][\"datamap\"][0, molecules_disposition != 0].mean(axis=-1)\n",
+    "        molecules = histories[key][\"datamap\"][:, molecules_disposition != 0].mean(axis=-1) / init_mol\n",
+    "        ax.plot(molecules, label=key)\n",
+    "    ax.set(\n",
+    "        ylabel=\"Avg. molecules left\", xlabel=\"Frames\"\n",
+    "    )\n",
+    "    ax.legend()\n",
+    "    if isinstance(savename, str):\n",
+    "        fig.savefig(savename, transparent=True, bbox_inches=\"tight\")\n",
+    "        pyplot.close(\"all\")\n",
+    "    else:\n",
+    "        pyplot.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare DyMIN and Conventional"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "experiment = utils.Experiment()\n",
+    "\n",
+    "# Create the DyMIN microscope\n",
+    "opts = {\n",
+    "    \"scale_power\" : [0., 0.25, 1.],\n",
+    "    \"decision_time\" : [10e-6, 10e-6, -1],\n",
+    "    \"threshold_count\" : [8, 8, 0]\n",
+    "}\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = microscopes.DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts=opts)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"DyMIN\", microscope, datamap, params=params)\n",
+    "\n",
+    "# Create the STED microscope\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"STED\", microscope, datamap, params=params)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "histories = acquire_all(experiment, num_acquisition, bleach=True, processes=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('DyMIN', 170), ('STED', 150)]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<ipython-input-95-159a30b366a7>:74: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n",
+      "  fig, axes = pyplot.subplots(len(keys), 3, figsize=(5, len(keys)+1), sharex=True, sharey=True)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASsAAADBCAYAAACXDJbkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/M0lEQVR4nO29eZicVbXv/9k191Ddne505pgQCIkJIGAgDEEIkxcVEHDCAUS9BA+HHDjHm6twr6IezZEDR0CvBs/hB+gR74N4Ua9XpoBEE0gwhCAYkpCERDJ3p9Pd1UPN+/fHenfVW5Wqrurq6qS72Z/nqXTV+761391DfbPW2muvpbTWWCwWy0jHc6wnYLFYLOVgxcpisYwKrFhZLJZRgRUri8UyKrBiZbFYRgVWrCwWy6jAipXFYhkVHFOxUkrtVEr1K6V6XI8px3JO+SilTlJKPa2UaldKHZGUppR6QSkVdc1/y7GYp2VsopT6lFLqTaVUr1Jqu1LqPNe5WqXUj5y/zS6l1B8HGOe9Sqnnneu2KaWuOjrfQfUYCZbV5Vrretdjr/ukUsp3rCbmkAAeA744wDV/75r/nKM0L8sYRyl1CfA94AYgDHwA2OG65CdAM/Be5+ttRcbxAb8BfudcdyPwn0qpE4dt8sPASBCrI1BKaaXUzUqpt4C3nGP3KaXeUUp1K6Veyfsf5k6l1C+VUv+plIoopV5XSp2olPqaUuqg875LXdc3KqUeVErtU0rtUUr9s1LKW2guWustWusHgb8O9/dtseTxTeBbWuu1Wuu01nqP1noPgFJqLnAFcKPWuk1rndJav1JknLnAFOD7znXPA2uAzxW6WCn1eaXUaqXU3Uqpw0qpt5VSl7nOv+B8Zl50vIn/q5RqUUr93Pl8/lkpNbOKPwdghIqVw0eBhcA85/WfgVOR/xkeBX6plAq5rr8c+BkwDngVeBr5/qYC3wIecF37MJAETgBOAy4FvjSEuS53TPE1SqkLhjCOxQKA85/nAqDVcdt2K6V+qJSqcS45E9gFfNP523tdKXXNYG4BnDTA+YXAFmA8cBfwoFJKuc5/ChG7qcDxwEvAQ8jn803gG4OYS3lorY/ZA9gJ9ACdzuPXznENXFjivYeB9znP7wSedZ273BnX67wOO2M2AROBGFDjuv5a4A8l7neC/LiOOL7QGT8IXA9EgOOP5c/VPkb/A7GENLAemIyIxhrgO875253zdwIB4Hznb/69BcbyI+7jMuf5pUAceLrIvT8PbHO9rnXuNcl5/QJwh+v8PcCTrteXAxur/TMZCZbVR7XWTc7jo67j77gvUkp9xQk0dimlOoFG5BdoOOB63g+0a61TrtcA9cAM5Be2TynV6Yz1ADChkslrrddprSNa65jW+hHkD+pDlYxlsbgwf7M/0Frv01q3A/9G9m+rH4mn/rPWOq61XgX8ARGiHLTWCcRT+TCwH/gnJA67e4D773e9v895Wu86n/95y3/tvrYqHOvg9UBkVt6c+NQy4CLgr1rrtFLqMGLKDpZ3EMtqvNY6WZWZ5qKpbF4WSwat9WGl1G5cn4O8538p9LYBxvsLYn0BoJR6EXhkqPM8mowEy6ocwkiMqQ3wKaW+DjRUMpDWeh/wDHCPUqpBKeVRSh2vlDq/0PVKCCGmNkqpkFIq6DxvUkp90DnmU0p9BlmxeaqSuVkseTwE3KKUmqCUGoes9v3OOfdH4G/A15y/vXOBxUis9giUUqc4f6e1SqmvIK7lw8P+HVSR0SJWTyMCsBUJKkbJcxMHyXWI+GxCYl+PI7+8QsxAzFqzGtiPBB5B3Ml/RkS0HbgFcWu3DmFuFovh28jC0lYkaP0q8B3IuHZXIm5hF/DvwHVa680ASqnblVJPusb6HLAPOIh4KJdorWNH6fuoCsoJiFksFsuIZrRYVhaL5V2OFSuLxTIqsGJlsVhGBVasLBbLqMCKlcViGRUMS1JooVIqlsJorYc1gXT8+PF6xoyZw3mLMcGuXTtpb28ftt+FUkpby6A0aYp/JkZyBrulCsyYMZM169Yf62mMeM5duGBYx/cAoZJXWaIDnLNib7FYRgVWrCwWy6jAipXFYhkVWLGyWCyjAitWFotlVGDFyjJokqk06bTNTrEcXaxYWQZFMpVmy74e2iKjqrqIZQxg86wsRxDpT9AbSzGhIYjHo0inNQe7Y9SHfNQGvIwPB6gLlv7TyR/HjRkzrTUepQpeU2zMSFQKvDbU+KkP+QY8bhk72N+oJYdkKk0kmuRwb4LWhiDptCaRSnOgK0paBwn5PbTUB/Co0sLSG0txqCdOa0MwZ3yPUqS1iJXWGp/Xk7lX2qmv5lEKj0eRTKVzxuzuT3KgK0pXPMFxzXWE/OIcRKJJ2iNxALweZcXqKOEFUiWvqg72N2rJYFy85voAc6eE8XoU+zujjlBBW3csIwgTG4NMbBw4J3tCQ5DWhiBex2Iy448PB2ipDwDQ2iDjmHsd7I5lxm+pD7BlXw8pV3xMa01XPMHVX3mUS68+lzsuOjEzzrypYYCyhNQydLxIn7w2XN0lhhErVhYg60Y11wcIh3woYH9nlO7+BCDi0RNN0htLiWD0JTIiUsztMi7k/s4o9SEfPo/iW89uIeDzMrW5hqvmTqQnmsSjYkxoCFIf8mU6HtQFfXiUYnw4QFdfInNfgJDXy0UfPYerT53I+HCAtu4Ykf5E5rx1AwfGCyxyvsaRhn+VWEcpRKgi1ZvagNjfqAUQl+1wb4ITJtaR1tDZl+Cttgg+5aHW76Um4KUnmqQzFqcx4M8Il9ejctwutysHkEprDvXEiSfTeD2KZ37+FHQdgHALH/zxzaR7NQd7YjTV+Qn5PYT8gcx701rTUh8gldZEE2lSabGsgl4PNy+aybTGWmoC0kj7UG+cPd39NAb8AIT8Hnze0b1+5EVWwLxIz60U0kE07bzurWBMP9J95YNIM8A+pDGhB2lKMNgx40jDzCDQ4YxfyTjlYMXKAojL1lwfYOu+CN9euZVnHn0aknEu+uxH+PtFx3HBZx+E7oNQ28gTd3+GhoAPr0cxZ3I9fpcoHOyOZVw5AI+CEyeH+eYzW/nRv/1SxnBx1x+28cJvX+J33/8sYUdo8mltCDJncj2b90ZIaTJuIH1d0DCBJ/7lY9z3xx288NuXeOLuz+DtjnG4N5FxZUcrs4A5iKu1GulushNxuTYAX2TwovBBpMvEhcCkiUAz3P0mnANcDHyVgTcTu2ly5uNtBCIwNS0W22DHKZcRKVaLFy/mggsuyLzu7+/n3nvvJRod/LcfCoW47bbbCIWy8ZXnn3+eVatWHZNxRiq9sSTd/UlSaU13XwL6uljwiSvpiyX59u/fhIM7IN4P0R6+/fs3+fDpU7ho5njaI3Eaa7NuV33IR1pr2rpj1AZ91Id8tEdi/O1Qn1hUQPj0D3DKadO5a+U2Xn/1b9AfYWJ9iLTW9MdTtDYEUUqhnXGMizehMUSkP0FnLAE9HfJw5rPlr3uh9zAaTSqtUcp0Bx69YhVCrKD1SMO/7wLeO2DqOzB1HVy3RUTs9UGM2YqI36ST4NAbsPKANA9sRawiP+WLjB/wLgDeBzTBU/dAN9JqxzuIOZXLiBSrCy64gK9//esAJJNJ2traWLFiRUViVVNTw7Jly2hqasocS6VSFYnVLbfcQmtrKz6fr+JxRiqRqKyyKaUIBbzQPJWbLzyOH6zczoZHH8teGO9nw6OPUVPzGS54TwsHu2N4HDcwmUpTG/AS8ntoj8SpD/loDUuQvD+ehPpm6OlgzrwpfPGc6Xxh6Qro7YRxU5jYGCQSTRJNpGmpD+D1KFJpzeHeBNFEmngyzrTmGiL90BWPg07nzAeA+mY6Y3FCXu+odwEhmwS5Gfg6cMYdwK1II7h5cMNXJV40GLHyI64kF8PeN+A/gGc/j/RTfh68ZaTPhRAxakLmwcXAyXDyDOCn8Mp6cTGjVHelcESKlZu1a9eycuXKioSqmsRiMR544AEuvvhiFi1adEznMpxorVm2+AQ+f9Y0Pv+1x+Dw3pLXQ+GVPgCf18PcKWHuvmI+G8+cyg23/Jj1j/2GLzwRFKHKI5XWbN4bQSmVcSE9CnqiSY77/CPQsRdSiYLvpaeDLyxdwUWfu4KvXzJnKD+GEcEbiIZsnwgsBW4Axv8LeL8KT8D8IEwfZG7uQ0hAfe1H4OSl8GwAUcUfU6Q9ai5+ZxrzEIOKs4HTgRObYX4Imvby/uVww5vSy/7Pg5vegIx4sZo+fToLFizIWDODJZFI8Kc//YlwOJw5tnPnzkGP4/P5WLBgAdOnTyeZTLJ27dqKxhlpmORMpRSTmkK0dccI4iHs90PvYXH9iuD1KFobgoRD2ZU7d7Koe4UunkzT4PeD8siY7nHTKQ50mQRRiVH1OFaWR0F/PEVnX4JLP3Qqa14M07txdfFvqLeTaOJoZf4MLykcl6wNaem7BZj8mBw8gYp8rQTQCbDXeRFFFOgN2J4ubQmlkXjZbGAuiGkXAXQHvIUE1vZmFweqyYgUq/7+fjo6OgAIh8PMmzcPr7cyLziZTPLcc88RDGYTE7dt2zbocbxeL/PnzyccDnPw4EGeffbZisYZaaS1rNaNDwdoCQc53JtA/iQHoL6ZkN+LUirjsqW1zuRdJVOy8tcfT9ETTWaspKDPA81TIBmHaE92vFSC1w92MqWulvqgL2OZJVKSHtHdL0mqd1x0IrfHkqzJF6v6ZnDlVtWH/Hg9CjUG8q1SwOY0zF0PTAeaN4jITIX+vspW3RIALzov2oBJ8noLpfUvBaxDPL+6ICJ67yC+5S+AJ2F7l8wrUcHcBmJYOjIPtQZ7KBTKCWRrrenu7qbSuQaDwZw/3GQySTKZHNQYSikaGhoy40Sj0YrGyWe4a7C///0LdKmyxqm0RiF5USknL2rLwQjXfPmHEsR2U9/MQ/cvYWJNiJDPi0fJz8brUTmrb2acA13ivk9qCjGhIUg0keaffruJx/71J7nj1jVx83//LF+/5ES27ovQEpak0K37Ik7AXFYel/1uMz/97o+PmE+jayVxVks905prBrUSeO7CBbzyyvph+114ldKVlDUOAd9EXK7ZSCyoYSIQhpO3iU5UIgqTgI8BVyGri22Iy7kOMZDeKfH+Dznv/STgnQb44Yy3ZSxjsKUZfMwqCqRGUw32aDRa1RhVLDb0Tbdaa7q6uqowm5GH+VCn07L65vEoZrXUcel1l7Pmxe0Ztyt8+gc488yZTKwJEfR6Mi6bsZxU3piNtf7Mfj+tNe2ROBMaglxz8gT2f+mznDC5gY6eGB2RGCdMbmDxceNoj8RoCYtr6XPcTJPAfqgnzsIZ9Wz/4mcA2PjKLno3vcIPVm7nw6dPYfGM8WitiSVStHXHyt5vOJJJIKGkQ87DC0QOQNuBrCdXCfuBVWSTOqPOYz/lJXluBp5ArLE5u8Xom4Xkbe2scE6lGJFiZTm6uPfrHeqJ01wfYHJTiK9fModvpDXPbX8TgDPPnMkdF52YETevR9xAv9dTUBTqQ77MKuHB7hiHeuKMq/Mzf2Ij377svcyZXM+hnngmJ+pAV5T2SJx5U8OZ1Ty3a7lpT4T5LY1890NNpNKa21OatRtXs+G3K2kddwUXH9cKiPsZTaQZHw7gGcWpCyCWyfPkulUvIhbQUHmdwa0kutnhPH6PxNdNBkMnVqwsw4R7FW9iYygjGm/t7+HEybKK9/aimYBsczGJoBKngq37Ipn9fQON31wfYPak+oxbl9aweW+ECc49y3XZWhvEPdy81/n/33EDT5s8jqnjZA4HukQYxxLrgdec59WOBQ2VDmTl8jWqnwjqZkCxUko9BBQLFGmt9RerPyXL0SR/Fc/rUTTU+FFK0R6JEU+maQoGMvFC486ZEGBLODhguRj3+Mat6+pLZJI/wyFfRqgaaiQwXmgjskcpJjYGM9t3JjSGuO6caTTUXs5pk8fh96pM5rzHI9eOpQ3NKY5edYPBcgjZdjMcW2zclLKsflfg2HTgNoYnSdVylJEPdq5VVB/yEfJ72LQngtbaEZPsB/9gdwyPyuZQDWQV5Y8/sTGE1pBI6Uy1Bfd9i21ANuPsPdxPeyTOnMn1fGBGK/NbGpk6LkR7JJ5TsaFURQhL9TDZC8PNgGKltf6Vea6UmgXcDnwA+BfgweGdmmUk0NoQZIKrHpVJ2nSXdhks+aVjBouZA5BZnZ3QEGR8WFIexpJFZclSMmallJoL/A/gNOBfgZu01kNbr7eMeNxul7FYGmr81Aa8TGoKURf0VSw2vbFk0QqipTAuqpuD3bHM3ExFU1siZuxRKmb1S+D9wD2I65cCGswfi9a6o/i7LaMZ43aZgnimdlXI7xmyi2UqiI6r8+N1UmrK2cuXTKWPKCPj3p4T8ns41CPxNCtWY49Sv9EzkAD7V4B/IjeVRiOpFZYxzISGIOPq/GzeG6GtSqVX3OVo0pojEkoLYVYV3VVDQQL+5pCJoVkncGxSKmY18yjNwzKCyG/04MfDpKZQRhQOdEXLrsaZ32zCNInQWqwiER/PgOVc3FVMzdzM6qQpJWPu1WbdwDFLKTfw9IHOa603VHc6lpGAab4wPhyAtOwfrAl4Cfo8eD2KTXskuD1QNc78xhBprfF7FQe6ohnryGzTKbWPL6eKaVrTG0vh83roT6ToTUjWUXMicERji7FQJiafENmqoSMFL7IXOkVlW2zKpdR/P/cMcE4jBQctY5iD3TG2tfVw+bJf8o9/dxFfu/AEgAFdwkLlYtq6Y7R1x3B7cVprWhtDJVcV3W5jKq0zianfeGYrD9z9CwAuve5ybr9wdqaxxVioFJqPKc+ygepksFeLhc4jgpSEeW3gyyumlBu4eJjuaxmBuMvFNNX6+cbTW/nboT72tvfAwR08+sx7aO9JsG1/NxfNa+Xcac3c8eRmPjl/MqfNbAJyXTZ3sugzO9p5cdshli0+gdXvHGbdjg7uvmI+r+/r4kdrd3HjGe/B51U5PQTdvQWN2/jMjnZe2NzGCZMaONwb49xPXpa5753PbGHZ4hMIej1jolIoiEBdCExBNh9/BCkdvA14FtnyshcpehCjdGLmdGcsU310IfB9pFLoJEQIy7GM3ocEtGc4c1mHWHxNSOnklWWOMxhKuYFXD3Rea/1/qjsdoaamhpqamszrdDpNV1dXRVUXlFI0NTXluBl9fX2D3ihdrXFGMu5yMU11fn70/cehM9tkaf8LT/LTF+S5+uJnOG1SAw888CyBv/sgJ09vwOf1ZFw2Y9WYcjGv7Orkhade5fqzpvHUxr1s+P0fCVx9Mk+/1cFDP1vNxbOuoiHgw+f1ZFYJTbZ6MpXOVF54ftNB1j78KC8CCz77Kb72QWnF9Z0nN/PS40+z9AM3ExxD7l8AqW5wOjDfA5wMp5odx12yyfkA0IJkkpcSqymI0BxAqi5c74fHE3J8FrCR8kTmDOBGYP40eHS37FdMIUX5FiCbpI+qWAGPI/Pf6LzOXw0cFrG69dZbWbZsWeZ1Z2cnp556akVVDxobG9mwYUNOWePly5dz1113HZNxRjLu1bSeWOlUusaAnyf+9VpqfF627Oth7pTwEQmfZsyHP30aHVfOZ/4N/x+07YRElPkfv5v/euvH2PnTG9jZ1psJuOdXCm3rjnGgK3rEf1brH/sN1/za+U8t3g/B2ir/RI49QeBzzcAnkCJSH0IKr/8ObrhfNOtFxMIqRxzWI0L115uRmjNB2PhzeGQ1/APl7zucAsxvBn4Gn54Bn25B6sp8A/78q8HVci+XUmJ1NfAp4BTgN8AvtNbDXnEuFApRX1/P2rVrSSaTRCIRUqnKdNpYRK+++iqrV6/m7LPPZv/+wbdkNOO4xcpdc2u0426//vq+Ln71+gGI9hA+/QPMmTeF9Y/9Jqe658ZXdvFdv5e7r5hP0O/NlIgp1Ca+rTvGa3s7ZcxD78g4gRoWXL6Y90+t43BvnG+v3Mo5JzRz0czxmbIzAO2RGL2xZM6qX4b8iqNjTKzmIBYMtcBP4PAKGLcD8fneBy1+mJMQS+mNMse8GLgWxJecAkTg2dVSPSGNWHD7EddyIMIgPuVEYCagZsH8nbAwzRm/Be8w7LYuFbP6NfBrpVQd0sHnHqVUC3CH1npYOyUkk0leeeUVYrEYfX19Qy5yt27dOlasWIHWmj179gx5ftFolERipO1/r5zeWIr2SJxUWrNizS5eePT/QbSHOfOm8HeLZ0rNdCMM9c30bn+T5zo6GXftaVLWuEAgO53WxFNptrX1cO8fdrD28aekQmhNGFpncPOFx9Hg97NxfyfP/fpF+Og5XHxca6bsTFprtuzrIZlKo7UeuPJnoAbC4wl4PWMmqD4T0RQS8EhautA8vw0JMM0AUuL+zUWqCZf679yPxKk+Pg0RGj+wF5Yjllkz4salKC1WdThv8AIqANQDTTCpA2aBZ8tgvtPyKDcZJYp02OlGfkzDblKEQiFuuukmtNYcPnyY++67b0jxoVtvvZWbbrqJUChENBrlueeeq3isaDTKAw88wMsvv1zxGCMNd/LnssUncP1ZSwo3d3BV5lQodrb1MqkpVDCrPbOS+I//ybkfXshD98uYn77lk9xx4QniEnYdgLpxPLz8E0yoCWXcQDPm3CnhTMXRgWKWCz5xJXd+eC4LZoyjPRIfEyViViIB79YDcP1xcP0XkKDUOuBZODktLl2c0u6bH4lR/QZ4ZDdsuAfWPAF3AC8sBZ6HP78hrlQ5wZb9IEt/vwOujcPkifDXv9B7nYjncGxtKRVgvxBxA89Efnb3aa0HrpFbBZ5//vkct6+/v79ioerv72f58uU5LtuaNWuGNE4ikeDll18eEzXYDR6Pwqsl32l8fZDJjSEuvf5KqRS66RUWfPZTBINSaOOBP+7iunOmcf7MVtq6Y3T1JdBaBK83lsy4k0oppjXVcOnV5xLpT/CDldshEaPP2RtIpF3KJitFQ8CfCYybelfGhXS7gZecNIHkZz91hFv65hu7+X59IOOWjoUSMSmkmN1/AjPfhrmr4G//U6ygdxCX7XWkWmcp0oj11QqcDLBBXMedIKKzQwL0McqLfT0PhHrgHx5HlOl9z8Jq2OOMv7rMcQZDKctqJfAX595B4Dql1HXmpNZ6aZXnA8CqVauq1o8vGo1WJQherXFGKmknuG1awTfX+bn9wtncmUzzwv793HzhcUysCRFNpbj6v/1vzprdwsdPCdIeidMfT5FIaVobghl3EqRiw+SmkIzzzBZeevxpCNbS1h3lr21dUNso3W6aJmbcN7PqB2QSSk2ZmlQaLnhPC6dObMgG1oO14AvS+/ZbPHfgIDsXHcecieExUyImgZQPngl8aSVchJQi9iO12SOUJ1YpJP/pSsS13LNLBM8L/O0leV6OK2lYjYjdVS/Be9YDjRBvh91InG3dIMYqlwEbRiilrh/ozVrrR4q8r/pdKMYoI6FhBMD+zijtkRgnTg7THskmcEaTKQ72R/n81x7joqvO5fYLZ9MdT3L8+DomN4XYtCeSqTLqdXKj0s7f1MHu3HGijrV818ptrH1yHQ8v/wTzWxuZ1BQi5PdwoCuWaTAxeVwNreFAZnxTHTSV1nTGElzz5R+y4KOX8o0PzeWkKQ20R+Ls7uqnIeBj8rgaJjcNTqxGasMIg+nOfAOy+reayrLZ/Ug6hAfJsToZsdz6cLX+GsScvoxYdxsQ683Mp9KATcUNI4wYKaVO1lpXWq7ZMgqoD/lQCnyu4PTERlmVm5wIcek1izj7+Ga8HsWJE+ppqMl2k+mJJvGobIOG/LrnExulD6DZ03fJSROoC53LhBppGd8TTVIbCB7RYOJgdyynmqhSinCNj+b6AJdedzlnH99MOOCjN5YirTWNQX/FHZBGOlFECF5ErBdzbLAkyMa3tiEi1UFlVlACEc09DE+MKp9yA+w/UkoFgYeBn2utx2abl3cx7s2/HqXweT0ZaymZSnPHRSeSTKVRToa5z+vJJHxGE2kSqTitriJ9+eN4VIxoIp1x5RbPGJ/pLWiaO7jnsL8zyqGe+BHJpW4X1cS2TDDdVDQdI4uBR5BCxKFa7GRozR1SVLfjcinKEiut9XlKqdnAF4BXlFIvAw9rrZ8Z1tlZjgnlVvI0CZ8mrSD/evc47tXGlFMWZs7k+qIrd8WSSw90Rdm8N5LZY+huYGEY7YF1S2HKrqOhtX5LKfU/kCTY+4HTlERCbx+ubTeWY4M7Z8oki7Y2BIn0J4gm0pnjpoyMt8j2Fvc47tVG04PE3VvQVPvMWHcFhNLdzMJNvtiVW77GMroo6zeqlDoFie19GNk/ebnWeoNSagrwEsO07cZybEmm0kSiyUx5Fq11Tkt3s4+wUG8+UyKmmOiYlb/agJeQ38OWfT0ZN28g3L0IQdIcth3ozZSdMauJVqzGHuX+Rn8A/AdiRWWSW7TWex1ryzLGKNTvryUczOn9VyyjPL8XYT6tDUHGh4M5PQcHU+HTXTXU7B/0qNxGEpaxR7kxq/OVUq1ITn1/3rmfDcfELMeOSH+C7v6kWFb9iUwOlvt5bdBHQ40vEx/KrwhqegW6j4f84i72RJOZki/u5M/8Cp/u9+ZbSqm0zgTd27pjKAVjdCHQ4lAqg10B3wBuxtkFpJRKAj/QWn/rKMzPcgyIRJMc6IqilKInmqQnmqQrniCU8NITlWzyuqCXlvpAxs0z5WVMs4aW+kBOpVANhPwBumMJeuOK3lgqExRPpNIc6ok712QrfJox3cejiRR9sRRdsTg+5SGIh61tEbQGpaQSxFimWpVC/QytqqcXydUKkN3uY37yw1UttFThn9uAc4EztdbNWutxSC7ZuUqp24ZhPpYRhMlZ6oonuPorj3LPqu2Z423dsZwGDma1rjUczLhpbZFYznj98RSXL/sl96zanlnF01rz1v4eZk+S54XGdB//7nPbOP6qu7jixh9wz6rtmbld8+UfcvVXHqU7Pna7xIWQGlILhziOH6k0c8IQxjgByYa/EykO6Ac+iRQHPJvh6YBcyg38HHCJ1rrdHNBa71BKfRZ4BikyaBljvL6vi3v/sCPzOh5PQsce1q7dwR3Ovr/rzpnGhbMmoDiywUQ6Ja5iV1+CZEoqdj63/QB/3NYJ7btYu3Yc3wLuvmI+8aQU1mvrjuHxKJrrA5ksdlM1FCROtb8zytwJIRZ85ALWP/Yb1q7dweHuKHTskX2CSqERd1VBRX0JRxKmeucspMBBK1I14QxEKP6EbJHZUWyAAsxGKiucDpyDJJYuZ/AJph3IFp1/RcTKbN3Zj+Rurefo7w30u4XKoLVuU0oNm73trhSaSCRIJBJDqrgQCoXw+/34/TJlWyk0F/fKXTKV5oWdnVLOpSc3L7l342rWbpTn86b/HR8/ZRppnV0ZHFfnx+8Y616P4nBfgj3d/TQG/Pxqw/5M2ZneTa/w3P79bDxzKg1+P8oJjk9qCtFSH2Dbgd5MAuq4On8mvrW1LcKk2ppMyZrejavZsNE1Qa3pjMUJ9XqJJtKZ+YxWwWpCLJirEYGZDXibkfpWaWjdKy5XKbEyVk4KKZlyPlIray4igo8i+w3LKYsMYuFFkU3WEz4AE2bD3BDwOBw+IAL6Y6rf2KKUGzhQnY1hq8Fx6623sn37drZv387Pf/5zlixZQjAYLP3GAoRCIZYsWcKjjz6aGXPp0sHvvzaVQs0YlY4z0nC7bOb5R+dM4KH7l0BdU9H3bdvXzaY9ETbtidAeiWVW4toisYz79sTmAxnXbNniEzJjLvjElTz83Y9zw9cey3Hf2rpjGZdwfDiYGbM9Estx976wdEW2ZI2bng6+sHQF96zanjOf0coOJC/o6kaYexN4fwscmiU7mBF3a0YZ48wCFiOi9QfEHbpgkWSfnwVsuBTeCcL/wqlTNQCmacX/BjY0Av8GfA0JGP0vGHcjnDtRLL+huJmFKGVZvU8p1V3guGIYa1qFQqFMRc5TTjkFpRQPPvggsdjg//D8fj8XX3wx9fX1bNy4EcBWCnXhUSqzcgdiwfg9iga/XyoiFCGlxdVz9+8zq3sgltWFs8ax7aPnEPR6WP3OYZ7auBcSMd58Yzf3p9NweC/hk87gzDNnEvR6qA3Kqp+pDmrmA85KX0/HEdZeDqF6Pn3LJ/nArMbMe9OjeIUwhWMRNCNmVjPAlXDZ9+F1eM9PoKmv9DiHnLFSiMt2FcDZcHknnPwG0Ap7YlKaqpQF4nWmEQZRgGbguAAwDcI74E0gIZUgqr1fsNRG5uGIkw2KGTNm0NDQgM9XWZKfz+dj0aJFvPHGG6xZs4ZoNMquXbuqPMvRi2kTD2QSLQdDbm8+lTPO/ImN3H7h7Eyjhw2PPgaQ477NmTeFmxeJWNUFvTTX+TNJnqYsjGznAcLjjyxl7Kamge/8lzn0xlKZ1cwxQc6n8P0w+Uy46mV4EsJl1IfpICsc5wNfmIj4lafCzG7gJamc8DTl1WD3muuiyHIgc4GFMCEKjXuhV1zBzjLGGgxjpw1ICc4666whuZOWIzErevOmhjMPrXWOewgMWAlh/WO/KegGzpsaZs7k+symZNOc4vSPXV58QskYb+ztLuu+o4UEsHYbErHuA6kUtV7qDu8YvCAcAg4dQMyotxCxqYX/MgP+L47FNABR4C6kew0JJNhFO9ADz+6F9ZAaJs97RO5JGK5KoabC586dO4c0juGFF16oaE6jgTq/j5uXfZpfPb+d/S88mT0RqGHBJ64kndZ857mtPPKZ0+mPpzKrge69e5H+BP3xFK0NQa47Zxpe72cAaTbRu1HqB7jdQJMV71FisXmUzrSt11rj7Y7x4dOn4PEcWSnUkEhn23aNBbGKIltHpq+EqTMAzw+keNQzcHdCLJhZlL8i+BJwN3D6r+DjTyK1jtfBn3dJXatyPmVRpCpnqA/+4T5g3l5o+YUcfL78dl6DZUSKla0UeuzwehRaS2mX/3nxbFIaVrzSkr0gPJ47PzyX76/awTP/71WS156W027e7PXzeWXHYCKlmdgY4pzp45lUG6Ix4OeOlJZVxfpmzjl7Vqbci0eRqVtlivhNbAyRTmsSqTRt3TEueE8Lp01q4Ornpmc75dQ3S0ZofQsKdzv60V8uJgH8AqkUeseDoJ4HdsHraRGdVqT3wy7KE4g/k21kurcP/uF38NcOaUbx0CDm9SIilB97WObgRRo0bEIqkg5HK5UBK4VWPKitFFo2I6VSqCGV1uzvjHKwO4ZHQTSZps/VWSjg9bBgxjj2dUbZ09XPwuOaOdgdoz0SZ97UcKbki9nrpxEBuuP3m/nRj5/iibs/w/dWvsXax5/iofuXcNrkcUxqDLJ5b3afoNejcupZmb6BxsIC6I4n+fbv32TDb1fmNLBoCPiY1BTK5GcV20ydz2ioFBpC4jYmQ9zsgvRSviUznWzn5bORnK1HnLEqEZgwkqQ6DxFVUyTwqFcKtbz7MGVblIK27hjNdQGmB2to65b0BJ9TK318OEhNwItHSdkWr0dav5uKo/k9BD82bxKBWy7j+PF1XHfONOpCH2FiTYiAz4Pf62FSU4i6oC+zBcc9Tn3Ih3YtPrtdwnENMs74+iB1Qa+zT1DlBf5HP1GKC8BgXC4jcCnEdexDutlU6rZFEGvKBPGHw/0zWLGyHIHZdHy4N5GpzNnWHcuUdjElWMzm4mLP3bzvPY2ZFvOLvROY3yLpBR6VXZFMO5uTfV5P0TGNS3i4N8HFx7Vy8XGtpNKa+pCP1nCAw72JUe/6DSedZIPyeyndH7AcqjVOKaxYWQpSqDLnxMasmzZYDnbHMm7dhIYg48MBILeqp/uaYvcQlzNWsCyMmbPVqrGJFStLUfIrc5rGDZWQ7x4WKtjnvqbUOD6PxKLMiqFJah0r3ZgtR2LFyjIgxdy64RinkmvcSa2Wsc3YikJaLJYxixUri8UyKrBiZbFYRgVWrCwWy6jAipXFYhkVWLGyWCyjAitWFotlVGDFymKxjAqsWFksllHBcJWIaUNK7FgGZobWunU4b2B/F2UzrL+LCn8Pp+W99gAHkc5XAeBkpGKMYT+wr8hYU5BK7jXONUdj73ElFP09DItYWSyW6qKUqkfE6ENa6z8qpWYCbyPt8kp2dlVKXY8I3U3Aq1rrO4dxusOCdQMtltHBNYjY/KmSN2utH9FaP0m2pFVRlFJ3KqUeU0r9VCkVUUr9VSm1wHV+p1Lqvyml/qKU6lVKPaiUmqiUetK5fqVSalwl8xwIK1YWy+jgeuCn+khXaJdSardS6iGl1Pgq3u8KpD1gE/Bb4Id5568BLgFOBC4HngRuR6oce4CqN9W0YmWxjHCUUqaR8iOuw+1IVeIZwPuRCsM/r+JtV2utf6+1TgE/A96Xd/4HWusDWus9iLW3Tmv9qtY6CjzBkfG2IWNLxFgsI5/PIeLxtjmgte5BGnQBHFBK/T2wTykV1lqXdPXKwN0JuA8IKaV8rvjYAdf5/gKv66swhxysZWWxjHyuI9eqKoRxD8fsZ9paVhbLCEYpdQ4wFfhl3vGFSDn1t4BxwP3AC1rrriLj+JFGOB7Ap5QKAQnHzRsVjFkVtljGCNcD/6eAazcLeApZ3XsDiAHXmpNKqRVKqRWu6/8dcc+uBe5wnn9uGOdddWyelcViGRVYy8pisYwKrFhZLJZRgRUri8UyKrBiZbFYRgVWrCwWy6hgWPKslFJ2ibFMtNbD2kJY+Wq0CoSH8xZjAh2PoJP9w/a7UEppaxmUJk3xz4RNCh3jqECY4JxPHOtpjHhiWx4b1vE9gO0bXZroAOes2FssllGBFSuLxTIqsGJlsVhGBVasLBZL2XgHOO4t47qhYMXKYnmXMxhhKVaiIf/4cJRysGJlsYxyBrJ2ysFT4Np8S2mw9y401lCtLStWFssIYaAPsxfwF7lmIGunlEB4gYTz3J/33nKtIyNEqbzX+XMZqrVl86wslhFCOR9mY12kEHFJl/E+Ixxu8fLkvbdSISkkiMPlElrLymIZwbiFIJ13LkD2A1zIgnILk3H1PIjIhci1pGDwlpT7noVcyWLvrRRrWVksIwy3yATyzqVc56IMbBkZq8e4eWHnPe4s8Tqg1rk2jdRJds+j0LhGmIz4hZ1x3iErnm6rzT3OUKwsK1YWywjFiEEI+ZAnnK91zvEucl28QrhdJz9Za6qFbAwsjohLAhEyc59CY3qd+Zj7hoFm52svWZHqdM2rWm6gFSuLZYRirJcwIgJxRExCzsN0hsh35yBXIIxgBZz31QIzgaBz/AAiUHHgEAMLlR8RS0Or8wgj/bqM4PUx8D6/SrBiZbGMAPJdrlpEWMJId9M6RCgiiNXS5jyPkrWKCglMgqzAeIBpwGykO6qx2J5HhK+TrBDlx8fcFlqzc10jsBCx0mqBLcBeYI8zrw7E2ir2PQ6WESlWixcvZuHChdx7771MmjSJadOmsXbtWpLJZOk35xEKhbjtttvYt28fO3fuBODtt99m165dgxrH5/Nx1llnMXv27Mx8tm7dOuhxLJZCFPoQ15G1WmYB04EdZAXLiEEUsYqKjWPcyRakp9cs4DLneC/SzbTNeewgK1QeckUrgFhjXmdeM5D+8TOc108DG5wx21xzqxYjUqwWLlzIjTfeyEMPPcTs2bM5/fTTWb9+fUViVVNTw7Jly9i4cSOrVq0CQGtdkVide+65XHbZZZx55pl873vfo7e314qVpWoYy8MITi3QhFhAM5H+7QFEAHoRYWlDhKuL0oLVjIjKVGDCSXK8pRNO3Q07OTKYD1nBSpNb5qbRmdMZ9cDJwBQ4/1fi/u1Ggu0h5LWZT761NlhGpFjde++9PPTQQ1x77bXU1dVVJFLDSSwW44EHHqC9vf1YT8UyhnCnGIB80DvIDbBf+F6gDXrb5bo/AS8hrl6c3BU447q5Y1pRoBvEPHPU8MI++FMHvI5YcXGyQXfy3psGJpGNoTGTTFCt5kw4/2URzxfJClU5uWDlMCLzrM4++2yWLl3KRz7yES655BIWLVqEz1eZrvb397N8+XJ27drFwoULeemllzLuYKUY1/Lcc88d0jgWixtjwaQQi8rvPDfW0FQPohRkY1ZpRHPc6QSQFYk02YC3iXElgO5dkHoT9BtAXI65rSd3ED1fJCJkrTjecQYPy8AesukQIbK5YNXY2DwiLauFCxdy0003ZV53dnbi9Vb27UajUe666y6++tWvct5557F27Vq6ugp22C5rrEgkQl9fH1/60pdob2/PuJYWy1BwB59N7hJkhasZ5x/Ht3oHiTUlyLpm+W6k+6vJoTJxpNfIpjLM7RFry1hOJj0hQq5QmU9gL9ncrYNdMKENCai1iW6BCFbIudZLYRdwsAH3YenIPNQa7KFQiFAoWwRWa013dzdDmWsoFCIYDA5pnGAwiN/vz1h50WiUaHRoIcThrsHuqZ2gbVnj0sS2PEa67+Cw/S68Sun8ssb5++ncH9wmsmkGZyBB8RlIeKgNEavXkLjVTmQVLt/lMmMaS8frGvNKRIhizlg7ARN9jZC7igfZnCw/YtzNcOY0j6yI+Z2xdiErgyZoP5gVwSiQGk012KshAsMxZiwWIxaLVWlGFkuW/A9wr+vYIdfXNCIIZlXQuIKFhMq9jzBKbuxqM1nh2IHExqLOewqJibGMvIiFZvYlxpznxn3sQCy+XucRJ1egxlzqgsXybifhet6BiJIRmx3ANrLB8FTe9W48rvO1ruPbyIrZLnLFZKBtMnHXNSaFohax3ryIO5kfH/PnjVEpVqwslmPEQB9eY7lEkFW6JkScNrmueafAOO64Vf74EbIW1yHX8RDZzPNibpp73IAzVpfz1eAhd8uOSWqNUB2sWFksI5D85X73VpaBlppKWS9GcNxjJChsmaXynpv3mLQGt0VnzsedY/nB/mpgxcpiGQHkWzT51lIciQGZdAaTZlDs+mKB+0IU26pTCGM9GeKu52Ze5jojaEPdZmMoKVZKqRbg08Bc59CbwC+01oeKv8tisQyGUitkhmKxqcEEsUtVaihGvqXkLj+Tj/t4tayrAZNClVLvBd4A3g9sBd5CVlJfV0rNHei9Foulepi0ATepvEchCh13u4KVFuA7FpSyrL4N/IPWOqe3tlLqGuA7wDXDNTGL5d1MvutkCvElipwv9r6ByB+znHHyj7tjX0OdTylKbbc5OV+oALTWvwJOqtIcLBZLHvkf8Pzg+mAEw32dyVo3WeXFMg/zg/D54+TfM+U6Xo2tNYUoJVb5iazlnrNYLFXCXS/d7LkzguBO/iyFEbIA2UTOgd5bjkVkaroXKgBYbUq5gROUUv9Y4LhC9ldaLJZhxIsIVIxsldB868pYScVWAN3XG+vK47ouf99euSIF2X2JmSoMBcarFqXE6t/J7qnM5z+qPBeLxcKRm5pNOeJm57jpTmPcr4TrWsiNa0HWMksgH2bzgTbJm61ks9E7C8zBvDYCZ+5vkj7NHEwxvz5ya7BXiwHFSmv9zSrey2KxlIH5gBthmYQIVYvz+hCyBcdUZymWPpCf4xQkKzIzyFpp+8kKnbthhBv3PkNTQqYZsfoanK87yApZsXGGQqnUhcdcz7+Xd+6ZKs4jB5/PR01NTebhrsAwWJRSjBs3LjNGKBSqqDZWtcaxWAqRH5T2IsLUilRfmYfUO78MOAepo97EkV2a0xw5lmkGEUIEqxap3rAQqe/eigihEZ9S8SdTwsYI6CykimmT82ghN5Bf7HssdbzQfQdituv5JXnnhi1mddZZZ7F06dLMY8mSJQSDwdJvLEBjYyMbNmxg6dKlhEIhlixZwsKFC4/ZOBaLm2IJmmHE/QsAc5CM7DnAqYgwnIR8OKcgAlNL4bLEKbIF8WYiInUecBVwOiI4XwIuRkTHlJNxx37cyZ9mTs1ka7nPca6Z48wnyOAC7uVaX6VMg4EKP1W/EJaDsaxAmju89dZbpFKVGZTJZJLXX3+dmpoazjvvPOrr6yuyiKLRKD/+8Y85cOAAZ511Fhs3bmT37t0VzcliMRTLTTJWhCmxYuqxNwLHI6JiKnZ2kFvr3IxhMDEv8/CTdTHDSJOHTtd9omSrPBQKlntc17Q4x8JkXb8+554xcuNnxcrPlEspy6pWKXWaUur9QI3z/HTzegj3LYtQKMShQ4fYtGnTkMRqzZo1JJNJTjvtNBKJBIlEMS+/ONFolPvvv5+DBw9y/vnns27dOtsswjJsuGtUmVpRtUCNByYF4VSPuIZTyXZUzk8iNQ/jkuV/2MOIJbQF6R1o4lEgIhMo8B6DEataxMqaQrYyhImNVTudoZSJsQ/4N+f5ftdz83rYMK7WzTffTHt7O6eeemrF5YgB1q5dy5o1awAqbum1ZMkSLrvsMk455RTuu+++qhcItFggWyvKbQ2BWCqpNHidRoB7O7Jlg81fonujsXluCvm94Vw7CVhNtiifqTza5nqvn9z29Ab36qQf2X83FbH43kFK2LzlGsOUNi60r3Cw5kcpsfqa1nrtIMccMm+//TbPPvssXV1d+P1++vv7K67QmUwmWb16Nbt37x6SuCSTSdavX09nZyfPPfecFSrLsGHcsTgiILvIdeFSPSJmG8hWDB2oaoPJVDd11U2pYbNaZ+qym4J5UdcY+TE14xZGkXpWHYiIehDrxVQu7SYb2C9EJX7SgDXYlVIbtNanD3rQIdZgfzdha7CPDI5FDXY4spwLZFfbTMeZhUjwejbicnUgNdefJSswpm9gfh0s9/jNiBU0kdwYVwvSRXmvM545bnKnTLkXk2fVStYtPc+5bwRxJQ85c9lPbsJpuSVrhlKDfVg/SBbLu51iBe46yCZgvo40dHiRbLoC5LaOL9TnzwiDSSHocK49RDbHyoNYbu7uye46VOa1+2sv2eqfacQFDCFWnilr7M6xcu8XHEqAvZRYHaeU+m2xk1rrK4Zwb4vFkkf+h9nElVJka5v7kbhRH9kVuELvz3fdILta10fWUkpQeNWvmLCY642baooCduPE1chNIq1WYmgpsWoD7qnSvSwWSxnkWzWm7LARqyAiVqaEsEkEHag3nzub3QTd3VUYDKW6JxvXztw7QtbKcu8NLJVmMBwB9h6tte3iabEcRcwH2YiJKWtsxMgEsY2LFyBXlNzkvzbBdr/rubluoM3QbtyrhGbFMX9rTaFxhlrbqpQAHlZKTTIvlFLXKaV+o5S6XynVPIT7WiyWIqRcX/NX1PJFxVg5hWJWxcY173MH0ktZVPnjmDhUofSGYvcs9rxcSolVE87PSin1AeBfgJ8iAf+fVHA/i8UyCIw4uZuMFjtfjgCk8r6a58Uy6Qcqpue2qo4GpdxAj9a6w3n+SeAnTpXQXymlNg7rzCyWdzH5lThNgmWa3NVAQ75gmJW+/O0u5I3hXvlzd6QpJnyFNk2buFffAN9PNYLspSwrn1LKCNpFwPPuc1W4v8VicWEsGXdMyBx3X5Nf0aDUmJBrobnHMQmngbzri41j5uUnu4na3UI+zLFZDfwFsEop1Q70A38CUEqdgLiCFoulSritH7P8n19JwYiEl2yaQL4AuQUi30Jz38NtFZlxoq5zxTZGm3kFybaNB7Hi6sh2eI5TPaGC0sX3vqOUeg6YDDyjs+nuHuCWKs7DYnnX404xMA8/knluRGYKWSHZi7he7iRN4zLmJ3aCBKDNlp1WsgJVSzYtwl00L99VNCuP7ooNTc5YzcjeQLNdx0M2raFaG9NKunKF9gZqrbdW6f4Wi8WFESVTfC+M1I1qIluMz4jVi0giJGSz2fNXC3GN53bT5jhjhZEM9jYkwx0kudOdoZ7Ke16LiOZ0Z17zgBOQTcy7kWx7M69qMiLjTqY6qNksrLUe0sbhUCiEUtmdQ4lEYtCVF5RSNDU15YzT19dnNzRbhkR+HpK7znkdsm9vHiIMkxBxMXlX7zjvS5CteQ5Hul5mvAAiNK1IEb45yF7BVcB21/1NYN69f9DtPtY58zkZ2Wd4HjBpGszcDeucuW1xfW/5rmiljEixuvXWW1m6dCkrVqwgGo0SjUZZsWJFRZUXTGkXd2nk1atXZ8rFlIupFNrU1JQ5tnz5cu66665Bz8liMRRLpDTNHWYhpYdnItaMafwQQfbihRFrqZPcTchmHFPK2FhUFwIfBC6sl+oNncDfB+GpGDyObEA2MTATNE+73t/ozONkpEro8TciO61PgKn3wNUrYUofvEa2oJ87274Q5SaLjkix2rdvH5s3b2bx4sUARCIRHnzwwYrEyu/3c/HFFxMOhzPH9u/fP2ixMpaVW6yGUhveYsnHxJqMUKXIVjOYCTQ0AougJg0NbTBlfVakTFAbcqslxMkG5BsQsZkI8CHwJqClF2iBM34BL5Hb9MFdFytOtsxME1mR5DSkxvJUxFTbAs1bZL7umNVACavlWlsjUqx27tzJunXrWLJkCfX19UQikYqbM/h8PhYtWpQRmWg0ytNPP13x3JLJZKbSaCUVRy2WYrhX1cx/g91I+ZYESBT7I8gnfy+0rhc3sYNs41KTnuBuy2XEoBZx4epAuk6YHIMEtKyCiXuzq4Om9hWucUzwPIwrdWI6MolaRLCa5b1TECttP0cxwH6sMK7fokWLmD9/ftXGfOCBB3j55ZcrHsNdcXQo41gs+Zj28CGy3WhakVW/t4AZb0PDHxClcJTkkHOuk2xBPeNGQm4GeggJfG8EZj6LCNY8pGxot2hOC5IS4U7wTCMCZyysPyPW2SFg0r1IdH0qsBb6X5IY2GayZW6gcEJntTcyHxPefvttTJbE5s2bmTBhQsWB7P7+fpYvX04oFCKRSPDyyy+zbdu2isfZv39/pvb6zp07K5qTxVIM9369TkRgWpBg+mpg0WPZvnxvkFswz22ZuUXCVFnoRCydHSCR8N2ImbQJ/twjoncIsebMnj+zAhhHrLe087ULCaLPWgk1qwA/9PbJsDuc871545jvr9xk1nwGrBRaKbZSaPnYSqEjg2NVKbQYdUhgvAlZbTNB8klk859eQ8TnANm655C10PKz32cgBtAs4MvOdZ2I2G1CivxtIhtrcruB7mz3kxDvbzrSFiyCWGIhJG1hlzOfDkT83FZaqQoMQ6kUarFYhhn3vjx3Z+Q44pI9SzYm1eq61hS+M9aL2/UzCabuWlWmIUQE+GdETDqARYiVtMkZrxgmnrUDMcpeQ6y9WkSoOpy59Dr3yi9pbMYYTIUHN1asLJZjTKEPrsm3MiuCpmX7O+SKWwIRNPdqm9vVcldrMLlTIELYhbh8ryEWkLHIjNvmtn5SZFf1zNxM5rzJiu8kK0QDbWquFCtWFssIoFgsx4t88E0iqLs2ey3ZVbpCuKsumHtAtsGDWd3b5Dpv8rhMDS2v65wpB+NOXjXlkcl7nh/gz8+CrwQrVhbLCCG/QoFbaCKIJeMu4WJeQ+4GaPdY+RubIVcwjMVlXve53u/GLTj5sTfz/vwN1O6SNO7vsVKsWFksowB3DKpYsb1i7qT7nKksWkxAiomJ+3ixXoDFrj9aJWIsFssxptDKWTlCVYh8K8scc1tCxe5pjhdKhS7kwlazPAyULr5nsViOMcVcuHLIb+QAxYXFnZ9VLIZWjuVV6l6VYsXKYhlFVMNaqbbFc7TuZcXKYhklVNNKqQZHez5WrCyWUUI57lwxyr12MIHxo+H6ubFiZbGMUgbjYo1W18+NFSuLxTIgI8X9tGJlsVgG5GhaZQNhxcpisYwKrFhZLO9C3O2+qjnmcDJc9azakLI2loGZobVuHc4b2N9F2Qzr78L+Hsqm6O9hWMTKYrFYqo11Ay0Wy6jAipXFYhkVWLGyWCyjAitWFotlVGDFymKxjAr+f0bzYHyRJb3RAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x216 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 216x216 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_and_gen_gif(histories, show_res=True)\n",
+    "plot_bleaching_curve(histories, keys=[\"STED\", \"DyMIN\"])\n",
+    "# plot_and_gen_gif(histories, show_res=True, savename=\"./panels/image_dymin-conventional_multiplesources-wnoise.gif\")\n",
+    "# plot_bleaching_curve(histories, keys=[\"STED\", \"DyMIN\"], savename=\"./panels/bleachingcurve_dymin-conventional_multiplesources-wnoise.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare reducing number of molecules"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "experiment = utils.Experiment()\n",
+    "\n",
+    "for num_mol in range(2, 12, 4):\n",
+    "    molecules_disposition = numpy.zeros((50, 50))\n",
+    "    for i in range(1,4):\n",
+    "        for j in range(1,4):\n",
+    "            molecules_disposition[\n",
+    "                i * molecules_disposition.shape[0]//4,\n",
+    "                j * molecules_disposition.shape[1]//4] = num_mol\n",
+    "            \n",
+    "    # Create the DyMIN microscope\n",
+    "    opts = {\n",
+    "        \"scale_power\" : [0., 0.25, 1.],\n",
+    "        \"decision_time\" : [10e-6, 10e-6, -1],\n",
+    "        \"threshold_count\" : [10, 5, 0]    \n",
+    "    }\n",
+    "    datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "    microscope = microscopes.DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts=opts)\n",
+    "    i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "    datamap.set_roi(i_ex, roi)\n",
+    "    experiment.add(\"DyMIN-{:02d}\".format(num_mol), microscope, datamap, params=params)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "histories = acquire_all(experiment, 1, bleach=False, processes=4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('DyMIN-02', 0), ('DyMIN-06', 0), ('DyMIN-10', 120)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "plot_and_gen_gif(histories, show_res=True, savename=\"./panels/compare_dymin-number-molecules_multiplesources.gif\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare different structures"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Multiple point sources"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Creates a new molecule disposition\n",
+    "numpy.random.seed(42)\n",
+    "random.seed(42)\n",
+    "\n",
+    "# p_ex = 1e-6\n",
+    "# p_ex_array = numpy.ones(molecules_disposition.shape) * p_ex\n",
+    "# p_sted = 2.5e-3\n",
+    "# p_sted_array = numpy.ones(molecules_disposition.shape) * p_sted\n",
+    "# pdt = 100e-6\n",
+    "# pdt_array = numpy.ones(molecules_disposition.shape) * pdt\n",
+    "\n",
+    "molecules_disposition = (numpy.random.rand(50, 50) > 0.99).astype(int) * 16\n",
+    "\n",
+    "experiment = utils.Experiment()\n",
+    "\n",
+    "opts = {\n",
+    "    \"scale_power\" : [0., 0.25, 1.],\n",
+    "    \"decision_time\" : [10e-6, 10e-6, None],\n",
+    "    \"threshold_count\" : [2, 2, 0]    \n",
+    "}\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = microscopes.DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts=opts)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"DyMIN\", microscope, datamap)\n",
+    "\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"STED\", microscope, datamap)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "histories = experiment.acquire_all(num_acquisition=2, processes=2, bleach=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "# plot_and_gen_gif(histories, savename=\"./panels/compare_dymin-conventional_default-structure.gif\")\n",
+    "plot_and_gen_gif(histories, show_res=False)\n",
+    "\n",
+    "fig, ax = pyplot.subplots(figsize=(3, 3), tight_layout=True)\n",
+    "for key in [\"STED\", \"DyMIN\"]:\n",
+    "    molecules = histories[key][\"datamap\"][:, molecules_disposition != 0].mean(axis=-1)\n",
+    "    ax.plot(molecules, label=key)\n",
+    "ax.set(\n",
+    "    ylabel=\"Avg. molecules left\", xlabel=\"Frames\"\n",
+    ")\n",
+    "ax.legend()\n",
+    "# fig.savefig(\"./panels/molecules-structure_evolution.pdf\", transparent=True, bbox_inches=\"tight\")\n",
+    "pyplot.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fiber-like structure"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Objects:   0%|          | 0/10 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "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": [
+    "from skimage import morphology\n",
+    "# Creates a new molecule disposition\n",
+    "numpy.random.seed(42)\n",
+    "random.seed(42)\n",
+    "\n",
+    "image = numpy.zeros((50, 50))\n",
+    "ensemble = temporal.Ensemble(roi=((0, 0), image.shape))\n",
+    "for _ in trange(10, desc=\"Objects\", leave=False):\n",
+    "    obj = temporal.Fiber(random_params={\n",
+    "        \"num_points\" : (30, 50),\n",
+    "        \"pos\" : [(0, 0), image.shape]\n",
+    "    })\n",
+    "    ensemble.append(obj)\n",
+    "molecules_disposition = ensemble.return_frame() > 0\n",
+    "molecules_disposition = morphology.binary_dilation(molecules_disposition)\n",
+    "molecules_disposition[molecules_disposition != 0] = 2\n",
+    "\n",
+    "fig, ax = pyplot.subplots()\n",
+    "ax.imshow(molecules_disposition)\n",
+    "pyplot.show()\n",
+    "\n",
+    "experiment = utils.Experiment()\n",
+    "\n",
+    "opts = {\n",
+    "    \"scale_power\" : [0., 0.25, 1.],\n",
+    "    \"decision_time\" : [10e-6, 10e-6, -1],\n",
+    "    \"threshold_count\" : [8, 8, 0]    \n",
+    "}\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = microscopes.DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts=opts)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"DyMIN\", microscope, datamap, params=params)\n",
+    "\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"STED\", microscope, datamap, params=params)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "histories = acquire_all(experiment, num_acquisition=num_acquisition, processes=2, bleach=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 85,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('DyMIN', 180), ('STED', 150)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "plot_and_gen_gif(histories, savename=\"./panels/compare_dymin-conventional_fiber-structure.gif\")\n",
+    "plot_bleaching_curve(histories, keys=[\"STED\", \"DyMIN\"], savename=\"./panels/bleachingcurve_dymin-conventional_fiber-structure.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare DyMIN parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Creates a new molecule disposition\n",
+    "numpy.random.seed(42)\n",
+    "random.seed(42)\n",
+    "\n",
+    "delta = 1\n",
+    "num_mol = 2\n",
+    "molecules_disposition = numpy.zeros((50, 50))\n",
+    "# molecules_disposition[\n",
+    "#     molecules_disposition.shape[0]//2 - delta : molecules_disposition.shape[0]//2+delta + 1,\n",
+    "#     molecules_disposition.shape[1]//2 - delta : molecules_disposition.shape[1]//2+delta + 1] = num_mol\n",
+    "for j in range(1,4):\n",
+    "    for i in range(1,4):\n",
+    "#         molecules_disposition[\n",
+    "#             i * molecules_disposition.shape[0]//4,\n",
+    "#             j * molecules_disposition.shape[1]//4] = num_mol\n",
+    "        molecules_disposition[\n",
+    "            j * molecules_disposition.shape[0]//4 - delta : j * molecules_disposition.shape[0]//4 + delta + 1,\n",
+    "            i * molecules_disposition.shape[1]//4 - delta : i * molecules_disposition.shape[1]//4 + delta + 1] = num_mol\n",
+    "\n",
+    "experiment = utils.Experiment()\n",
+    "\n",
+    "opts = {\n",
+    "    \"scale_power\" : [0., 0.25, 1.],\n",
+    "    \"decision_time\" : [10e-6, 10e-6, -1],\n",
+    "    \"threshold_count\" : [20, 10, 0]\n",
+    "}\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = microscopes.DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"tc20-10\", microscope, datamap, params=params)\n",
+    "\n",
+    "\n",
+    "opts = {\n",
+    "    \"scale_power\" : [0., 0.25, 1.],\n",
+    "    \"decision_time\" : [10e-6, 10e-6, -1],\n",
+    "    \"threshold_count\" : [10, 5, 0]\n",
+    "}\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = microscopes.DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"tc10-5\", microscope, datamap, params=params)\n",
+    "\n",
+    "opts = {\n",
+    "    \"scale_power\" : [0., 0.25, 1.],\n",
+    "    \"decision_time\" : [10e-6, 10e-6, -1],\n",
+    "    \"threshold_count\" : [5, 2, 0]\n",
+    "}\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = microscopes.DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"tc5-2\", microscope, datamap, params=params)\n",
+    "\n",
+    "opts = {\n",
+    "    \"scale_power\" : [0., 0.25, 1.],\n",
+    "    \"decision_time\" : [10e-6, 10e-6, -1],\n",
+    "    \"threshold_count\" : [1, 1, 0]\n",
+    "}\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = microscopes.DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"tc1-1\", microscope, datamap, params=params)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "histories = acquire_all(experiment, num_acquisition=25, processes=4, bleach=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_and_gen_gif(histories, savename=\"./panels/compare_dymin-parameters_multiplesources.gif\", keys=[\"tc20-10\", \"tc10-5\", \"tc5-2\", \"tc1-1\"])\n",
+    "plot_bleaching_curve(histories, savename=\"./panels/bleachcurve_dymin-parameters_multiplesources.pdf\", keys=[\"tc20-10\", \"tc10-5\", \"tc5-2\", \"tc1-1\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Increased intensity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Microscope stuff\n",
+    "egfp = {\"lambda_\": 535e-9,\n",
+    "        \"qy\": 0.6,\n",
+    "        \"sigma_abs\": {488: 1.15e-20,\n",
+    "                      575: 6e-21},\n",
+    "        \"sigma_ste\": {560: 1.2e-20,\n",
+    "                      575: 6.0e-21,\n",
+    "                      580: 5.0e-21},\n",
+    "        \"sigma_tri\": 1e-21,\n",
+    "        \"tau\": 3e-09,\n",
+    "        \"tau_vib\": 1.0e-12,\n",
+    "        \"tau_tri\": 5e-6,\n",
+    "        \"phy_react\": {488: 1e-7,   # 1e-4\n",
+    "                      575: 1e-11},   # 1e-8\n",
+    "        \"k_isc\": 0.26e6}\n",
+    "pixelsize = 10e-9\n",
+    "bleach = True\n",
+    "p_ex = 1e-6\n",
+    "p_ex_array = numpy.ones(molecules_disposition.shape) * p_ex\n",
+    "p_sted = 30e-3\n",
+    "p_sted_array = numpy.ones(molecules_disposition.shape) * p_sted\n",
+    "pdt = 100e-6\n",
+    "pdt_array = numpy.ones(molecules_disposition.shape) * pdt\n",
+    "roi = 'max'\n",
+    "\n",
+    "# Generating objects necessary for acquisition simulation\n",
+    "laser_ex = base.GaussianBeam(488e-9)\n",
+    "laser_sted = base.DonutBeam(575e-9, zero_residual=0)\n",
+    "detector = base.Detector(noise=True, background=0)\n",
+    "objective = base.Objective()\n",
+    "fluo = base.Fluorescence(**egfp)\n",
+    "\n",
+    "experiment = Experiment()\n",
+    "\n",
+    "opts = {\n",
+    "    \"scale_power\" : [0., 0.25, 1.],\n",
+    "    \"decision_time\" : [10e-6, 10e-6, None],\n",
+    "    \"threshold_count\" : [10, 5, 0]\n",
+    "}\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = microscopes.DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo, opts)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"DyMIN\", microscope, datamap)\n",
+    "\n",
+    "datamap = base.Datamap(molecules_disposition, pixelsize)\n",
+    "microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo)\n",
+    "i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)\n",
+    "datamap.set_roi(i_ex, roi)\n",
+    "experiment.add(\"STED\", microscope, datamap)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "histories = experiment.acquire_all(num_acquisition=2, bleach=True, processes=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "plot_and_gen_gif(histories)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image = numpy.random.rand(4,5)\n",
+    "print(image)\n",
+    "fig, ax = pyplot.subplots()\n",
+    "ax.imshow(image)\n",
+    "pyplot.show()"
+   ]
+  },
+  {
+   "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/minor_bugs/decay_time_bug.py b/minor_bugs/decay_time_bug.py
new file mode 100644
index 0000000..c85f104
--- /dev/null
+++ b/minor_bugs/decay_time_bug.py
@@ -0,0 +1,69 @@
+"""
+------------------------- BUG DESCRIPTION -------------------------
+I would expect that changing the decay_time_us would change the slope of the flash
+The lower the day_time_us, the faster the flash should go from peak back to normal,
+however, changing this value does not seem to change anything
+-------------------------------------------------------------------
+"""
+
+import numpy as np
+from matplotlib import pyplot as plt
+from pysted import base, utils
+
+
+print("Setting up the microscope ...")
+# Microscope stuff
+egfp = {"lambda_": 535e-9,
+        "qy": 0.6,
+        "sigma_abs": {488: 1.15e-20,
+                      575: 6e-21},
+        "sigma_ste": {560: 1.2e-20,
+                      575: 6.0e-21,
+                      580: 5.0e-21},
+        "sigma_tri": 1e-21,
+        "tau": 3e-09,
+        "tau_vib": 1.0e-12,
+        "tau_tri": 5e-6,
+        "phy_react": {488: 1e-6,   # 1e-4
+                      575: 1e-10},   # 1e-8
+        "k_isc": 0.26e6}
+pixelsize = 20e-9
+bleach = False
+p_ex_val = 1e-6
+p_sted_val = 30e-3
+pdt_val = 10e-6
+# pdt_val = np.random.randint(0, 100, size=(64, 64)) * 1e-6
+
+# Generating objects necessary for acquisition simulation
+laser_ex = base.GaussianBeam(488e-9)
+laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+detector = base.Detector(noise=True, background=0)
+objective = base.Objective()
+fluo = base.Fluorescence(**egfp)
+microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)
+i_ex, _, _ = microscope.cache(pixelsize, save_cache=True)
+molec_disp = np.ones((64, 64))
+molec_disp[29:34, 29:34] = 3
+temporal_dmap_1 = base.TestTemporalDmap(molec_disp, pixelsize)
+temporal_dmap_1.set_roi(i_ex, intervals="max")
+decay_time_us_1 = 1000000  # 1 seconde
+temporal_dmap_1.create_t_stack_dmap(decay_time_us_1)
+
+for i in range(temporal_dmap_1.flash_tstack.shape[0]):
+    temporal_dmap_1.update_whole_datamap(i)
+    plt.imshow(temporal_dmap_1.whole_datamap)
+    plt.title(f"i = {i}, max = {np.max(temporal_dmap_1.whole_datamap)}")
+    plt.show()
+
+temporal_dmap_2 = base.TestTemporalDmap(molec_disp, pixelsize)
+temporal_dmap_2.set_roi(i_ex, intervals="max")
+decay_time_us_2 = 100  # 1 seconde
+temporal_dmap_2.create_t_stack_dmap(decay_time_us_1)
+
+for i in range(temporal_dmap_2.flash_tstack.shape[0]):
+    temporal_dmap_2.update_whole_datamap(i)
+    plt.imshow(temporal_dmap_2.whole_datamap)
+    plt.title(f"i = {i}, max = {np.max(temporal_dmap_2.whole_datamap)}")
+    plt.show()
+
+
diff --git a/pysted/base.py b/pysted/base.py
index d808f13..d8582fc 100644
--- a/pysted/base.py
+++ b/pysted/base.py
@@ -4,25 +4,25 @@
 molecules, to obtain a microscope setup. The following code gives an example of
 how to create such setup and use it to measure and plot the detected signal
 given some ``data_model``.
-    
+
 .. code-block:: python
-    
+
     laser_ex = base.GaussianBeam(488e-9)
     laser_sted = base.DonutBeam(575e-9, zero_residual=0.04)
     detector = base.Detector(def=0.02)
     objective = base.Objective()
     fluo = base.Fluorescence(535e-9)
     microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo)
-    
+
     data_map = io.read_data_map(data_model, 1)
-    
+
     # imaging parameters
     pdt = 10e-6
     p_ex = 1e-6
     p_sted = 30e-3
 
     signal, _ = microscope.get_signal(data_map, 10e-9, pdt, p_ex, p_sted)
-    
+
     from matplotlib import pyplot
     pyplot.imshow(signal)
     pyplot.colorbar()
@@ -51,7 +51,7 @@
 .. [Jerker1999] Jerker, W., Ülo, M., & Rudolf, R. (1999).
    Photodynamic properties of green fluorescent proteins investigated by
    fluorescence correlation spectroscopy. Chemical Physics, 250(2), 171-186.
-   
+
 .. [Leutenegger2010] Leutenegger, M., Eggeling, C., & Hell, S. W. (2010).
     Analytical description of STED microscopy performance.
     Optics Express, 18(25), 26417–26429.
@@ -68,7 +68,7 @@
 .. [Willig2006] Willig, K. I., Keller, J., Bossi, M., & Hell, S. W. (2006).
    STED microscopy resolves nanoparticle assemblies.
    New Journal of Physics, 8(6), 106.
-   
+
 .. [Xie2013] Xie, H., Liu, Y., Jin, D., Santangelo, P. J., & Xi, P. (2013).
    Analytical description of high-aperture STED resolution with 0–2pi
    vortex phase modulation.
@@ -81,6 +81,8 @@
 import pickle
 
 # from pysted import cUtils, utils   # je dois changer ce import en les 2 autres en dessous pour que ça marche
+import tqdm
+
 from pysted import utils, cUtils, raster, bleach_funcs
 # import cUtils
 
@@ -92,15 +94,16 @@
 from matplotlib import pyplot
 import time
 from functools import partial
+import pickle
 
 
 class GaussianBeam:
     '''This class implements a Gaussian beam (excitation).
-    
+
     :param lambda_: The wavelength of the beam (m).
     :param kwargs: One or more parameters as described in the following table,
                    optional.
-    
+
     +------------------+--------------+----------------------------------------+
     | Parameter        | Default      | Details                                |
     +==================+==============+========================================+
@@ -110,25 +113,25 @@ class GaussianBeam:
     | ``beta``         | ``pi/4``     | The beam incident angle, in            |
     |                  |              | :math:`[0, \pi/2]` (rad).              |
     +------------------+--------------+----------------------------------------+
-    
+
     Polarization :
         * :math:`\pi/2` is left-circular
         * :math:`0` is linear
         * :math:`-\pi/2` is right-circular
     '''
-    
+
     def __init__(self, lambda_, **kwargs):
         self.lambda_ = lambda_
         self.polarization = kwargs.get("polarization", numpy.pi/2)
         self.beta = kwargs.get("beta", numpy.pi/4)
-    
+
     # FIXME: pass Objective object instead of f, n, na, transmission
     def get_intensity(self, power, f, n, na, transmission, datamap_pixelsize):
         '''Compute the transmitted excitation intensity field (W/m²). The
         technique essentially follows the method described in [Xie2013]_,
         where :math:`z = 0`, along with some equations from [Deng2010]_, and
         [RPPhoto2015]_.
-        
+
         :param power: The power of the beam (W).
         :param f: The focal length of the objective (m).
         :param n: The refractive index of the objective.
@@ -148,16 +151,16 @@ def fun2(theta, kr):
         def fun3(theta, kr):
             return numpy.sqrt(numpy.cos(theta)) * numpy.sin(theta) *\
                    scipy.special.jv(2, kr * numpy.sin(theta)) * (1 - numpy.cos(theta))
-        
+
         alpha = numpy.arcsin(na / n)
-        
+
         diameter = 2.233 * self.lambda_ / (na * datamap_pixelsize)
         n_pixels = int(diameter / 2) * 2 + 1 # odd number of pixels
         center = int(n_pixels / 2)
-        
+
         # [Deng2010]
         k = 2 * numpy.pi * n / self.lambda_
-        
+
         # compute the focal plane integrations i1 to i3 [Xie2013]
         i1 = numpy.empty((n_pixels, n_pixels))
         i2 = numpy.empty((n_pixels, n_pixels))
@@ -169,13 +172,13 @@ def fun3(theta, kr):
                 w_rel = (x - center)
 
                 angle, radius = utils.cart2pol(w_rel, h_rel)
-                
+
                 kr = k * radius * datamap_pixelsize
                 i1[y, x] = scipy.integrate.quad(fun1, 0, alpha, (kr,))[0]
                 i2[y, x] = scipy.integrate.quad(fun2, 0, alpha, (kr,))[0]
                 i3[y, x] = scipy.integrate.quad(fun3, 0, alpha, (kr,))[0]
                 phi[y, x] = angle
-        
+
         ax = numpy.sin(self.beta)
         ay = numpy.cos(self.beta) * numpy.exp(1j * self.polarization)
 
@@ -191,12 +194,12 @@ def fun3(theta, kr):
         electromagfieldx = exdx - eydy
         electromagfieldy = eydx + exdy
         electromagfieldz = ezdx + ezdy
-        
+
         # [Xie2013] I = E_x E_x* + E_y E_y* + E_z E_z* (p. 1642)
         intensity = electromagfieldx * numpy.conj(electromagfieldx) +\
                     electromagfieldy * numpy.conj(electromagfieldy) +\
                     electromagfieldz * numpy.conj(electromagfieldz)
-        
+
         # keep it real
         intensity = numpy.real_if_close(intensity)
         # normalize
@@ -212,7 +215,7 @@ def fun3(theta, kr):
         intensity_flipped[0: n_pixels // 2 + 1, 0: n_pixels // 2 + 1] = numpy.flip(intensity_tr, 1)
         intensity_flipped[n_pixels // 2:, 0: n_pixels // 2 + 1] = numpy.flip(intensity_tr)
         intensity_flipped[n_pixels // 2:, n_pixels // 2:] = numpy.flip(intensity_tr, 0)
-        
+
         idx_mid = int((intensity.shape[0]-1) / 2)
         r = utils.fwhm(intensity[idx_mid])
         area_fwhm = numpy.pi * (r * datamap_pixelsize) ** 2 / 2
@@ -222,11 +225,11 @@ def fun3(theta, kr):
 
 class DonutBeam:
     '''This class implements a donut beam (STED).
-    
+
     :param lambda_: The wavelength of the beam (m).
     :param parameters: One or more parameters as described in the following
                        table, optional.
-    
+
     +------------------+--------------+----------------------------------------+
     | Parameter        | Default      | Details                                |
     +==================+==============+========================================+
@@ -243,13 +246,13 @@ class DonutBeam:
     | ``zero_residual``| ``0``        | The ratio between minimum and maximum  |
     |                  |              | intensity (ratio).                     |
     +------------------+--------------+----------------------------------------+
-    
+
     Polarization :
         * :math:`\pi/2` is left-circular
         * :math:`0` is linear
         * :math:`-\pi/2` is right-circular
     '''
-    
+
     def __init__(self, lambda_, **kwargs):
         self.lambda_ = lambda_
         self.polarization = kwargs.get("polarization", numpy.pi/2)
@@ -257,14 +260,14 @@ def __init__(self, lambda_, **kwargs):
         self.tau = kwargs.get("tau", 200e-12)
         self.rate = kwargs.get("rate", 80e6)
         self.zero_residual = kwargs.get("zero_residual", 0)
-    
+
     # FIXME: pass Objective object instead of f, n, na, transmission
     def get_intensity(self, power, f, n, na, transmission, datamap_pixelsize):
         '''Compute the transmitted STED intensity field (W/m²). The technique
         essentially follows the method described in [Xie2013]_, where
         :math:`z = 0`, along with some equations from [Deng2010]_, and
         [RPPhoto2015]_.
-        
+
         :param power: The power of the beam (W).
         :param f: The focal length of the objective (m).
         :param n: The refractive index of the objective.
@@ -289,16 +292,16 @@ def fun4(theta, kr):
         def fun5(theta, kr):
             return numpy.sqrt(numpy.cos(theta)) * numpy.sin(theta)**2 *\
                    scipy.special.jv(2, kr * numpy.sin(theta))
-        
+
         alpha = numpy.arcsin(na / n)
-        
+
         diameter = 2.233 * self.lambda_ / (na * datamap_pixelsize)
         n_pixels = int(diameter / 2) * 2 + 1 # odd number of pixels
         center = int(n_pixels / 2)
-        
+
         # [Deng2010]
         k = 2 * numpy.pi * n / self.lambda_
-        
+
         # compute the angular integrations i1 to i5 [Xie2013]
         i1 = numpy.zeros((n_pixels, n_pixels))
         i2 = numpy.zeros((n_pixels, n_pixels))
@@ -310,21 +313,21 @@ def fun5(theta, kr):
             h_rel = (center - y)
             for x in range(n_pixels):
                 w_rel = (x - center)
-                
+
                 angle, radius = utils.cart2pol(w_rel, h_rel)
-                
+
                 kr = k * radius * datamap_pixelsize
-                
+
                 i1[y, x] = scipy.integrate.quad(fun1, 0, alpha, (kr,))[0]
                 i2[y, x] = scipy.integrate.quad(fun2, 0, alpha, (kr,))[0]
                 i3[y, x] = scipy.integrate.quad(fun3, 0, alpha, (kr,))[0]
                 i4[y, x] = scipy.integrate.quad(fun4, 0, alpha, (kr,))[0]
                 i5[y, x] = scipy.integrate.quad(fun5, 0, alpha, (kr,))[0]
                 phi[y, x] = angle
-        
+
         ax = numpy.sin(self.beta)
         ay = numpy.cos(self.beta) * numpy.exp(1j * self.polarization)
-        
+
         # [Xie2013] eq. 2, where exdx = e_x, eydx = e_y, and ezdx = e_z
         exdx = ax * (i1 * numpy.exp(1j * phi) -\
                      i2 / 2 * numpy.exp(-1j * phi) +\
@@ -332,7 +335,7 @@ def fun5(theta, kr):
         eydx = -ax * 1j / 2 * (i2 * numpy.exp(-1j * phi) +\
                                i3 * numpy.exp(3j * phi))
         ezdx = ax * 1j * (i4 - i5 * numpy.exp(2j * phi))
-        
+
         # [Xie2013] annexe A, where exdy = e'_{2x'}, eydy = e'_{2y'}, and ezdy = e'_{2z'}
         exdy = ay * (i1 * numpy.exp(1j * phi) +\
                      i2 / 2 * numpy.exp(-1j * phi) -\
@@ -340,20 +343,20 @@ def fun5(theta, kr):
         eydy = ay * 1j / 2 * (i2 * numpy.exp(-1j * phi) +\
                               i3 * numpy.exp(3j * phi))
         ezdy = -ay * (i4 + i5 * numpy.exp(2j * phi))
-        
+
         # [Xie2013] eq. 3
         electromagfieldx = exdx - eydy
         electromagfieldy = eydx + exdy
         electromagfieldz = ezdx + ezdy
-        
+
         # [Xie2013] I = E_x E_x* + E_y E_y* + E_z E_z* (p. 1642)
         intensity = electromagfieldx * numpy.conj(electromagfieldx) +\
                     electromagfieldy * numpy.conj(electromagfieldy) +\
                     electromagfieldz * numpy.conj(electromagfieldz)
-        
+
         # keep it real
         intensity = numpy.real_if_close(intensity)
-        
+
         # normalize
         intensity /= numpy.max(intensity)
 
@@ -368,20 +371,20 @@ def fun5(theta, kr):
         intensity_flipped[n_pixels // 2:, 0: n_pixels // 2 + 1] = numpy.flip(intensity_tr)
         intensity_flipped[n_pixels // 2:, n_pixels // 2:] = numpy.flip(intensity_tr, 0)
         intensity = intensity_flipped
-        
+
         # for peak intensity
         duty_cycle = self.tau * self.rate
         intensity /= duty_cycle
-        
+
         idx_mid = int((intensity.shape[0]-1) / 2)
         r_out, r_in = utils.fwhm_donut(intensity[idx_mid])
         big_area = numpy.pi * (r_out * datamap_pixelsize) ** 2 / 2
         small_area = numpy.pi * (r_in * datamap_pixelsize) ** 2 / 2
         area_fwhm = big_area - small_area
-        
+
         # [RPPhoto2015]
         intensity *= 2 * transmission * power / area_fwhm
-        
+
         if power > 0:
             # zero_residual ~= min(intensity) / max(intensity)
             old_max = numpy.max(intensity)
@@ -394,10 +397,10 @@ def fun5(theta, kr):
 
 class Detector:
     '''This class implements the photon detector component.
-    
+
     :param parameters: One or more parameters as described in the following
                        table, optional.
-    
+
     +------------------+--------------+----------------------------------------+
     | Parameter        | Default      | Details                                |
     +==================+==============+========================================+
@@ -422,32 +425,32 @@ class Detector:
     |                  |              | is the ratio of collected photons that |
     |                  |              | are perceived by the detector (ratio). |
     +------------------+--------------+----------------------------------------+
-    
+
     .. [#] The actual number is sampled from a poisson distribution with given
        mean.
-    
+
     .. [#] Excelitas Technologies. (2011). Photon Detection Solutions.
     '''
-    
+
     def __init__(self, **kwargs):
         # detection pinhole
         self.n_airy = kwargs.get("n_airy", 0.7)
-        
+
         # detection noise
         self.noise = kwargs.get("noise", False)
         self.background = kwargs.get("background", 0)
         self.darkcount = kwargs.get("darkcount", 0)
-        
+
         # photon detection
         self.pcef = kwargs.get("pcef", 0.1)
         self.pdef = kwargs.get("pdef", 0.5)
-    
+
     def get_detection_psf(self, lambda_, psf, na, transmission, datamap_pixelsize):
         '''Compute the detection PSF as a convolution between the fluorscence
         PSF and a pinhole, as described by the equation from [Willig2006]_. The
         pinhole raidus is determined using the :attr:`n_airy`, the fluorescence
         wavelength, and the numerical aperture of the objective.
-        
+
         :param lambda_: The fluorescence wavelength (m).
         :param psf: The fluorescence PSF that can the obtained using
                     :meth:`~pysted.base.Fluorescence.get_psf`.
@@ -478,17 +481,22 @@ def get_detection_psf(self, lambda_, psf, na, transmission, datamap_pixelsize):
         ra_flipped[returned_array.shape[0] // 2:, returned_array.shape[1] // 2:] = numpy.flip(intensity_tr, 0)
 
         return ra_flipped
-    
-    def get_signal(self, photons, dwelltime):
+
+    def get_signal(self, photons, dwelltime, seed=None):
         '''Compute the detected signal (in photons) given the number of emitted
         photons and the time spent by the detector.
-        
+
         :param photons: An array of number of emitted photons.
         :param dwelltime: The time spent to detect the emitted photons (s). It is
                           either a scalar or an array shaped like *nb_photons*.
         :returns: An array shaped like *nb_photons*.
         '''
         detection_efficiency = self.pcef * self.pdef # ratio
+        if seed is None:
+            seed = int(str(time.time_ns())[-5:-1])
+            numpy.random.seed(seed)
+        else:
+            numpy.random.seed(seed)
         try:
             signal = numpy.random.binomial(photons.astype(numpy.int64),
                                            detection_efficiency,
@@ -507,13 +515,25 @@ def get_signal(self, photons, dwelltime):
             # background counts per second
             cts = numpy.random.poisson(self.background, signal.shape)
             # background counts during dwell time
-            cts = (cts * dwelltime).astype(numpy.int64)
+            # cts = (cts * dwelltime).astype(numpy.int64)
+            """
+            ^^^ old implementation did this, however I don't think this is right ^^^
+            With this implementation, the number of photons simply increases as pdt increases. For example, if
+            noise is 1000 and pdt is 10e-6, the max photon count for the acq will be around 200, but if I increase pdt
+            to 100e-6 then the max photon count wil be around 2000. So the value simply increases for the whole image.
+            In order to see the noise on the acq, we have to put in ludicrous values for noise of at least 10000000000.
+
+            By commenting this line, I can put a more moderate noise value, around the photon count I expect to get in
+            the image. Then, as the pdt increases, the signal for the rest of the image increases while the noise stays
+            at the same level, which I think makes more sense.
+            """
+
             signal += cts
         if self.darkcount > 0:
             # dark counts per second
             cts = numpy.random.poisson(self.darkcount, signal.shape)
-            # dark counts during dwell time
-            cts = (cts * dwelltime).astype(numpy.int64)
+            # dark counts during dwell time ***DISABLING THIS LINE, see explanation in "if self.background > 0"
+            # cts = (cts * dwelltime).astype(numpy.int64)
             signal += cts
         return signal
 
@@ -521,10 +541,10 @@ def get_signal(self, photons, dwelltime):
 class Objective:
     '''
     This class implements the microscope objective component.
-    
+
     :param parameters: One or more parameters as described in the following
                        table, optional.
-    
+
     +------------------+-------------------+-----------------------------------+
     | Parameter        | Default [#]_      | Details                           |
     +==================+===================+===================================+
@@ -540,10 +560,10 @@ class Objective:
     |                  | ``585: 0.85,``    |                                   |
     |                  | ``575: 0.85``     |                                   |
     +------------------+-------------------+-----------------------------------+
-    
+
     .. [#] Leica 100x tube lense
     '''
-    
+
     def __init__(self, **kwargs):
         self.f = kwargs.get("f", 2e-3)
         self.n = kwargs.get("n", 1.5)
@@ -553,18 +573,18 @@ def __init__(self, **kwargs):
                                                         550: 0.86,
                                                         585: 0.85,
                                                         575: 0.85})
-    
+
     def get_transmission(self, lambda_):
         return self.transmission[int(lambda_ * 1e9)]
 
 
 class Fluorescence:
     '''This class implements a fluorescence molecule.
-    
+
     :param lambda_: The fluorescence wavelength (m).
     :param parameters: One or more parameters as described in the following
                        table, optional.
-    
+
     +------------------+--------------+----------------------------------------+
     | Parameter        | Default [#]_ | Details                                |
     +==================+==============+========================================+
@@ -594,13 +614,13 @@ class Fluorescence:
     +------------------+--------------+----------------------------------------+
     | ``k_isc``        | ``1e6``      | The intersystem crossing rate (s⁻¹).   |
     +------------------+--------------+----------------------------------------+
-    
+
     .. [#] EGFP
     '''
     def __init__(self, lambda_, **kwargs):
         # psf parameters
         self.lambda_ = lambda_
-        
+
         self.sigma_ste = kwargs.get("sigma_ste", {575: 1e-21})
         self.sigma_abs = kwargs.get("sigma_abs", {488: 3e-20})
         self.sigma_tri = kwargs.get("sigma_tri", 1e-21)
@@ -610,37 +630,37 @@ def __init__(self, lambda_, **kwargs):
         self.qy = kwargs.get("qy", 0.6)
         self.phy_react = kwargs.get("phy_react", {488: 1e-3, 575: 1e-5})
         self.k_isc = kwargs.get("k_isc", 0.26e6)
-    
+
     def get_sigma_ste(self, lambda_):
         '''Return the stimulated emission cross-section of the fluorescence
         molecule given the wavelength.
-        
+
         :param lambda_: The STED wavelength (m).
         :returns: The stimulated emission cross-section (m²).
         '''
         return self.sigma_ste[int(lambda_ * 1e9)]
-        
+
     def get_sigma_abs(self, lambda_):
         '''Return the absorption cross-section of the fluorescence molecule
         given the wavelength.
-        
+
         :param lambda_: The STED wavelength (m).
         :returns: The absorption cross-section (m²).
         '''
         return self.sigma_abs[int(lambda_ * 1e9)]
-    
+
     def get_phy_react(self, lambda_):
         '''Return the reaction probability of the fluorescence molecule once it
         is in triplet state T_1 given the wavelength.
-        
+
         :param lambda_: The STED wavelength (m).
         :returns: The probability of reaction (ratio).
         '''
         return self.phy_react[int(lambda_ * 1e9)]
-    
+
     def get_psf(self, na, datamap_pixelsize):
         '''Compute the Gaussian-shaped fluorescence PSF.
-        
+
         :param na: The numerical aperture of the objective.
         :param datamap_pixelsize: The size of an element in the intensity matrix (m).
         :returns: A 2D array.
@@ -648,9 +668,9 @@ def get_psf(self, na, datamap_pixelsize):
         diameter = 2.233 * self.lambda_ / (na * datamap_pixelsize)
         n_pixels = int(diameter / 2) * 2 + 1 # odd number of pixels
         center = int(n_pixels / 2)
-        
+
         fwhm = self.lambda_ / (2 * na)
-        
+
         half_pixelsize = datamap_pixelsize / 2
         gauss = numpy.zeros((n_pixels, n_pixels))
         for y in range(n_pixels):
@@ -665,11 +685,11 @@ def get_psf(self, na, datamap_pixelsize):
                                                     ((h_lb, h_ub), (w_lb, w_ub)),
                                                     (fwhm,))[0]
         return numpy.real_if_close(gauss / numpy.max(gauss))
-    
+
     def get_photons(self, intensity):
         e_photon = scipy.constants.c * scipy.constants.h / self.lambda_
-        return intensity // e_photon
-    
+        return numpy.floor(intensity / e_photon)
+
     def get_k_bleach(self, lambda_, photons):
         sigma_abs = self.get_sigma_abs(lambda_)
         phy_react = self.get_phy_react(lambda_)
@@ -677,13 +697,17 @@ def get_k_bleach(self, lambda_, photons):
                 (sigma_abs * photons * (1/self.tau_tri + self.k_isc) +\
                 (self.tau_tri * self.tau))
         return T_1 * photons * self.sigma_tri * phy_react
+        # if lambda_ == 488e-9:
+        #     return photons**2 * phy_react
+        # else:
+        #     return photons**1.5 * phy_react
 
 
 class Microscope:
     '''This class implements a microscopy setup described by an excitation beam,
     a STED (depletion) beam, a detector, some fluorescence molecules, and the
     parameters of the objective.
-    
+
     :param excitation: A :class:`~pysted.base.GaussianBeam` object
                        representing the excitation laser beam.
     :param sted: A :class:`~pysted.base.DonutBeam` object representing the
@@ -702,14 +726,14 @@ class Microscope:
                        important to use load_cache=True only if we know that the previously cached lasers were generated
                        with the same pixel_size as the pixel_size which will be used in the current experiment.
     '''
-    
+
     def __init__(self, excitation, sted, detector, objective, fluo, load_cache=False):
         self.excitation = excitation
         self.sted = sted
         self.detector = detector
         self.objective = objective
         self.fluo = fluo
-                
+
         # caching system
         self.__cache = {}
         if load_cache:
@@ -722,31 +746,31 @@ def __init__(self, excitation, sted, detector, objective, fluo, load_cache=False
         # between the microscope acquisition time steps and the Ca2+ flash time steps
         self.pixel_bank = 0
         self.time_bank = 0
-    
+
     def __str__(self):
         return str(self.__cache.keys())
-    
+
     def is_cached(self, datamap_pixelsize):
         '''Indicate the presence of a cache entry for the given pixel size.
-        
+
         :param datamap_pixelsize: The size of a pixel in the simulated image (m).
         :returns: A boolean.
         '''
 
         datamap_pixelsize_nm = int(datamap_pixelsize * 1e9)
         return datamap_pixelsize_nm in self.__cache
-    
+
     def cache(self, datamap_pixelsize, save_cache=False):
         '''Compute and cache the excitation and STED intensities, and the
         fluorescence PSF. These intensities are computed with a power of 1 W
         such that they can serve as a basis to compute intensities with any
         power.
-        
+
         :param datamap_pixelsize: The size of a pixel in the simulated image (m).
         :param save_cache: A bool which determines whether or not the lasers will be saved to allow for faster load
                            times for future experiments
         :returns: A tuple containing:
-        
+
                   * A 2D array of the excitation intensity for a power of 1 W;
                   * A 2D array of the STED intensity for a a power of 1 W;
                   * A 2D array of the detection PSF.
@@ -755,15 +779,15 @@ def cache(self, datamap_pixelsize, save_cache=False):
         datamap_pixelsize_nm = int(datamap_pixelsize * 1e9)
         if datamap_pixelsize_nm not in self.__cache:
             f, n, na = self.objective.f, self.objective.n, self.objective.na
-            
+
             transmission = self.objective.get_transmission(self.excitation.lambda_)
             i_ex = self.excitation.get_intensity(1, f, n, na,
                                                  transmission, datamap_pixelsize)
-            
+
             transmission = self.objective.get_transmission(self.sted.lambda_)
             i_sted = self.sted.get_intensity(1, f, n, na,
                                              transmission, datamap_pixelsize)
-            
+
             transmission = self.objective.get_transmission(self.fluo.lambda_)
             psf = self.fluo.get_psf(na, datamap_pixelsize)
             # should take data_pixelsize instead of pixelsize, right? same for psf above?
@@ -775,10 +799,10 @@ def cache(self, datamap_pixelsize, save_cache=False):
         if save_cache:
             pickle.dump(self.__cache, open(".microscope_cache.pkl", "wb"))
         return self.__cache[datamap_pixelsize_nm]
-    
+
     def clear_cache(self):
         '''Empty the cache.
-        
+
         .. important::
            It is important to empty the cache if any of the components
            :attr:`excitation`, :attr:`sted`, :attr:`detector`,
@@ -786,31 +810,31 @@ def clear_cache(self):
            or replaced.
         '''
         self.__cache = {}
-    
+
     def get_effective(self, datamap_pixelsize, p_ex, p_sted):
         '''Compute the detected signal given some molecules disposition.
-        
+
         :param datamap_pixelsize: The size of one pixel of the simulated image (m).
         :param p_ex: The power of the depletion beam (W).
         :param p_sted: The power of the STED beam (W).
         :param data_pixelsize: The size of one pixel of the raw data (m).
         :returns: A 2D array of the effective intensity (W) of a single molecule.
-        
+
         The technique follows the method and equations described in
         [Willig2006]_, [Leutenegger2010]_ and [Holler2011]_.
         '''
 
         h, c = scipy.constants.h, scipy.constants.c
         f, n, na = self.objective.f, self.objective.n, self.objective.na
-        
+
         __i_ex, __i_sted, psf_det = self.cache(datamap_pixelsize)
         i_ex = __i_ex * p_ex
         i_sted = __i_sted * p_sted
-        
+
         # saturation intensity (W/m²) [Leutenegger2010] p. 26419
         sigma_ste = self.fluo.get_sigma_ste(self.sted.lambda_)
         i_s = (h * c) / (self.fluo.tau * self.sted.lambda_ * sigma_ste)
-        
+
         # [Leutenegger2010] eq. 3
         zeta = i_sted / i_s
         k_vib = 1 / self.fluo.tau_vib
@@ -820,7 +844,7 @@ def get_effective(self, datamap_pixelsize, p_ex, p_sted):
         # probability of fluorescence given the donut
         eta = (((1 + gamma * numpy.exp(-k_s1 * self.sted.tau * (1 + gamma))) / (1 + gamma)) -
               numpy.exp(-k_s1 * (gamma * self.sted.tau + T))) / (1 - numpy.exp(-k_s1 * T))
-        
+
         # molecular brigthness [Holler2011]
         sigma_abs = self.fluo.get_sigma_abs(self.excitation.lambda_)
         excitation_probability = sigma_abs * i_ex * self.fluo.qy
@@ -830,7 +854,8 @@ def get_effective(self, datamap_pixelsize, p_ex, p_sted):
 
     def get_signal_and_bleach(self, datamap, pixelsize, pdt, p_ex, p_sted, indices=None, acquired_intensity=None,
                               pixel_list=None, bleach=True, update=True, seed=None, filter_bypass=False,
-                              bleach_func=bleach_funcs.default_update_survival_probabilities, steps=None):
+                              bleach_func=bleach_funcs.default_update_survival_probabilities, steps=None,
+                              prob_ex=None, prob_sted=None, bleach_mode="default"):
         """
         This function acquires the signal and bleaches simultaneously. It makes a call to compiled C code for speed,
         so make sure the raster.pyx file is compiled!
@@ -899,15 +924,16 @@ def get_signal_and_bleach(self, datamap, pixelsize, pdt, p_ex, p_sted, indices=N
         rows_pad, cols_pad = datamap.roi_corners['tl'][0], datamap.roi_corners['tl'][1]
         laser_pad = i_ex.shape[0] // 2
 
-
-        prob_ex = numpy.ones(datamap.whole_datamap.shape)
-        prob_sted = numpy.ones(datamap.whole_datamap.shape)
+        if prob_ex is None:
+            prob_ex = numpy.ones(datamap.whole_datamap.shape)
+        if prob_sted is None:
+            prob_sted = numpy.ones(datamap.whole_datamap.shape)
         # bleached_sub_datamaps_dict = copy.copy(datamap.sub_datamaps_dict)
         bleached_sub_datamaps_dict = {}
         if isinstance(indices, type(None)):
             indices = {"flashes": 0}
         for key in datamap.sub_datamaps_dict:
-            bleached_sub_datamaps_dict[key] = numpy.copy(datamap.sub_datamaps_dict[key])
+            bleached_sub_datamaps_dict[key] = numpy.copy(datamap.sub_datamaps_dict[key].astype(int))
 
         if seed is None:
             seed = 0
@@ -928,14 +954,16 @@ def get_signal_and_bleach(self, datamap, pixelsize, pdt, p_ex, p_sted, indices=N
         photons = self.fluo.get_photons(acquired_intensity)
 
         if photons.shape == pdt.shape:
-            returned_acquired_photons = self.detector.get_signal(photons, pdt)
+            returned_acquired_photons = self.detector.get_signal(photons, pdt, seed=seed)
         else:
             pixeldwelltime_reshaped = numpy.zeros((int(numpy.ceil(pdt.shape[0] / ratio)),
                                                    int(numpy.ceil(pdt.shape[1] / ratio))))
             new_pdt_plist = utils.pixel_sampling(pixeldwelltime_reshaped, mode='all')
             for (row, col) in new_pdt_plist:
                 pixeldwelltime_reshaped[row, col] = pdt[row * ratio, col * ratio]
-            returned_acquired_photons = self.detector.get_signal(photons, pixeldwelltime_reshaped)
+            returned_acquired_photons = self.detector.get_signal(photons, pixeldwelltime_reshaped, seed=seed)
+
+        unbleached_whole_datamap = numpy.copy(datamap.whole_datamap)
 
         if update and bleach:
             datamap.sub_datamaps_dict = bleached_sub_datamaps_dict
@@ -943,9 +971,16 @@ def get_signal_and_bleach(self, datamap, pixelsize, pdt, p_ex, p_sted, indices=N
             datamap.whole_datamap = numpy.copy(datamap.base_datamap)
             # BLEACHER LES FLASHS FUTURS
             if datamap.contains_sub_datamaps["flashes"] and indices["flashes"] < datamap.flash_tstack.shape[0]:
-                datamap.bleach_future(indices, bleached_sub_datamaps_dict)
+                if bleach_mode == "default":
+                    datamap.bleach_future(indices, bleached_sub_datamaps_dict)
+                elif bleach_mode == "proportional":
+                    datamap.bleach_future_proportional(indices, bleached_sub_datamaps_dict, unbleached_whole_datamap)
+
+        temporal_acq_elts = {"intensity": acquired_intensity,
+                             "prob_ex": prob_ex,
+                             "prob_sted": prob_sted}
 
-        return returned_acquired_photons, bleached_sub_datamaps_dict, acquired_intensity
+        return returned_acquired_photons, bleached_sub_datamaps_dict, temporal_acq_elts
 
     def get_signal_rescue(self, datamap, pixelsize, pdt, p_ex, p_sted, pixel_list=None, bleach=True, update=True,
                           lower_th=1, ltr=0.1, upper_th=100):
@@ -1257,6 +1292,217 @@ def create_t_stack_dmap(self, acq_time, min_timestep, fwhm_step_sec_correspondan
         self.contains_sub_datamaps["flashes"] = True
         self.sub_datamaps_idx_dict["flashes"] = 0
         self.sub_datamaps_dict["flashes"] = self.flash_tstack[0]
+        self.update_whole_datamap(0)
+
+    def bleach_future(self, indices, bleached_sub_datamaps_dict):
+        """
+        Applies bleaching to the future flash subdatamaps according to the bleaching that occured to the current flash
+        subdatamap
+        :param indices: A dictionary containing the indices of the time steps we are currently at for the subdatamaps.
+                        For now, as there is only the flash subdatamap implemented, the dictionary will simply be
+                        indices = {"flashes": idx}, with idx being an >=0 integer.
+        :param bleached_sub_datamaps_dict: A dictionary containing the bleached subdatamaps (base, flashes)
+        """
+        what_bleached = self.flash_tstack[indices["flashes"]] - bleached_sub_datamaps_dict["flashes"]
+        self.flash_tstack[indices["flashes"]] = bleached_sub_datamaps_dict["flashes"]
+        # UPDATE THE FUTURE
+        with numpy.errstate(divide='ignore', invalid='ignore'):
+            flash_survival = bleached_sub_datamaps_dict["flashes"] / self.flash_tstack[indices["flashes"]]
+        flash_survival[numpy.isnan(flash_survival)] = 1
+        self.flash_tstack[indices["flashes"] + 1:] -= what_bleached
+        self.flash_tstack[indices["flashes"] + 1:] = numpy.multiply(
+            self.flash_tstack[indices["flashes"] + 1:],
+            flash_survival)
+        self.flash_tstack[indices["flashes"] + 1:] = numpy.rint(
+            self.flash_tstack[indices["flashes"] + 1:])
+        self.flash_tstack[indices["flashes"] + 1:] = numpy.where(
+            self.flash_tstack[indices["flashes"] + 1:] < 0,
+            0, self.flash_tstack[indices["flashes"] + 1:])
+        self.whole_datamap += self.flash_tstack[indices["flashes"]]
+
+    def update_whole_datamap(self, flash_idx):
+        """
+        This method will be used to update de whole datamap using the indices of the sub datamaps.
+        Whole datamap is the base datamap + all the sub datamaps (for flashes, diffusion, etc).
+        :param flash_idx: The index of the flash for the most recent acquisition.
+        """
+        self.whole_datamap = self.base_datamap + self.flash_tstack[flash_idx]
+
+    def update_dicts(self, indices):
+        """
+        Method used to update the dicts of the temporal datamap
+        :param indices: A dict containing the indices of the time step for the different temporal sub datamaps (so far
+                        only flashes).
+        """
+        self.sub_datamaps_idx_dict = indices
+        self.sub_datamaps_dict["flashes"] = self.flash_tstack[indices["flashes"]]
+
+
+class TemporalSynapseDmap(Datamap):
+    """
+    Temporal Datamap of a Synaptic region with nanodomains for NeurIPS exps
+    """
+    def __init__(self, whole_datamap, datamap_pixelsize, synapse_obj):
+        super().__init__(whole_datamap, datamap_pixelsize)
+        # faudrait que j'ajoute un attribut qui est l'objet synapse
+        self.synapse = synapse_obj
+        self.contains_sub_datamaps = {"base": True,
+                                      "flashes": False}
+        self.sub_datamaps_idx_dict = {}
+        self.init_molecs_ratio = numpy.ones(self.whole_datamap.shape)
+
+    def __setitem__(self, key, value):
+        if key == "flashes":
+            self.sub_datamaps_idx_dict[key] = value
+            self.sub_datamaps_dict[key] = self.flash_tstack[value]
+        elif key == "base":
+            pass
+
+    def create_t_stack_dmap(self, decay_time_us, delay=2, n_decay_steps=10, n_molecules_multiplier=28, end_pad=0):
+        """
+        Creates the t stack for the evolution of the flash of the nanodmains in the synapse.
+        Very similar implementation to TemporalDatamap's create_t_stack_dmap method
+        Assumes the roi is set
+        """
+        self.decay_time_us = decay_time_us
+        self.time_usec_between_flash_updates = int(numpy.round(self.decay_time_us / n_decay_steps))
+        self.sub_datamaps_dict["base"] = self.base_datamap
+
+        flash_curve = utils.hand_crafted_light_curve(delay=delay, n_decay_steps=n_decay_steps,
+                                                     n_molecules_multiplier=n_molecules_multiplier, end_pad=end_pad)
+
+        self.flash_tstack = numpy.zeros((flash_curve.shape[0], *self.whole_datamap.shape))
+        self.nanodomains_active = []
+        for t, nanodomains_multiplier in enumerate(flash_curve):
+            # -1 makes it so the whole_datamap at flash values of 1 are equal to the base datamap, which I think I want
+            nd_mult = int(numpy.round(nanodomains_multiplier)) - 1
+            if nd_mult < 0:
+                nd_mult = 0
+            for nanodomain in self.synapse.nanodomains:
+                self.flash_tstack[t][self.roi][nanodomain.coords[0], nanodomain.coords[1]] = \
+                    self.synapse.n_molecs_base * nd_mult    # - self.synapse.n_molecs_base
+                # qui a eu l'idée de mettre un - qui me permet d'avoir des vals négatives ici? (c moi :)
+            if self.flash_tstack[t].max() > 0:
+                self.nanodomains_active.append(True)
+            else:
+                self.nanodomains_active.append(False)
+
+        self.nanodomains_active_currently = self.nanodomains_active[0]
+        self.contains_sub_datamaps["flashes"] = True
+        self.sub_datamaps_idx_dict["flashes"] = 0
+        self.sub_datamaps_dict["flashes"] = self.flash_tstack[0]
+        self.update_whole_datamap(0)
+
+    def create_t_stack_dmap_smooth(self, decay_time_us, delay=2, n_decay_steps=10, n_molecules_multiplier=None,
+                                   end_pad=0, individual_flashes=False):
+        """
+        Creates the t stack for the evolution of the flash of the nanodmains in the synapse.
+        Very similar implementation to TemporalDatamap's create_t_stack_dmap method
+        Assumes the roi is set
+        """
+        self.decay_time_us = decay_time_us
+        self.time_usec_between_flash_updates = int(numpy.round(self.decay_time_us / n_decay_steps))
+        self.sub_datamaps_dict["base"] = self.base_datamap
+
+        if type(delay) is tuple:
+            delay = numpy.random.randint(delay[0], delay[1])
+
+        flash_curves = []
+        for i in range(len(self.synapse.nanodomains)):
+            flash_curve = utils.smooth_ramp_hand_crafted_light_curve(
+                delay=delay,
+                n_decay_steps=n_decay_steps,
+                n_molecules_multiplier=n_molecules_multiplier,
+                end_pad=end_pad
+            )
+            flash_curves.append(numpy.copy(flash_curve))
+
+        self.flash_tstack = numpy.zeros((flash_curve.shape[0], *self.whole_datamap.shape))
+        self.nanodomains_active = []
+        for t, nanodomains_multiplier in enumerate(flash_curve):
+            # -1 makes it so the whole_datamap at flash values of 1 are equal to the base datamap, which I think I want
+            # nd_mult = int(numpy.round(nanodomains_multiplier)) - 1
+            # if nd_mult < 0:
+            #     nd_mult = 0
+            for nd_idx, nanodomain in enumerate(self.synapse.nanodomains):
+                if not individual_flashes:
+                    nd_mult = int(numpy.round(nanodomains_multiplier)) - 1
+                    if nd_mult < 0:
+                        nd_mult = 0
+                else:
+                    nd_mult = int(numpy.round(flash_curves[nd_idx][t])) - 1
+                    if nd_mult < 0:
+                        nd_mult = 0
+                self.flash_tstack[t][self.roi][nanodomain.coords[0], nanodomain.coords[1]] = \
+                    self.synapse.n_molecs_base * nd_mult    # - self.synapse.n_molecs_base
+                # qui a eu l'idée de mettre un - qui me permet d'avoir des vals négatives ici? (c moi :)
+            if self.flash_tstack[t].max() > 0:
+                self.nanodomains_active.append(True)
+            else:
+                self.nanodomains_active.append(False)
+
+        self.nanodomains_active_currently = self.nanodomains_active[0]
+        self.contains_sub_datamaps["flashes"] = True
+        self.sub_datamaps_idx_dict["flashes"] = 0
+        self.sub_datamaps_dict["flashes"] = self.flash_tstack[0]
+        self.update_whole_datamap(0)
+
+    def create_t_stack_dmap_sampled(self, decay_time_us, delay=0, n_decay_steps=10, curves_path=None,
+                                    individual_flashes=False):
+        """
+        Creates the t stack for the evolution of the flash of the nanodmains in the synapse.
+        Very similar implementation to TemporalDatamap's create_t_stack_dmap method
+        Assumes the roi is set
+        """
+        # even though in this case the decay_time_us and n_decay_steps wont help generate the light curve, they will
+        # help define de frequency of updates
+        self.decay_time_us = decay_time_us
+        self.time_usec_between_flash_updates = int(numpy.round(self.decay_time_us / n_decay_steps))
+        self.sub_datamaps_dict["base"] = self.base_datamap
+
+        if type(delay) is tuple:
+            delay = numpy.random.randint(delay[0], delay[1])
+
+        if curves_path is None:
+            curves_path = "flash_files/events_curves.npy"
+        flash_curve = utils.sampled_flash_manipulations(curves_path, delay, rescale=True, seed=None)
+
+        if individual_flashes:
+            # faire de quoi pour trouver le peak, sampler des variances pour chaque ND :)
+            flash_peak = numpy.argmax(flash_curve)
+            flash_variances = []
+            for i in range(len(self.synapse.nanodomains)):
+                flash_variances.append(numpy.random.randint(-4, 4))
+        else:
+            flash_peak = 0
+
+        self.flash_tstack = numpy.zeros((flash_curve.shape[0], *self.whole_datamap.shape))
+        self.nanodomains_active = []
+        for t, nanodomains_multiplier in enumerate(flash_curve):
+            # -1 makes it so the whole_datamap at flash values of 1 are equal to the base datamap, which I think I want
+            nd_mult = int(numpy.round(nanodomains_multiplier)) - 1
+            if nd_mult < 0:
+                nd_mult = 0
+            for nd_idx, nanodomain in enumerate(self.synapse.nanodomains):
+                if not individual_flashes or t < flash_peak:
+                    flash_variance = 0
+                else:
+                    flash_variance = flash_variances[nd_idx]
+                    if nd_mult + flash_variance < 0:
+                        flash_variance = 0
+                self.flash_tstack[t][self.roi][nanodomain.coords[0], nanodomain.coords[1]] = \
+                    self.synapse.n_molecs_base * (nd_mult + flash_variance) # - self.synapse.n_molecs_base
+                # qui a eu l'idée de mettre un - qui me permet d'avoir des vals négatives ici? (c moi :)
+            if self.flash_tstack[t].max() > 0:
+                self.nanodomains_active.append(True)
+            else:
+                self.nanodomains_active.append(False)
+
+        self.nanodomains_active_currently = self.nanodomains_active[0]
+        self.contains_sub_datamaps["flashes"] = True
+        self.sub_datamaps_idx_dict["flashes"] = 0
+        self.sub_datamaps_dict["flashes"] = self.flash_tstack[0]
+        self.update_whole_datamap(0)
 
     def bleach_future(self, indices, bleached_sub_datamaps_dict):
         """
@@ -1282,15 +1528,42 @@ def bleach_future(self, indices, bleached_sub_datamaps_dict):
         self.flash_tstack[indices["flashes"] + 1:] = numpy.where(
             self.flash_tstack[indices["flashes"] + 1:] < 0,
             0, self.flash_tstack[indices["flashes"] + 1:])
+        self.flash_tstack = self.flash_tstack.astype('int64')
         self.whole_datamap += self.flash_tstack[indices["flashes"]]
 
+    def bleach_future_proportional(self, indices, bleached_sub_datamaps_dict, unbleached_whole_datamap):
+        """
+        This function will apply bleaching to the future molecules proportional to what has bleached.
+        For instance, if 3/5 molecules are left after bleaching, then the number of molecules in the subsequent
+        flashes will be multiplied by 3/5
+        """
+        # ???
+        bleached_whole_datamap = numpy.zeros(unbleached_whole_datamap.shape)
+        for key in bleached_sub_datamaps_dict:
+            bleached_whole_datamap += bleached_sub_datamaps_dict[key]
+        ratio = bleached_whole_datamap / numpy.where(numpy.logical_and(unbleached_whole_datamap == 0,
+                                                                       bleached_whole_datamap == 0),
+                                                     1, unbleached_whole_datamap)
+        # self.flash_tstack[indices["flashes"]:, :, :] *= ratio
+        # self.flash_tstack = numpy.ceil(self.flash_tstack)
+        # self.flash_tstack = self.flash_tstack.astype('int64')
+        self.flash_tstack[indices["flashes"]:, :, :] = numpy.ceil(self.flash_tstack[indices["flashes"]:, :, :]
+                                                                  * ratio).astype('int64')
+        self.whole_datamap = bleached_sub_datamaps_dict["base"] + self.flash_tstack[indices["flashes"]]
+
+
     def update_whole_datamap(self, flash_idx):
         """
         This method will be used to update de whole datamap using the indices of the sub datamaps.
         Whole datamap is the base datamap + all the sub datamaps (for flashes, diffusion, etc).
         :param flash_idx: The index of the flash for the most recent acquisition.
         """
+        # If the experiment runs longer than the generated flash curve, just keep extending the final value of the curve
+        if flash_idx >= self.flash_tstack.shape[0]:
+            flash_idx = self.flash_tstack.shape[0] - 1
         self.whole_datamap = self.base_datamap + self.flash_tstack[flash_idx]
+        self.nanodomains_active_currently = self.nanodomains_active[flash_idx]   # updates whether or not flashing rn
+
 
     def update_dicts(self, indices):
         """
@@ -1300,3 +1573,288 @@ def update_dicts(self, indices):
         """
         self.sub_datamaps_idx_dict = indices
         self.sub_datamaps_dict["flashes"] = self.flash_tstack[indices["flashes"]]
+
+
+class TestTemporalDmap(Datamap):
+    """
+    This is a test class of a simple temporal Datamap of a cube flashing to verify if the stitching of temporal dmaps
+    works correctly
+    """
+    def __init__(self, whole_datamap, datamap_pixelsize):
+        super().__init__(whole_datamap, datamap_pixelsize)
+        self.contains_sub_datamaps = {"base": True,
+                                      "flashes": False}
+        self.sub_datamaps_idx_dict = {}
+
+    def __setitem__(self, key, value):
+        if key == "flashes":
+            self.sub_datamaps_idx_dict[key] = value
+            self.sub_datamaps_dict[key] = self.flash_tstack[value]
+        elif key == "base":
+            pass
+
+    def create_t_stack_dmap(self, decay_time_us, delay=2, n_decay_steps=10, n_molecules_multiplier=28, end_pad=0):
+        """
+        Creates the t stack for the evolution of the flash of the nanodmains in the synapse.
+        Very similar implementation to TemporalDatamap's create_t_stack_dmap method
+        Assumes the roi is set
+        """
+        self.decay_time_us = decay_time_us
+        self.time_usec_between_flash_updates = int(numpy.round(self.decay_time_us / n_decay_steps))
+        self.sub_datamaps_dict["base"] = self.base_datamap
+
+        flash_curve = utils.hand_crafted_light_curve(delay=delay, n_decay_steps=n_decay_steps,
+                                                     n_molecules_multiplier=n_molecules_multiplier, end_pad=end_pad)
+
+        self.flash_tstack = numpy.zeros((flash_curve.shape[0], *self.whole_datamap.shape))
+        for t, nanodomains_multiplier in enumerate(flash_curve):
+            # -1 makes it so the whole_datamap at flash values of 1 are equal to the base datamap, which I think I want
+            nd_mult = int(numpy.round(nanodomains_multiplier)) - 1
+            if nd_mult < 0:
+                nd_mult = 0
+            self.flash_tstack[t][self.roi] = numpy.max(self.whole_datamap) * nd_mult
+
+        self.contains_sub_datamaps["flashes"] = True
+        self.sub_datamaps_idx_dict["flashes"] = 0
+        self.sub_datamaps_dict["flashes"] = self.flash_tstack[0]
+        self.update_whole_datamap(0)
+
+    def bleach_future(self, indices, bleached_sub_datamaps_dict):
+        """
+        pass for now
+        """
+        what_bleached = self.flash_tstack[indices["flashes"]] - bleached_sub_datamaps_dict["flashes"]
+        self.flash_tstack[indices["flashes"]] = bleached_sub_datamaps_dict["flashes"]
+        # UPDATE THE FUTURE
+        with numpy.errstate(divide='ignore', invalid='ignore'):
+            flash_survival = bleached_sub_datamaps_dict["flashes"] / self.flash_tstack[indices["flashes"]]
+        flash_survival[numpy.isnan(flash_survival)] = 1
+        self.flash_tstack[indices["flashes"] + 1:] -= what_bleached
+        self.flash_tstack[indices["flashes"] + 1:] = numpy.multiply(
+            self.flash_tstack[indices["flashes"] + 1:],
+            flash_survival)
+        self.flash_tstack[indices["flashes"] + 1:] = numpy.rint(
+            self.flash_tstack[indices["flashes"] + 1:])
+        self.flash_tstack[indices["flashes"] + 1:] = numpy.where(
+            self.flash_tstack[indices["flashes"] + 1:] < 0,
+            0, self.flash_tstack[indices["flashes"] + 1:])
+        self.flash_tstack = self.flash_tstack.astype('int64')
+        self.whole_datamap += self.flash_tstack[indices["flashes"]]
+
+    def update_whole_datamap(self, flash_idx):
+        if flash_idx >= self.flash_tstack.shape[0]:
+            flash_idx = self.flash_tstack.shape[0] - 1
+        self.whole_datamap = self.base_datamap + self.flash_tstack[flash_idx]
+
+    def update_dicts(self, indices):
+        self.sub_datamaps_idx_dict = indices
+        self.sub_datamaps_dict["flashes"] = self.flash_tstack[indices["flashes"]]
+
+
+class Clock():
+    """
+    Clock class to keep track of time in experiments involving time
+    :param time_quantum_us: The minimal time increment on which the experiment loop will happen. All other time
+                            increments in the experiment should be a multiple of this value (in micro seconds (us))
+                            (int)
+
+    Note : The time_quantum_us is an int and so is the current_time attribute. This means the longest time an experiment
+           can last is determined by the size of the biggest int, which means it is 9223372036854775807 us, or
+           9223372036854.775807 s, which I think should be ample time :)
+    """
+    def __init__(self, time_quantum_us):
+        if type(time_quantum_us) is not int:
+            raise TypeError(f"The time_quantum_us value should be an int, but a {type(time_quantum_us)} was passed !")
+        self.time_quantum_us = time_quantum_us
+        self.current_time = 0
+
+    def update_time(self):
+        """
+        Updates the current_time by 1 time_quantum_us
+        """
+        self.current_time += self.time_quantum_us
+
+    def reset(self):
+        """
+        Resets the current_time to 0
+        """
+        self.current_time = 0
+
+
+class RandomActionSelector():
+    """
+    Class which selects a random action from :
+    0 - Confocal acquisition
+    1 - STED acquisition
+    2 - Wait (for the time of 1 acquisition)
+
+    *** NOTE ***
+    For now we have are pre setting the pdt, p_ex and p_sted that will be used for the actions.
+    A real agent would select the powers / dwellit me individually
+    ************
+
+    :param pdt: The pixel dwell time that will be used in the acquisitions
+    :param p_ex: The excitation beam power that will be used when the selected action is confocal or sted
+    :param p_sted: The STED beam power that will be used when the selected action is sted
+    """
+
+    def __init__(self, pdt, p_ex, p_sted, roi_shape):
+        self.pdt = numpy.ones(roi_shape) * pdt
+        self.p_ex = p_ex
+        self.p_sted = p_sted
+        self.action_selected = None
+        self.action_completed = False
+        self.valid_actions = {0: "confocal", 1: "sted", 2: "wait"}
+        self.n_actions = 3
+        self.current_action_pdt = None
+        self.current_action_p_ex = None
+        self.current_action_p_sted = None
+
+    def select_action(self):
+        """
+        selects a random action from the current actions
+        """
+        # self.action_selected = self.valid_actions[numpy.random.randint(0, self.n_actions)]
+        # temporary dont want him to select wait for debuggind prupouses
+        self.action_selected = self.valid_actions[numpy.random.randint(0, 1)]
+        if self.action_selected == "confocal":
+            self.current_action_p_ex = self.p_ex
+            self.current_action_p_sted = 0.0
+            self.current_action_pdt = self.pdt
+        elif self.action_selected == "sted":
+            self.current_action_p_ex = self.p_ex
+            self.current_action_p_sted = self.p_sted
+            self.current_action_pdt = self.pdt
+        elif self.action_selected == "wait":
+            self.current_action_p_ex = 0.0
+            self.current_action_p_sted = 0.0
+            self.current_action_pdt = self.pdt
+        else:
+            raise ValueError("Impossible action selected :)")
+        self.action_completed = False
+
+
+class TemporalExperiment():
+    """
+    This temporal experiment will run on a loop based on the action selections instead of on the time to make it easier
+    to integrate the agent/gym stuff :)
+    """
+    def __init__(self, clock, microscope, temporal_datamap, exp_runtime, bleach=True, bleach_mode="default"):
+        self.clock = clock
+        self.microscope = microscope
+        self.temporal_datamap = temporal_datamap
+        self.exp_runtime = exp_runtime
+        self.flash_tstep = 0
+        self.bleach = bleach
+        self.bleach_mode = bleach_mode
+
+    def play_action(self, pdt, p_ex, p_sted):
+        """
+        l'idée va comme ça
+        fait une loop sur X épisodes
+            - quand un épisode commence on crée un objet TemporalExperimentV2p1 avec un certain exp_runtime
+            - l'agent choisit une action et la joue
+                - dans la méthode de jouer l'action (ici) on fait toute la gestion des updates de flash mid acq si c'est
+                  le cas, finir l'action early si on run out de temps, ...
+        *** pdt can be a float value, I will convert it into an array filled with that value if this is the case ***
+        """
+        indices = {"flashes": self.flash_tstep}
+        intensity = numpy.zeros(self.temporal_datamap.whole_datamap[self.temporal_datamap.roi].shape).astype(float)
+        prob_ex = numpy.ones(self.temporal_datamap.whole_datamap.shape).astype(float)
+        prob_sted = numpy.ones(self.temporal_datamap.whole_datamap.shape).astype(float)
+        action_required_time = numpy.sum(pdt) * 1e6   # this assumes a pdt given in sec * 1e-6
+        action_completed_time = self.clock.current_time + action_required_time
+        # +1 ensures no weird business if tha last acq completed as the dmap updated
+        time_steps_covered_by_acq = numpy.arange(int(self.clock.current_time) + 1, action_completed_time)
+        dmap_times = []
+        for i in time_steps_covered_by_acq:
+            if i % self.temporal_datamap.time_usec_between_flash_updates == 0 and i != 0:
+                dmap_times.append(i)
+        dmap_update_times = numpy.arange(self.temporal_datamap.time_usec_between_flash_updates, self.exp_runtime + 1,
+                                         self.temporal_datamap.time_usec_between_flash_updates)
+
+        # if len(dmap_times) == 0, this means the acquisition is not interupted and we can just do it whole
+        # if not, then we need to split the acquisition
+        if len(dmap_times) == 0:
+            acq, bleached, temporal_acq_elts = self.microscope.get_signal_and_bleach(self.temporal_datamap,
+                                                                                     self.temporal_datamap.pixelsize,
+                                                                                     pdt, p_ex, p_sted,
+                                                                                     indices=indices,
+                                                                                     acquired_intensity=intensity,
+                                                                                     bleach=self.bleach, update=True,
+                                                                                     bleach_mode=self.bleach_mode)
+
+            intensity = temporal_acq_elts["intensity"]
+            self.clock.current_time += action_required_time
+            return acq, bleached
+        else:
+            # assume raster pixel scan
+            pixel_list = utils.pixel_sampling(intensity, mode="all")
+            flash_t_step_pixel_idx_dict = {}
+            n_keys = 0
+            first_key = self.flash_tstep
+            for i in range(len(dmap_times) + 1):
+                pdt_cumsum = numpy.cumsum(pdt * 1e6)
+                if i < len(dmap_times) and dmap_times[i] >= self.exp_runtime:
+                    # the datamap would update, but the experiment will be over before then
+                    update_pixel_idx = numpy.argwhere(pdt_cumsum + self.clock.current_time > self.exp_runtime)[0, 0]
+                    flash_t_step_pixel_idx_dict[self.flash_tstep] = update_pixel_idx
+                    if self.flash_tstep > first_key:
+                        flash_t_step_pixel_idx_dict[self.flash_tstep] += flash_t_step_pixel_idx_dict[self.flash_tstep - 1]
+                    self.clock.current_time = self.exp_runtime
+                    break
+                elif i < len(dmap_times):  # mid update split
+                    # update_pixel_idx = numpy.argwhere(pdt_cumsum + self.clock.current_time > dmap_update_times[self.flash_tstep])[0, 0]
+                    # not sure if the + 1 is legit but it seems to fix my bug of acqs being 1 pixel short
+                    update_pixel_idx = \
+                    numpy.argwhere(pdt_cumsum + self.clock.current_time > dmap_update_times[self.flash_tstep])[0, 0] + 1
+                    flash_t_step_pixel_idx_dict[self.flash_tstep] = update_pixel_idx
+                    if self.flash_tstep > first_key:
+                        flash_t_step_pixel_idx_dict[self.flash_tstep] += flash_t_step_pixel_idx_dict[self.flash_tstep - 1]
+                    n_keys += 1
+                    self.flash_tstep += 1
+                    self.clock.current_time += pdt_cumsum[update_pixel_idx - 1]
+                else:  # from last update to the end of acq
+                    update_pixel_idx = pdt_cumsum.shape[0] - 1
+                    flash_t_step_pixel_idx_dict[self.flash_tstep] = update_pixel_idx
+                    self.clock.current_time += pdt_cumsum[update_pixel_idx] - pdt_cumsum[flash_t_step_pixel_idx_dict[self.flash_tstep - 1] - 1]
+            key_counter = 0
+            for key in flash_t_step_pixel_idx_dict:
+                if key_counter == 0:
+                    acq_pixel_list = pixel_list[0:flash_t_step_pixel_idx_dict[key]]
+                    # print(f"len(acq_pixel_list) = {len(acq_pixel_list)}")
+                elif key_counter == n_keys:
+                    acq_pixel_list = pixel_list[
+                                     flash_t_step_pixel_idx_dict[key - 1]:flash_t_step_pixel_idx_dict[key] + 1]
+                    # print(f"len(acq_pixel_list) = {len(acq_pixel_list)}")
+                else:
+                    acq_pixel_list = pixel_list[flash_t_step_pixel_idx_dict[key - 1]:flash_t_step_pixel_idx_dict[key]]
+                if len(acq_pixel_list) == 0:  # acq is over time to go home
+                    # should I still update? PogChampionship I should
+                    key_counter += 1
+                    indices = {"flashes": key}
+                    self.temporal_datamap.update_whole_datamap(key)
+                    self.temporal_datamap.update_dicts(indices)
+                    break
+                    # pass
+                key_counter += 1
+                indices = {"flashes": key}
+                self.temporal_datamap.update_whole_datamap(key)
+                self.temporal_datamap.update_dicts(indices)
+                acq, bleached, temporal_acq_elts = self.microscope.get_signal_and_bleach(self.temporal_datamap,
+                                                                                         self.temporal_datamap.pixelsize,
+                                                                                         pdt, p_ex, p_sted,
+                                                                                         indices=indices,
+                                                                                         acquired_intensity=intensity,
+                                                                                         bleach=self.bleach,
+                                                                                         bleach_mode=self.bleach_mode,
+                                                                                         update=True,
+                                                                                         pixel_list=acq_pixel_list,
+                                                                                         prob_ex=prob_ex,
+                                                                                         prob_sted=prob_sted)
+
+                intensity = temporal_acq_elts["intensity"]
+                prob_ex = temporal_acq_elts["prob_ex"]
+                prob_sted = temporal_acq_elts["prob_sted"]
+
+            return acq, bleached
diff --git a/pysted/bleach_funcs.pyx b/pysted/bleach_funcs.pyx
index 402c80a..aff17c3 100644
--- a/pysted/bleach_funcs.pyx
+++ b/pysted/bleach_funcs.pyx
@@ -100,15 +100,12 @@ def test_update_survival_probabilities(object self,
     cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] photons_ex, photons_sted
     cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] k_ex, k_sted
     cdef int s, sprime, t, tprime
-    cdef FLOATDTYPE_t value
-    cdef int sampled_value
     cdef int prob
     cdef int rsamp
     cdef int current
     cdef str key
     cdef float duty_cycle
 
-    # print("CUMaroonie")
 
     photons_ex = self.fluo.get_photons(i_ex * p_ex)
     k_ex = self.fluo.get_k_bleach(self.excitation.lambda_, photons_ex)
@@ -141,6 +138,81 @@ def test_update_survival_probabilities(object self,
                 tprime += 1
             sprime += 1
 
+@cython.boundscheck(False)  # turn off bounds-checking for entire function
+@cython.wraparound(False)  # turn off negative index wrapping for entire function
+def default_bleach_multisteps(object self,
+                   numpy.ndarray[FLOATDTYPE_t, ndim=2] i_ex,
+                   numpy.ndarray[FLOATDTYPE_t, ndim=2] i_sted,
+                   numpy.ndarray[FLOATDTYPE_t, ndim=1] p_ex,
+                   numpy.ndarray[FLOATDTYPE_t, ndim=1] p_sted,
+                   numpy.ndarray[FLOATDTYPE_t, ndim=1] pdt,
+                   dict bleached_sub_datamaps_dict,
+                   int row,
+                   int col,
+                   int h,
+                   int w,
+                   numpy.ndarray[FLOATDTYPE_t, ndim=2] prob_ex,
+                   numpy.ndarray[FLOATDTYPE_t, ndim=2] prob_sted):
+    cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] photons_ex, photons_sted
+    cdef numpy.ndarray[FLOATDTYPE_t, ndim=3] k_ex, k_sted
+    cdef numpy.ndarray[FLOATDTYPE_t, ndim=1] tmp
+    cdef int s, sprime, t, tprime, i
+    cdef FLOATDTYPE_t value
+    cdef int sampled_value
+    cdef float prob
+    cdef float rsamp
+    cdef float maxval
+    cdef float sampled_prob
+    cdef float expsum
+    cdef int current
+    cdef str key
+    cdef float duty_cycle
+
+    maxval = float(RAND_MAX)
+
+    k_ex = numpy.zeros((len(p_ex), i_ex.shape[0], i_ex.shape[1]), dtype=i_ex.dtype)
+    for i in range(len(p_ex)):
+      photons_ex = self.fluo.get_photons(i_ex * p_ex[i])
+      k_ex[i] = self.fluo.get_k_bleach(self.excitation.lambda_, photons_ex)
+
+    k_sted = numpy.zeros((len(p_sted), i_sted.shape[0], i_sted.shape[1]), dtype=i_sted.dtype)
+    for i in range(len(p_sted)):
+      duty_cycle = self.sted.tau * self.sted.rate
+      photons_sted = self.fluo.get_photons(i_sted * p_sted[i] * duty_cycle)
+      k_sted[i] = self.fluo.get_k_bleach(self.sted.lambda_, photons_sted)
+
+    for key in bleached_sub_datamaps_dict:
+        sprime = 0
+        for s in range(row, row + h):
+            tprime = 0
+            for t in range(col, col + w):
+                # Updates probabilites
+                # I THINK I COMPUTE THIS WETHER THE PIXEL WAS EMPTY OR NOT?
+                expsum = 0.
+                for i in range(len(p_sted)):
+                  expsum = expsum + k_ex[i, sprime, tprime] * pdt[i]
+                prob_ex[s, t] = prob_ex[s, t] * exp(-1. * expsum)
+                expsum = 0.
+                for i in range(len(p_sted)):
+                  expsum = expsum + k_sted[i, sprime, tprime] * pdt[i]
+                prob_sted[s, t] = prob_sted[s, t] * exp(-1. * expsum)
+
+                # only need to compute bleaching (resampling) if the pixel is not empty
+                current = bleached_sub_datamaps_dict[key][s, t]
+                if current > 0:
+                    # Calculates the binomial sampling
+                    sampled_value = 0
+                    prob = prob_ex[s, t] * prob_sted[s, t]
+                    # For each count we sample a random variable
+                    for o in range(current):
+                        rsamp = rand()
+                        sampled_prob = rsamp / maxval
+                        if sampled_prob <= prob:
+                            sampled_value += 1
+                    bleached_sub_datamaps_dict[key][s, t] = sampled_value
+
+                tprime += 1
+            sprime += 1
 
 @cython.boundscheck(False)  # turn off bounds-checking for entire function
 @cython.wraparound(False)  # turn off negative index wrapping for entire function
@@ -160,8 +232,6 @@ def default_update_survival_probabilities(object self,
     cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] photons_ex, photons_sted
     cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] k_ex, k_sted
     cdef int s, sprime, t, tprime
-    cdef FLOATDTYPE_t value
-    cdef int sampled_value
     cdef float prob
     cdef float rsamp
     cdef float maxval
@@ -202,8 +272,7 @@ def sample_molecules(object self,
                    int w,
                    numpy.ndarray[FLOATDTYPE_t, ndim=2] prob_ex,
                    numpy.ndarray[FLOATDTYPE_t, ndim=2] prob_sted):
-    cdef int s, sprime, t, tprime
-    cdef FLOATDTYPE_t value
+    cdef int s, sprime, t, tprime, o
     cdef int sampled_value
     cdef float prob
     cdef float rsamp
diff --git a/pysted/exp_data_gen.py b/pysted/exp_data_gen.py
new file mode 100644
index 0000000..5fea517
--- /dev/null
+++ b/pysted/exp_data_gen.py
@@ -0,0 +1,403 @@
+import numpy as np
+import warnings
+from matplotlib import pyplot as plt
+from skimage import draw
+from skimage import transform as sktr
+from scipy.ndimage.morphology import binary_fill_holes
+from scipy.spatial.distance import cdist
+from pysted import utils
+
+
+def degrees_to_radians(angle_deg):
+    return angle_deg * np.pi / 180
+
+
+def rotate_nds(nd_coords, rot_angle, frame_shape=(64, 64)):
+    """
+    rotates the nanodomain coords
+    :param nd_coords: list or np.array of the nanodomain coords in the unrotated frame
+    :param rot_angle: rotation angle in degrees
+    :param frame_shape: shape of the image in which the NDs reside. Should be (64, 64) in most cases
+    """
+    nd_coords_to_rot = np.asarray(nd_coords) - \
+                       np.array([int(frame_shape[0] / 2) - 0.5, int(frame_shape[1] / 2) - 0.5])   # faut tu jfasse - 0.5
+    angle_rad = degrees_to_radians(rot_angle)
+    rotation_matrix = np.array([[np.cos(angle_rad), -np.sin(angle_rad)],
+                                [np.sin(angle_rad), np.cos(angle_rad)]])
+    rotated_nd_coords = np.asarray(np.rint(nd_coords_to_rot @ rotation_matrix.T), dtype=np.int8) + \
+                        np.array([int(frame_shape[0] / 2) - 0.5, int(frame_shape[1] / 2) - 0.5])
+    rotated_nd_coords = np.rint(rotated_nd_coords).astype(int)
+
+    return rotated_nd_coords
+
+class Synapse():
+    """
+    Synapse class
+    Implemented with the intent of using a datamap_pixelsize of 20nm, to generate synapses with width of 500nm and
+    height of 200nm inside a 64px by 64px datamap (1080nm x 1080nm).
+    The synapse will have nanodomains along its upper edge
+    :param n_molecs: The number of molecules that will be placed in every pixel of the synapse
+    :param datamap_pixelsize_nm: The pixelsize (in nm) of the datamap
+    :param width_nm: Interval for the desired width (in nm) of the synapse. The width will be sampled from this interval
+    :param height_nm: Interval for the desired height (in nm) of the synapse. The height will be sampled from this
+                      interval
+    :param img_shape: The shape of the image (tuple)
+    :param dendrite_thickness: Interval for the desired thickness of the dendrite (in pixels) to which the synapse is
+                               connected. The height will be sampled from this interval. Basically, this just determines
+                               how much of the dendrite we see in the ROI, drawn as a line on the bottom of the image.
+    :param mode: The mode used for the random synapse generation. 'mushroom' will produce a mushroom-like synapse
+                 (i.e., an ellipse connected to the dendrite by a recangular-ish neck). 'bump' will produce a bump-like
+                 synapse (i.e., a have ellipse protruding from the dendrite). 'rand' will randomly select one of these
+                 2 modes.
+    :param seed: Sets the seed for the randomness
+    """
+    def __init__(self, n_molecs, datamap_pixelsize_nm=20, width_nm=(400, 800), height_nm=(300, 600),
+                 img_shape=(64, 64), dendrite_thickness=(1, 10), mode='rand', seed=None):
+        np.random.seed(seed)
+        self.img_shape = img_shape
+        self.datamap_pixelsize_nm = datamap_pixelsize_nm
+        self.n_molecs_base = n_molecs
+        self.flash_tstep = 0
+        self.nanodomains = []
+        self.nanodomains_coords = []
+
+        modes = {0: 'mushroom', 1: 'bump', 2: 'rand'}
+        if mode not in modes.values():
+            raise ValueError(f"mode {mode} is not valid, valid modes are {modes.values}")
+        if mode == 'rand':
+            mode_key = np.random.randint(0, 2)
+            mode = modes[mode_key]
+
+        width_nm = np.random.randint(width_nm[0], width_nm[1])
+        height_nm = np.random.randint(height_nm[0], height_nm[1])
+        width_px = int(np.round(width_nm / self.datamap_pixelsize_nm))
+        height_px = int(np.round(height_nm / self.datamap_pixelsize_nm))
+
+        if mode == 'mushroom':
+            center = (int(self.img_shape[0] / 2), int(self.img_shape[1] / 2))
+
+            # ellipse_rows, ellipse_cols = draw.ellipse(center[0], center[1], int(height_px / 2), int(width_px / 2))
+            # ellipse_pixels = np.stack((ellipse_rows, ellipse_cols), axis=-1)
+
+            ellipse_r_perimeter, ellipse_c_perimeter = draw.ellipse_perimeter(center[0], center[1],
+                                                                              int(height_px / 2), int(width_px / 2))
+            # keep the perimeter of the ellipse as an attribute for latter addition of the nanodomains
+            self.ellipse_perimeter = np.stack((ellipse_r_perimeter, ellipse_c_perimeter), axis=-1)
+
+            # add a trapezoid shaped neck that joins the synapse to the bottom
+            lowest_row = np.max(self.ellipse_perimeter[:, 0])
+            lowest_row_pixels = np.squeeze(self.ellipse_perimeter[np.argwhere(self.ellipse_perimeter[:, 0] == lowest_row)])
+            left_lowest_px = np.min(lowest_row_pixels[:, 1])
+            right_lowest_px = np.max(lowest_row_pixels[:, 1])
+            poly_width = np.random.randint(0, 3)
+            polygon_corners_rows = [lowest_row, lowest_row, self.img_shape[0] - 1, self.img_shape[0] - 1]
+            polygon_corners_cols = [left_lowest_px, right_lowest_px,
+                                    right_lowest_px + poly_width,
+                                    left_lowest_px - poly_width]
+            polygon_rows, polygon_cols = draw.polygon(polygon_corners_rows, polygon_corners_cols)
+            polygon_pixels = np.stack((polygon_rows, polygon_cols), axis=-1)
+
+            img = np.zeros(self.img_shape)
+            # fill the bottom of the image as if it was the dendrite
+            sampled_thickness = np.random.randint(dendrite_thickness[0], dendrite_thickness[1])
+            self.unrotated_dendrite_top = self.img_shape[0] - sampled_thickness
+            img[self.img_shape[0] - sampled_thickness: self.img_shape[0]] = 1
+            img[self.ellipse_perimeter[:, 0], self.ellipse_perimeter[:, 1]] = 1
+            img = binary_fill_holes(img)
+            img[polygon_pixels[:, 0], polygon_pixels[:, 1]] = 1
+
+        elif mode == 'bump':
+            sampled_thickness = np.random.randint(dendrite_thickness[0], dendrite_thickness[1])
+            self.unrotated_dendrite_top = self.img_shape[0] - sampled_thickness
+            center = (self.img_shape[0] - sampled_thickness, int(self.img_shape[1] / 2))
+
+            ellipse_rows, ellipse_cols = draw.ellipse(center[0], center[1], int(height_px / 2), int(width_px / 2))
+            ellipse_pixels = np.stack((ellipse_rows, ellipse_cols), axis=-1)
+
+            ellipse_r_perimeter, ellipse_c_perimeter = draw.ellipse_perimeter(center[0], center[1],
+                                                                              int(height_px / 2), int(width_px / 2))
+            # keep the perimeter of the ellipse as an attribute for latter addition of the nanodomains
+            self.ellipse_perimeter = np.stack((ellipse_r_perimeter, ellipse_c_perimeter), axis=-1)
+            # remove pixels on the bottom of the ellipse that are outside the ROI
+            row_too_low_all = np.argwhere(ellipse_pixels[:, 0] >= self.img_shape[0])
+            ellipse_pixels = np.delete(ellipse_pixels, row_too_low_all, axis=0)
+            row_too_low_perimeter = np.argwhere(self.ellipse_perimeter[:, 0] >= self.img_shape[0])
+            self.ellipse_perimeter = np.delete(self.ellipse_perimeter, row_too_low_perimeter, axis=0)
+
+            img = np.zeros(self.img_shape)
+            img[self.img_shape[0] - sampled_thickness: self.img_shape[0]] = 1
+            # img[ellipse_pixels[:, 0], ellipse_pixels[:, 1]] = n_molecs
+            img[self.ellipse_perimeter[:, 0], self.ellipse_perimeter[:, 1]] = 1
+            img = binary_fill_holes(img)
+
+        self.frame = np.where(img, n_molecs, 0)
+
+    def filter_valid_nanodomain_pos(self, thickness=0):
+        """
+        Returns a list of the valid nanodomain positions. The valid positions are on the upper half of the perimeter
+        of the synapse
+        :param thickness: The thickness of the valid region for the nanodomains. This value is 0 by default, meaning the
+                          nanodomains will only be placed on the upper perimeter of the synapse
+        :return: list of the valid positions for the nanodomains.
+        """
+        ellipsis_min_row = np.min(self.ellipse_perimeter[:, 0])
+        ellipsis_max_row = np.max(self.ellipse_perimeter[:, 0])
+        ellipsis_height = ellipsis_max_row - ellipsis_min_row
+
+        lower_half_perimeter = np.argwhere(self.ellipse_perimeter[:, 0] >= ellipsis_min_row + int(ellipsis_height / 2))
+        pixels_in_top_half_perimeter = np.delete(self.ellipse_perimeter, lower_half_perimeter, axis=0)
+
+        synapse_pixels = np.argwhere(self.frame > 0)
+        distances = cdist(synapse_pixels, pixels_in_top_half_perimeter)
+        valid_pixels_idx = np.argwhere(distances <= thickness)[:, 0]
+        valid_pixels = synapse_pixels[valid_pixels_idx]
+        self.valid_nanodomains_pos = valid_pixels
+
+        return valid_pixels
+
+
+    def add_nanodomains(self, n_nanodmains, min_dist_nm=200, n_molecs_in_domain=5, seed=None, valid_thickness=0):
+        """
+        Adds nanodomains on the periphery of the synapse.
+        :param n_nanodmains: The number of nanodomains that will be attempted to be added. If n_nanodomains is too
+                             high and the min_dist_nm is too high, it may not be able to place all the nanodomains,
+                             in which case a warning will be raised to tell the user not all nanodomains have been
+                             placed
+        :param min_dist_nm: The minimum distance (in nm) separating the nanodomains.
+        :param n_molecs_in_domain: The number of molecules to be added at the nanodomain positions
+        :param seed: Sets the seed for the random placement of nanodomains
+        :param valid_thickness: The thickness of the valid region for the nanodomains. This value is 0 by default,
+                                meaning the nanodomains will only be placed on the upper perimeter of the synapse
+        """
+        if type(n_nanodmains) is tuple:
+            n_nanodmains = np.random.randint(n_nanodmains[0], n_nanodmains[1])
+        if type(min_dist_nm) is tuple:
+            min_dist_nm = np.random.randint(min_dist_nm[0], min_dist_nm[1])
+        if type(valid_thickness) is tuple:
+            valid_thickness = np.random.randint(valid_thickness[0], valid_thickness[1])
+        if type(n_molecs_in_domain) is tuple:
+            n_molecs_in_domain_list = [np.random.randint(n_molecs_in_domain[0], n_molecs_in_domain[1])
+                                       for i in range(n_nanodmains)]
+
+        np.random.seed(seed)
+        self.nanodomains = []
+        self.nanodomains_coords = []
+        n_nanodmains_placed = 0
+        self.filter_valid_nanodomain_pos(thickness=valid_thickness)
+
+        for i in range(n_nanodmains):
+            if self.valid_nanodomains_pos.shape[0] == 0:
+                # no more valid positions, simply stop
+                warnings.warn(f"Attempted to place {n_nanodmains} nanodomains, but only {n_nanodmains_placed} could"
+                              f"be placed due to the minimum distance of {min_dist_nm} separating them")
+                break
+            self.nanodomains.append(Nanodomain(self.img_shape, self.valid_nanodomains_pos))
+            self.nanodomains_coords.append(self.nanodomains[i].coords)
+            n_nanodmains_placed += 1
+            distances = cdist(np.array(self.nanodomains_coords), self.valid_nanodomains_pos)
+            distances *= self.datamap_pixelsize_nm
+            invalid_positions_idx = np.argwhere(distances < min_dist_nm)[:, 1]
+            self.valid_nanodomains_pos = np.delete(self.valid_nanodomains_pos, invalid_positions_idx, axis=0)
+
+        counter = 0
+        for row, col in self.nanodomains_coords:
+            if type(n_molecs_in_domain) is tuple:
+                self.frame[row, col] += n_molecs_in_domain_list[counter]
+            else:
+                self.frame[row, col] += n_molecs_in_domain
+            counter += 1
+        self.n_molecs_in_domains = n_molecs_in_domain
+
+    def fatten_nanodomains(self):
+        """
+        Fattens the nanodomains by 1 pixel on each side (if the side is within the synapse)
+        """
+        nanodomains_px = np.argwhere(self.frame == self.n_molecs_base + self.n_molecs_in_domains)
+        for i in range(nanodomains_px.shape[0]):
+            # look on all sides of the pixel, if it is within the synapse and not already part of a nanodomain,
+            # add molecules to make it part of the nanodomain
+            row, col = nanodomains_px[i, :]
+            if (self.frame[row - 1, col] == self.n_molecs_base):   # look on top
+                self.frame[row - 1, col] += self.n_molecs_in_domains
+            if (self.frame[row + 1, col] == self.n_molecs_base):   # look on bot
+                self.frame[row + 1, col] += self.n_molecs_in_domains
+            if (self.frame[row, col - 1] == self.n_molecs_base):   # look right
+                self.frame[row, col - 1] += self.n_molecs_in_domains
+            if (self.frame[row, col + 1] == self.n_molecs_base):   # look left
+                self.frame[row, col + 1] += self.n_molecs_in_domains
+
+    def flash_nanodomains(self, current_time, time_quantum_us, delay=0, fwhm_step_usec_correspondance=(10, 1500000)):
+        """
+        Verifies if the nanodomains need to be updated for the flash, updates them if it is the case
+
+        l'idée du delay est que je ne veux pas nécessairement commencer la routine de flash au début de l'exp, je ne
+        suis pas certain de comment je veux l'implem encore :)
+
+        *** ??? I DON'T THINK THIS IS HOW I WANT TO HANDLE IT ??? ***
+
+        :param current_time: The current_time of the clock
+        """
+        n_time_quantums_us_per_flash_step = utils.time_quantum_to_flash_tstep_correspondance(
+            fwhm_step_usec_correspondance,
+            time_quantum_us)
+        if (current_time % n_time_quantums_us_per_flash_step == 0):
+            self.flash_tstep += 1
+            for nanodomain in self.nanodomains:
+                if self.flash_tstep >= nanodomain.flash_curve.shape[0]:
+                    # if the flash is done, return the nanodomains to their initial value
+                    self.flash_tstep = nanodomain.flash_curve.shape[0]
+                self.frame[nanodomain.coords[0], nanodomain.coords[1]] = int(nanodomain.flash_curve[self.flash_tstep] *
+                                                                             self.n_molecs_in_domains)
+            self.frame = self.frame.astype(int)
+            plt.imshow(self.frame)
+            plt.title(f"flash_tstep = {self.flash_tstep} \n"
+                      f"current_time = {current_time} \n"
+                      f"flash value = {np.max(self.frame)}")
+            plt.show()
+
+    def rotate_and_translate(self, rot_angle=None, translate=True):
+        # pad the frame to allow us to lengthen the dendrite and translate and stuff :)
+        pad_width = 100
+        padded_frame = np.pad(self.frame, pad_width)
+
+        # stretch the dendrite
+        padded_frame[pad_width + self.unrotated_dendrite_top: pad_width + self.frame.shape[0]] = self.n_molecs_base
+
+        # rotate around the center, keep the center crop of img shape (64, 64), the rotate the nds
+        if rot_angle is None:
+            rot_angle = np.random.randint(0, 360)
+        rot8_padded = sktr.rotate(padded_frame, rot_angle, resize=False, order=1, preserve_range=True)
+
+        rot8_roi = rot8_padded[pad_width: pad_width + self.frame.shape[0],
+                               pad_width: pad_width + self.frame.shape[1]]
+
+        # set the translation limits to make sure no ND is outside the roi set by the frame
+        if len(self.nanodomains) != 0:
+            rotated_nd_coords = rotate_nds(self.nanodomains_coords, rot_angle, frame_shape=self.frame.shape)
+        else:
+            rotated_nd_coords = np.asarray(self.nanodomains_coords)
+        dist_to_far_edge = np.min((np.min(self.frame.shape) - 1) * np.ones(rotated_nd_coords.shape) - rotated_nd_coords)
+        dist_to_close_edge = np.min(rotated_nd_coords)
+        translate_lim = np.min([dist_to_close_edge, dist_to_far_edge])
+
+        if translate and (translate_lim > 0):
+            translate_rows = np.random.randint(-translate_lim, translate_lim)
+            translate_cols = np.random.randint(-translate_lim, translate_lim)
+            rot8_roi = rot8_padded[pad_width + translate_rows: pad_width + translate_rows + self.frame.shape[0],
+                                   pad_width + translate_cols: pad_width + translate_cols + self.frame.shape[1]]
+        else:
+            translate_rows, translate_cols = 0, 0
+            rot8_roi = rot8_padded[pad_width: pad_width + self.frame.shape[0],
+                                   pad_width: pad_width + self.frame.shape[1]]
+
+        if len(self.nanodomains) != 0:
+            rotated_nd_coords[:, 0] -= translate_rows
+            rotated_nd_coords[:, 1] -= translate_cols
+        self.nanodomains_coords = rotated_nd_coords
+        for idx, nd in enumerate(self.nanodomains):
+            nd.coords = self.nanodomains_coords[idx]
+        self.frame = np.rint(rot8_roi).astype(int)
+
+
+
+
+class Nanodomain():
+    """
+    Nanodomain class
+    For now I don't think this will do much other than say where the nanodomains are situated. For later exps, we will
+    add flash routines and such to this class :)
+    :param img_shape: The shape of the image in which the nanodomains will be placed
+    :param valid_positions: A list of the valid positions from which to randomly sample a nanodomain position.
+    """
+    def __init__(self, img_shape, valid_positions=None):
+        """
+        Spawns a Nanodomain
+        :param valid_positions: List of valid pixels for the nanodomain to spawn in. If none, randomly spawn in the img
+        """
+        if valid_positions is not None:
+            valid_positions = np.array(valid_positions)
+            self.coords = np.array(valid_positions[np.random.randint(0, valid_positions.shape[0])])
+        else:
+            self.coords = np.array([np.random.randint(0, img_shape[0]), np.random.randint(0, img_shape[1])])
+
+    def add_flash_curve(self, events_curves_path, seed=None):
+        """
+        Adds a list of molecule values for a certain number of frames
+        """
+        sampled_light_curve = utils.flash_generator(events_curves_path, seed=seed)
+        normalized_light_curve = utils.rescale_data(sampled_light_curve, to_int=False, divider=2)
+        # smoothed_light_curve = utils.savitzky_golay(normalized_light_curve, 11, 5)
+        # plt.plot(normalized_light_curve, label="unsmoothed")
+        # plt.plot(smoothed_light_curve, label="smoothed")
+        # plt.legend()
+        # plt.show()
+        # exit()
+
+        self.flash_curve = np.append(normalized_light_curve, [0])
+
+
+if __name__ == "__main__":
+    from pysted import base
+
+    # generate a synapse with nanodomains
+    # create molecules disposition
+    n_molecs_base = 5
+    min_dist = 100
+    n_molecs_in_domain = 100
+    n_nanodomains = 7
+    valid_thickness = 3
+    shroom = Synapse(n_molecs_base, mode="mushroom", seed=42)
+    shroom.add_nanodomains(n_nanodomains, min_dist, seed=42, n_molecs_in_domain=n_molecs_in_domain, valid_thickness=3)
+
+    # microscope stuff
+    egfp = {
+                "lambda_": 535e-9,
+                "qy": 0.6,
+                "sigma_abs": {488: 1.15e-20,
+                              575: 6e-21},
+                "sigma_ste": {560: 1.2e-20,
+                              575: 6.0e-21,
+                              580: 5.0e-21},
+                "sigma_tri": 1e-21,
+                "tau": 3e-09,
+                "tau_vib": 1.0e-12,
+                "tau_tri": 5e-6,
+                "phy_react": {488: 0.25e-7,   # 1e-4
+                              575: 25.0e-11},   # 1e-8
+                "k_isc": 0.26e+6
+            }
+    pixelsize = 20e-9
+    bleach = False
+    p_ex = 5.0e-6
+    p_sted = 5.0e-3
+    pdt = 100.0e-6
+
+    laser_ex = base.GaussianBeam(488e-9)
+    laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+    detector = base.Detector(noise=True, background=0)
+    objective = base.Objective()
+    fluo = base.Fluorescence(**egfp)
+    microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)
+    i_ex, _, _ = microscope.cache(pixelsize, save_cache=True)
+
+    datamap = base.Datamap(shroom.frame, pixelsize)
+    datamap.set_roi(i_ex, "max")
+
+    # confocal acquisition
+    confocal_acq, _, _ = microscope.get_signal_and_bleach(datamap, datamap.pixelsize, pdt, p_ex, 0.0,
+                                                          bleach=False, update=False)
+
+    # STED acquisition
+    sted_acq, _, _ = microscope.get_signal_and_bleach(datamap, datamap.pixelsize, pdt, p_ex, p_sted,
+                                                      bleach=False, update=False)
+
+    fig, axes = plt.subplots(1, 3)
+
+    axes[0].imshow(datamap.whole_datamap[datamap.roi])
+    axes[0].set_title(f"Datamap")
+    axes[1].imshow(confocal_acq)
+    axes[1].set_title(f"Confocal")
+    axes[2].imshow(sted_acq)
+    axes[2].set_title(f"STED")
+
+    plt.show()
diff --git a/pysted/microscopes.py b/pysted/microscopes.py
new file mode 100644
index 0000000..a107895
--- /dev/null
+++ b/pysted/microscopes.py
@@ -0,0 +1,319 @@
+
+import numpy
+import time
+import random
+
+from pysted import base, utils, raster, bleach_funcs
+
+class DyMINMicroscope(base.Microscope):
+    def __init__(self, excitation, sted, detector, objective, fluo, load_cache=False, opts=None):
+        super(DyMINMicroscope, self).__init__(excitation, sted, detector, objective, fluo, load_cache=load_cache)
+
+        if isinstance(opts, type(None)):
+            opts = {
+                "scale_power" : [0., 0.25, 1.],
+                "decision_time" : [10.0e-6, 10.0e-6, -1],
+                "threshold_count" : [8, 8, 0]
+            }
+        required_keys = ["scale_power", "decision_time", "threshold_count"]
+        assert all(k in opts for k in required_keys), "Missing keys in opts. {}".format(required_keys)
+        self.opts = opts
+
+    def get_signal_and_bleach(self, datamap, pixelsize, pdt, p_ex, p_sted, indices=None, acquired_intensity=None,
+                                  pixel_list=None, bleach=True, update=True, seed=None, filter_bypass=False,
+                                  bleach_func=bleach_funcs.default_update_survival_probabilities,
+                                  sample_func=bleach_funcs.sample_molecules):
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pdt = utils.float_to_array_verifier(pdt, datamap_roi.shape)
+        p_ex = utils.float_to_array_verifier(p_ex, datamap_roi.shape)
+        p_sted = utils.float_to_array_verifier(p_sted, datamap_roi.shape)
+
+        datamap_pixelsize = datamap.pixelsize
+        i_ex, i_sted, psf_det = self.cache(datamap_pixelsize)
+        if datamap.roi is None:
+            datamap.set_roi(i_ex)
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pixel_list = utils.pixel_list_filter(datamap_roi, pixel_list, pixelsize, datamap_pixelsize)
+
+        ratio = utils.pxsize_ratio(pixelsize, datamap_pixelsize)
+        rows_pad, cols_pad = datamap.roi_corners['tl'][0], datamap.roi_corners['tl'][1]
+        laser_pad = i_ex.shape[0] // 2
+
+        prob_ex = numpy.ones(datamap.whole_datamap.shape)
+        prob_sted = numpy.ones(datamap.whole_datamap.shape)
+        bleached_datamap = numpy.copy(datamap.whole_datamap)
+        returned_photons = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+        scaled_power = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+
+        bleached_sub_datamaps_dict = {}
+        if isinstance(indices, type(None)):
+            indices = 0   # VÉRIF À QUOI INDICES SERT?
+        for key in datamap.sub_datamaps_dict:
+            bleached_sub_datamaps_dict[key] = numpy.copy(datamap.sub_datamaps_dict[key])
+
+        for (row, col) in pixel_list:
+            row_slice = slice(row + rows_pad - laser_pad, row + rows_pad + laser_pad + 1)
+            col_slice = slice(col + cols_pad - laser_pad, col + cols_pad + laser_pad + 1)
+
+            pdts, p_exs, p_steds = numpy.zeros(len(self.opts["scale_power"])), numpy.zeros(len(self.opts["scale_power"])), numpy.zeros(len(self.opts["scale_power"]))
+            for i, (scale_power, decision_time, threshold_count) in enumerate(zip(self.opts["scale_power"], self.opts["decision_time"], self.opts["threshold_count"])):
+                if decision_time < 0.:
+                    decision_time = pdt[row, col]
+
+                effective = self.get_effective(datamap_pixelsize, p_ex[row, col], scale_power * p_sted[row, col])
+                h, w = effective.shape
+
+                # Uses the bleached datamap
+                bleached_datamap = numpy.zeros(bleached_sub_datamaps_dict["base"].shape, dtype=numpy.int32)
+                for key in bleached_sub_datamaps_dict:
+                    bleached_datamap += bleached_sub_datamaps_dict[key]
+
+                pixel_intensity = numpy.sum(effective * bleached_datamap[row_slice, col_slice])
+                pixel_photons = self.detector.get_signal(self.fluo.get_photons(pixel_intensity), decision_time)
+
+                # Stores the action taken for futures bleaching
+                pdts[i] = decision_time
+                p_exs[i] = p_ex[row, col]
+                p_steds[i] = scale_power * p_sted[row, col]
+
+                # If signal is less than threshold count then skip pixel
+                scaled_power[row, col] = scale_power
+                if pixel_photons < threshold_count:
+                    break
+
+                # Update the photon counts only on the last pixel power scale
+                if scale_power > 0.:
+                    returned_photons[row, col] += pixel_photons
+
+            if bleach:
+                for _p_ex, _p_sted, _pdt in zip(p_exs, p_steds, pdts):
+                    bleach_func(self, i_ex, i_sted, _p_ex, _p_sted,
+                                _pdt, bleached_sub_datamaps_dict,
+                                row, col, h, w, prob_ex, prob_sted)
+                sample_func(self, bleached_sub_datamaps_dict, row, col, h, w, prob_ex, prob_sted)
+
+        if update and bleach:
+            datamap.sub_datamaps_dict = bleached_sub_datamaps_dict
+            datamap.base_datamap = datamap.sub_datamaps_dict["base"]
+            datamap.whole_datamap = numpy.copy(datamap.base_datamap)
+
+        return returned_photons, bleached_sub_datamaps_dict, scaled_power
+
+class DyMINRESCueMicroscope(base.Microscope):
+    def __init__(self, excitation, sted, detector, objective, fluo, load_cache=False, opts=None):
+        super(DyMINRESCueMicroscope, self).__init__(excitation, sted, detector, objective, fluo, load_cache=load_cache)
+
+        if isinstance(opts, type(None)):
+            opts = {
+                "scale_power" : [0., 0.1, 1.],
+                "decision_time" : [10.0e-6, 10.0e-6, 10.0e-6],
+                "threshold_count" : [8, 8, 3]
+            }
+        required_keys = ["scale_power", "decision_time", "threshold_count"]
+        assert all(k in opts for k in required_keys), "Missing keys in opts. {}".format(required_keys)
+        self.opts = opts
+
+    def get_signal_and_bleach(self, datamap, pixelsize, pdt, p_ex, p_sted, indices=None, acquired_intensity=None,
+                                  pixel_list=None, bleach=True, update=True, seed=None, filter_bypass=False,
+                                  bleach_func=bleach_funcs.default_update_survival_probabilities,
+                                  sample_func=bleach_funcs.sample_molecules):
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pdt = utils.float_to_array_verifier(pdt, datamap_roi.shape)
+        p_ex = utils.float_to_array_verifier(p_ex, datamap_roi.shape)
+        p_sted = utils.float_to_array_verifier(p_sted, datamap_roi.shape)
+
+        datamap_pixelsize = datamap.pixelsize
+        i_ex, i_sted, psf_det = self.cache(datamap_pixelsize)
+        if datamap.roi is None:
+            datamap.set_roi(i_ex)
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pixel_list = utils.pixel_list_filter(datamap_roi, pixel_list, pixelsize, datamap_pixelsize)
+
+        ratio = utils.pxsize_ratio(pixelsize, datamap_pixelsize)
+        rows_pad, cols_pad = datamap.roi_corners['tl'][0], datamap.roi_corners['tl'][1]
+        laser_pad = i_ex.shape[0] // 2
+
+        prob_ex = numpy.ones(datamap.whole_datamap.shape)
+        prob_sted = numpy.ones(datamap.whole_datamap.shape)
+        bleached_datamap = numpy.copy(datamap.whole_datamap)
+        returned_photons = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+        scaled_power = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+
+        bleached_sub_datamaps_dict = {}
+        if isinstance(indices, type(None)):
+            indices = 0   # VÉRIF À QUOI INDICES SERT?
+        for key in datamap.sub_datamaps_dict:
+            bleached_sub_datamaps_dict[key] = numpy.copy(datamap.sub_datamaps_dict[key])
+
+        for (row, col) in pixel_list:
+            row_slice = slice(row + rows_pad - laser_pad, row + rows_pad + laser_pad + 1)
+            col_slice = slice(col + cols_pad - laser_pad, col + cols_pad + laser_pad + 1)
+
+            pdts, p_exs, p_steds = numpy.zeros(len(self.opts["scale_power"])), numpy.zeros(len(self.opts["scale_power"])), numpy.zeros(len(self.opts["scale_power"]))
+            for i, (scale_power, decision_time, threshold_count) in enumerate(zip(self.opts["scale_power"], self.opts["decision_time"], self.opts["threshold_count"])):
+
+                effective = self.get_effective(datamap_pixelsize, p_ex[row, col], scale_power * p_sted[row, col])
+                h, w = effective.shape
+
+                # Uses the bleached datamap
+                bleached_datamap = numpy.zeros(bleached_sub_datamaps_dict["base"].shape, dtype=numpy.int32)
+                for key in bleached_sub_datamaps_dict:
+                    bleached_datamap += bleached_sub_datamaps_dict[key]
+
+                pixel_intensity = numpy.sum(effective * bleached_datamap[row_slice, col_slice])
+                pixel_photons = self.detector.get_signal(self.fluo.get_photons(pixel_intensity), decision_time)
+
+                # Stores the action taken for futures bleaching
+                pdts[i] = decision_time
+                p_exs[i] = p_ex[row, col]
+                p_steds[i] = scale_power * p_sted[row, col]
+                if i == len(self.opts["scale_power"]) - 1:
+                    if (threshold_count > 0) and (pixel_photons > threshold_count):
+                        scaled_power[row, col] = 4
+                        returned_photons[row, col] += (pixel_photons * pdt[row, col] / decision_time).astype(int)
+                        break
+                    else:
+                        scaled_power[row, col] = 3
+                        returned_photons[row, col] += pixel_photons
+
+                        # Acquire another time as in RESCue
+                        pdts[i] += pdt[row, col]
+                        pixel_photons = self.detector.get_signal(self.fluo.get_photons(pixel_intensity), pdt[row, col])
+                        returned_photons[row, col] += pixel_photons
+                else:
+                    # If signal is less than threshold count then skip pixel
+                    scaled_power[row, col] = scale_power
+                    if pixel_photons < threshold_count:
+                        break
+
+                    # # Update the photon counts only on the last pixel power scale
+                    # if scale_power > 0.:
+                    #     returned_photons[row, col] += pixel_photons
+
+            if bleach:
+                for _p_ex, _p_sted, _pdt in zip(p_exs, p_steds, pdts):
+                    bleach_func(self, i_ex, i_sted, _p_ex, _p_sted,
+                                _pdt, bleached_sub_datamaps_dict,
+                                row, col, h, w, prob_ex, prob_sted)
+                sample_func(self, bleached_sub_datamaps_dict, row, col, h, w, prob_ex, prob_sted)
+
+        if update and bleach:
+            datamap.sub_datamaps_dict = bleached_sub_datamaps_dict
+            datamap.base_datamap = datamap.sub_datamaps_dict["base"]
+            datamap.whole_datamap = numpy.copy(datamap.base_datamap)
+
+        return returned_photons, bleached_sub_datamaps_dict, scaled_power
+
+class RESCueMicroscope(base.Microscope):
+    def __init__(self, excitation, sted, detector, objective, fluo, load_cache=False, opts=None):
+        super(RESCueMicroscope, self).__init__(excitation, sted, detector, objective, fluo, load_cache=load_cache)
+
+        if isinstance(opts, type(None)):
+            opts = {
+                "lower_threshold" : [2, -1.],
+                "upper_threshold" : [4, -1.],
+                "decision_time" : [10.0e-6, -1.]
+            }
+        required_keys = ["lower_threshold", "upper_threshold", "decision_time"]
+        assert all(k in opts for k in required_keys), "Missing keys in opts. {}".format(required_keys)
+        self.opts = opts
+
+    def get_signal_and_bleach(self, datamap, pixelsize, pdt, p_ex, p_sted, indices=None, acquired_intensity=None,
+                                  pixel_list=None, bleach=True, update=True, seed=None, filter_bypass=False,
+                                  bleach_func=bleach_funcs.default_update_survival_probabilities,
+                                  sample_func=bleach_funcs.sample_molecules):
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pdt = utils.float_to_array_verifier(pdt, datamap_roi.shape)
+        p_ex = utils.float_to_array_verifier(p_ex, datamap_roi.shape)
+        p_sted = utils.float_to_array_verifier(p_sted, datamap_roi.shape)
+
+        datamap_pixelsize = datamap.pixelsize
+        i_ex, i_sted, psf_det = self.cache(datamap_pixelsize)
+        if datamap.roi is None:
+            datamap.set_roi(i_ex)
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pixel_list = utils.pixel_list_filter(datamap_roi, pixel_list, pixelsize, datamap_pixelsize)
+
+        ratio = utils.pxsize_ratio(pixelsize, datamap_pixelsize)
+        rows_pad, cols_pad = datamap.roi_corners['tl'][0], datamap.roi_corners['tl'][1]
+        laser_pad = i_ex.shape[0] // 2
+
+        prob_ex = numpy.ones(datamap.whole_datamap.shape)
+        prob_sted = numpy.ones(datamap.whole_datamap.shape)
+        bleached_datamap = numpy.copy(datamap.whole_datamap)
+        returned_photons = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+        thresholds = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+
+        bleached_sub_datamaps_dict = {}
+        if isinstance(indices, type(None)):
+            indices = 0   # VÉRIF À QUOI INDICES SERT?
+        for key in datamap.sub_datamaps_dict:
+            bleached_sub_datamaps_dict[key] = numpy.copy(datamap.sub_datamaps_dict[key])
+
+        for (row, col) in pixel_list:
+            row_slice = slice(row + rows_pad - laser_pad, row + rows_pad + laser_pad + 1)
+            col_slice = slice(col + cols_pad - laser_pad, col + cols_pad + laser_pad + 1)
+
+            pdts, p_exs, p_steds = numpy.zeros(len(self.opts["decision_time"])), numpy.zeros(len(self.opts["decision_time"])), numpy.zeros(len(self.opts["decision_time"]))
+            for i, (lower_threshold, upper_threshold, decision_time) in enumerate(zip(self.opts["lower_threshold"], self.opts["upper_threshold"], self.opts["decision_time"])):
+                # If last decision, we aquire for the remaining time period
+                if decision_time < 0.:
+                    decision_time = pdt[row, col]# - numpy.array(self.opts["decision_time"])[:-1].sum()
+
+                effective = self.get_effective(datamap_pixelsize, p_ex[row, col], p_sted[row, col])
+                h, w = effective.shape
+
+                # Uses the bleached datamap
+                bleached_datamap = numpy.zeros(bleached_sub_datamaps_dict["base"].shape, dtype=numpy.int32)
+                for key in bleached_sub_datamaps_dict:
+                    bleached_datamap += bleached_sub_datamaps_dict[key]
+
+                # Calculates the number of acquired photons
+                pixel_intensity = numpy.sum(effective * bleached_datamap[row_slice, col_slice])
+                pixel_photons = self.detector.get_signal(self.fluo.get_photons(pixel_intensity), decision_time)
+
+                # Stores the action taken for futures bleaching
+                pdts[i] = decision_time
+                p_exs[i] = p_ex[row, col]
+                p_steds[i] = p_sted[row, col]
+
+                # STEPS
+                # if number of photons is less than lower_threshold
+                # we skip
+                # if number of photons is higher than upper_threshold
+                # we stop acquisition and assign number of count as total_time/decision_time
+                # if number of photons is between
+                # We continue to the next step
+                # At the final step we assign the number of acquired photons
+
+                if (lower_threshold > 0) and (pixel_photons < lower_threshold):
+                    thresholds[row, col] = 0
+                    # returned_photons[row, col] += (pixel_photons * pdt[row, col] / decision_time).astype(int)
+                    break
+                elif (upper_threshold > 0) and (pixel_photons > upper_threshold):
+                    thresholds[row, col] = 2
+                    returned_photons[row, col] += (pixel_photons * pdt[row, col] / decision_time).astype(int)
+                    break
+                else:
+                    thresholds[row, col] = 1
+                    returned_photons[row, col] += pixel_photons
+
+            if bleach:
+                for _p_ex, _p_sted, _pdt in zip(p_exs, p_steds, pdts):
+                    bleach_func(self, i_ex, i_sted, _p_ex, _p_sted,
+                                _pdt, bleached_sub_datamaps_dict,
+                                row, col, h, w, prob_ex, prob_sted)
+                sample_func(self, bleached_sub_datamaps_dict, row, col, h, w, prob_ex, prob_sted)
+
+        if update and bleach:
+            datamap.sub_datamaps_dict = bleached_sub_datamaps_dict
+            datamap.base_datamap = datamap.sub_datamaps_dict["base"]
+            datamap.whole_datamap = numpy.copy(datamap.base_datamap)
+
+        return returned_photons, bleached_sub_datamaps_dict, thresholds
diff --git a/pysted/raster.pyx b/pysted/raster.pyx
index cc74f69..f83bb89 100644
--- a/pysted/raster.pyx
+++ b/pysted/raster.pyx
@@ -4,6 +4,7 @@ import numpy
 from matplotlib import pyplot as plt
 import bleach_funcs
 cimport numpy
+import scipy
 cimport cython
 
 from libc.math cimport exp
@@ -58,13 +59,14 @@ def raster_func_c_self_bleach_split_g(
     cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] step
 
     """
-    raster_func_c_self_bleach executes the simultaneous acquisition and bleaching routine for the case where the 
+    raster_func_c_self_bleach executes the simultaneous acquisition and bleaching routine for the case where the
     excitation power (p_ex) AND/OR sted power (p_sted) vary through the sample. This function thus requires these
     parameters to be passed as arrays of floats the same size as the ROI being imaged.
 
     Additionally, this function seperately bleaches the different parts composing the datamap (i.e. the base and flash
     components of the datamap are bleached separately).
     """
+
     if seed == 0:
         # if no seed is passed, calculates a 'pseudo-random' seed form the time in ns
         srand(int(str(time.time_ns())[-5:-1]))
@@ -97,8 +99,112 @@ def raster_func_c_self_bleach_split_g(
         acquired_intensity[int(row / ratio), int(col / ratio)] = value
 
         if bleach:
-            #
-            for step in steps:
-                bleach_func(self, i_ex, i_sted, p_ex, p_sted, step[row, col], bleached_sub_datamaps_dict, row, col, h, w, prob_ex,
-                            prob_sted)
-            sample_func(self, bleached_sub_datamaps_dict, row, col, h, w, prob_ex, prob_sted)
\ No newline at end of file
+            bleach_func(self, i_ex, i_sted, p_ex, p_sted, pdt, bleached_sub_datamaps_dict, row, col, h, w, prob_ex,
+                        prob_sted)
+            sample_func(self, bleached_sub_datamaps_dict, row, col, h, w, prob_ex, prob_sted)
+
+@cython.boundscheck(False)  # turn off bounds-checking for entire function
+@cython.wraparound(False)  # turn off negative index wrapping for entire function
+def raster_func_c_self_bleach_dymin(
+        object self,
+        object datamap,
+        numpy.ndarray[FLOATDTYPE_t, ndim=2] acquired_intensity,
+        numpy.ndarray[FLOATDTYPE_t, ndim=2] scaled_power,
+        numpy.ndarray[INTDTYPE_t, ndim=2] pixel_list,
+        int ratio,
+        int rows_pad,
+        int cols_pad,
+        int laser_pad,
+        numpy.ndarray[FLOATDTYPE_t, ndim=2] prob_ex,
+        numpy.ndarray[FLOATDTYPE_t, ndim=2] prob_sted,
+        numpy.ndarray[FLOATDTYPE_t, ndim=2] pdt_roi,
+        numpy.ndarray[FLOATDTYPE_t, ndim=2] p_ex_roi,
+        numpy.ndarray[FLOATDTYPE_t, ndim=2] p_sted_roi,
+        bint bleach,   # bint is a bool
+        dict bleached_sub_datamaps_dict,
+        int seed,
+        object bleach_func   # uncertain of the type for a cfunc, but this seems to be working so ???
+):
+    cdef int row, col
+    cdef int sprime, tprime
+    cdef int h, w
+    cdef int current
+    cdef int max_len = len(pixel_list)
+    cdef FLOATDTYPE_t value
+    cdef int sampled_value
+    cdef int prob
+    cdef int rsamp
+    cdef FLOATDTYPE_t pdt, p_ex, p_sted
+    cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] pre_effective, effective
+    cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] k_ex, k_sted
+    cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] i_ex, i_sted
+    cdef numpy.ndarray[FLOATDTYPE_t, ndim=2] photons_ex, photons_sted
+    cdef numpy.ndarray[FLOATDTYPE_t, ndim=1] pdts, p_exs, p_steds
+    cdef numpy.ndarray[int, ndim=2] bleached_datamap
+    cdef FLOATDTYPE_t duty_cycle
+
+    """
+    raster_func_c_self_bleach executes the simultaneous acquisition and bleaching routine for the case where the
+    excitation power (p_ex) AND/OR sted power (p_sted) vary through the sample. This function thus requires these
+    parameters to be passed as arrays of floats the same size as the ROI being imaged.
+
+    Additionally, this function seperately bleaches the different parts composing the datamap (i.e. the base and flash
+    components of the datamap are bleached separately).
+    """
+    if seed == 0:
+        # if no seed is passed, calculates a 'pseudo-random' seed form the time in ns
+        srand(int(str(time.time_ns())[-5:-1]))
+    else:
+        srand(seed)
+
+    i_ex, i_sted, _ = self.cache(datamap.pixelsize)
+    pre_effective = self.get_effective(datamap.pixelsize, p_ex_roi[0, 0], p_sted_roi[0, 0])
+    h, w = pre_effective.shape[0], pre_effective.shape[1]
+
+    scale_powers = self.opts["scale_power"]
+    decision_times = self.opts["decision_time"]
+    threshold_counts = self.opts["threshold_count"]
+
+    for (row, col) in (pixel_list):
+        pdts, p_exs, p_steds = numpy.zeros(len(scale_powers)), numpy.zeros(len(scale_powers)), numpy.zeros(len(scale_powers))
+        for i in range(len(scale_powers)):
+            pdt = decision_times[i]
+            scale_power = scale_powers[i]
+            threshold_count = threshold_counts[i]
+            if pdt < 0.:
+                pdt = pdt_roi[row, col]
+
+            p_ex = p_ex_roi[row, col]
+            p_sted = scale_power * p_sted_roi[row, col]
+            effective = self.get_effective(datamap.pixelsize, p_ex, p_sted)
+            # i think resetting each time ensures that we are acquiring on the dmap while it is
+            # being bleached. Either way, it doesn't affect speed, so I will keep it here
+            bleached_datamap = numpy.zeros(bleached_sub_datamaps_dict["base"].shape, dtype=numpy.int32)
+            for key in bleached_sub_datamaps_dict:
+                bleached_datamap += bleached_sub_datamaps_dict[key]
+
+            value = 0.0
+            sprime = 0
+            for s in range(row, row + h):
+                tprime = 0
+                for t in range(col, col + w):
+                    value += effective[sprime, tprime] * bleached_datamap[s, t]
+                    tprime += 1
+                sprime += 1
+            acquired_intensity[int(row / ratio), int(col / ratio)] = value
+
+            pdts[i] = pdt
+            p_exs[i] = p_ex
+            p_steds[i] = p_sted
+
+            scaled_power[row, col] = scale_power
+            photons = numpy.array(self.fluo.get_photons(value))
+            photons = self.detector.get_signal(photons, pdt)
+            if photons < threshold_count:
+                acquired_intensity[int(row / ratio), int(col / ratio)] = 0
+                break
+
+        if bleach:
+            bleach_func(self, i_ex, i_sted, p_exs, p_steds, pdts,
+                        bleached_sub_datamaps_dict, row, col, h, w,
+                        prob_ex, prob_sted)
diff --git a/pysted/utils.py b/pysted/utils.py
index 56f3551..ce38801 100644
--- a/pysted/utils.py
+++ b/pysted/utils.py
@@ -7,6 +7,7 @@
 '''
 
 import numpy
+import numpy as np
 import scipy, scipy.constants, scipy.integrate
 
 # import mis par BT
@@ -14,12 +15,14 @@
 import random
 import warnings
 import tifffile
+import os
 
 # import mis par BT pour des tests :)
 from matplotlib import pyplot
 import time
 from pysted import temporal, raster
 from scipy.spatial.distance import cdist
+from tqdm.auto import tqdm, trange
 
 
 def approx_binomial(n, p, size=None):
@@ -869,12 +872,14 @@ def sample_light_curve(light_curves):
     return smoothed_sampled
 
 
-def flash_generator(events_curves_path):
+def flash_generator(events_curves_path, seed=None):
     """
-    xd
-    :param events_curves_path:
-    :return:
+    Generates a flash by sampling from statistics built from save light curves
+    :param events_curves_path: Path to the .npy file containing the light curves
+    :param seed: Sets the seed for random sampling :)
+    :return: A sampled light curve
     """
+    numpy.random.seed(seed)
     events_curves = numpy.load(events_curves_path)
 
     sampled_light_curve = sample_light_curve(events_curves)
@@ -882,6 +887,92 @@ def flash_generator(events_curves_path):
     return sampled_light_curve
 
 
+def sampled_flash_manipulations(events_curves_path, delay, rescale=True, seed=None):
+    """
+    Samples a light curve and modifies it to make it more prettier for training (i.e. more like the hand crafted light
+    curves)
+    - converts the values to ints
+    - add variable delay at the start of the curve to delay the flash
+    - (optional) rescales the values between [1, 28]
+    :param events_curves_path: Path to the .npy file containing the light curves
+    :param delay: Number of steps where the flash value stays ctw at 1 before the flash starts
+    :param rescale: Whether or not the light curve will be rescaled. For now, if true, simply rescales between [1, 28]
+                    because this is the value range for
+    :param seed: Sets the seed for random sampling :)
+    """
+    numpy.random.seed(seed)
+    events_curves = numpy.load(events_curves_path)
+
+    sampled_light_curve = sample_light_curve(events_curves)
+
+    if rescale:
+        sampled_light_curve = (28 - 1) * (sampled_light_curve - sampled_light_curve.min()) / \
+                                       (sampled_light_curve.max() - sampled_light_curve.min()) + 1
+
+    sampled_light_curve = numpy.round(sampled_light_curve).astype(int)
+
+    if type(delay) is tuple:
+        delay = numpy.random.randint(delay[0], delay[1])
+    if delay > 0:
+        delay = numpy.ones(delay)
+        sampled_light_curve = numpy.append(delay, sampled_light_curve)
+
+    return sampled_light_curve
+
+
+def hand_crafted_light_curve(delay=2, n_decay_steps=10, n_molecules_multiplier=28, end_pad=0):
+    """
+    Hand crafted light curve that has a more abrupt rise than sampling a light curve from real data.
+    :param delay: The number of steps before the peak of the light curve.
+    :param n_decay_steps: The number of steps for the light curve to return to 1
+    :param n_molecules_multiplier: The value of the light curve at it's peak
+    :param end_pad: The number of steps where the curve stays flat at 1 after the end of the exponential decay.
+    :returns: The hand crafted light curve, which is flat at 1 until t = delay, where it peaks to n_molecs_multiplier,
+              then decays back to 1 over t = n_decay_steps steps, and stays flat at 1 for end_pad + 1 steps
+    """
+    # why is it so hard for me to plot an exponential decay
+    tau = 3
+    tmax = 10
+    t = np.linspace(0, tmax, n_decay_steps)
+    y = n_molecules_multiplier * np.exp(-t / tau)
+
+    # light_curve = np.ones(20)
+    light_curve = np.ones(delay + n_decay_steps + end_pad)
+    light_curve[delay:delay + y.shape[0]] *= y
+    light_curve = numpy.where(light_curve < 1, 1, light_curve)
+
+    return light_curve
+
+
+def smooth_ramp_hand_crafted_light_curve(delay=2, n_decay_steps=10, n_molecules_multiplier=None, end_pad=0):
+    """
+    Hand crafted light curve that has a more abrupt rise than sampling a light curve from real data.
+    :param delay: The number of steps before the peak of the light curve.
+    :param n_decay_steps: The number of steps for the light curve to return to 1
+    :param n_molecules_multiplier: The value of the light curve at it's peak
+    :param end_pad: The number of steps where the curve stays flat at 1 after the end of the exponential decay.
+    :returns: The hand crafted light curve, which is flat at 1 until t = delay, where it peaks to n_molecs_multiplier,
+              then decays back to 1 over t = n_decay_steps steps, and stays flat at 1 for end_pad + 1 steps
+    """
+    if n_molecules_multiplier is None:
+        n_molecules_multiplier = numpy.random.randint(20, 35)
+    if type(n_molecules_multiplier) is tuple:
+        n_molecules_multiplier = numpy.random.randint(n_molecules_multiplier[0], n_molecules_multiplier[1])
+
+    # why is it so hard for me to plot an exponential decay
+    tau = 3
+    tmax = 10
+    t = np.linspace(0, tmax, n_decay_steps)
+    y = n_molecules_multiplier * np.exp(-t / tau)
+
+    # light_curve = np.ones(20)
+    light_curve = np.ones(delay + n_decay_steps + end_pad + 1)
+    light_curve[delay] = int(0.2 * np.max(y))
+    light_curve[delay + 1:delay + 1 + y.shape[0]] *= y
+    light_curve = numpy.where(light_curve < 1, 1, light_curve)
+
+    return light_curve
+
 
 def generate_fiber_with_synapses(datamap_shape, fibre_min, fibre_max, n_synapses, min_dist, polygon_scale=(5, 10)):
     """
@@ -1200,6 +1291,24 @@ def compute_time_correspondances(fwhm_step_sec_correspondance, acquisition_time_
         return n_time_steps, x_pixels_for_flash_ts
 
 
+def time_quantum_to_flash_tstep_correspondance(fwhm_step_sec_corresnpondance, time_quantum_us):
+    """
+    Computes the correspondance between the time quantum value (in us) and the flash time steps
+    :param fwhm_step_sec_corresnpondance: A tuple containing how large in time steps the FWHM of the mean flash is at
+                                          index 0 and how large in useconds we want the FWHM to be at index 1
+    :param time_quantum_us: Value of the time quantum used by the master clock (in us)
+    :return:
+    """
+    fwhm_time_usecs, fwhm_time_steps = fwhm_step_sec_corresnpondance[1], fwhm_step_sec_corresnpondance[0]
+    usec_per_time_step = fwhm_time_usecs / fwhm_time_steps
+    # I think in most cases, the time_quantum will be 1 us
+    # I also need to make sure the fwhm_time_usecs is in usecs and is a multiple of the time_quantum_us ?
+    n_time_quantums_per_flash_ts = int(usec_per_time_step / time_quantum_us)
+    return n_time_quantums_per_flash_ts
+
+
+
+
 def flash_routine(synapses, probability, synapse_flashing_dict, synapse_flash_idx_dict, curves_path,
                   synapse_flash_curve_dict, isolated_synapses_frames, datamap):
     """
@@ -1399,3 +1508,15 @@ def action_execution_g(action_selected, frame_shape, starting_pixel, pxsize, dat
                                                                          indices=t_stack_idx)
 
     return acq, intensity_map, datamap, pixel_list
+
+def make_path_sane(p):
+    """Function to uniformly return a real, absolute filesystem path."""
+    # ~/directory -> /home/user/directory
+    p = os.path.expanduser(p)
+    # A/.//B -> A/B
+    p = os.path.normpath(p)
+    # Resolve symbolic links
+    p = os.path.realpath(p)
+    # Ensure path is absolute
+    p = os.path.abspath(p)
+    return p
diff --git a/requirements-nodes.txt b/requirements-nodes.txt
new file mode 100644
index 0000000..8cb065f
--- /dev/null
+++ b/requirements-nodes.txt
@@ -0,0 +1,18 @@
+certifi
+cycler
+Cython
+decorator
+imageio
+kiwisolver
+matplotlib
+networkx
+numpy
+Pillow
+pyparsing
+python-dateutil
+PyWavelets
+scikit-image
+scipy
+six
+tifffile
+tqdm
diff --git a/requirements.txt b/requirements.txt
index c7646a6..ad55afe 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -34,8 +34,8 @@ nbconvert==6.1.0
 nbformat==5.1.3
 nest-asyncio==1.5.1
 networkx==2.5.1
+numpy==1.20.2
 notebook==6.4.0
-numpy==1.21.0
 packaging==20.9
 pandocfilters==1.4.3
 parso==0.8.2
@@ -55,7 +55,7 @@ pyzmq==22.1.0
 qtconsole==5.1.0
 QtPy==1.9.0
 scikit-image==0.18.1
-scipy==1.7.0
+scipy==1.5.2
 Send2Trash==1.7.1
 six==1.16.0
 terminado==0.10.1
diff --git a/requirements2.txt b/requirements2.txt
new file mode 100644
index 0000000..8268216
--- /dev/null
+++ b/requirements2.txt
@@ -0,0 +1,17 @@
+certifi==2021.5.30
+cycler==0.10.0
+Cython==0.29.23
+decorator==4.4.2
+imageio==2.9.0
+kiwisolver==1.3.1
+matplotlib==3.4.2
+networkx==2.5.1
+numpy==1.21.0
+pyparsing==2.4.7
+python-dateutil==2.8.1
+PyWavelets==1.1.1
+scikit-image==0.18.1
+scipy==1.7.0
+six==1.16.0
+tifffile==2021.6.14
+tqdm==4.61.1
\ No newline at end of file


Test patch:
diff --git a/aaai_figure1_stuff/fig1_test1.py b/aaai_figure1_stuff/fig1_test1.py
new file mode 100644
index 0000000..f8e514e
--- /dev/null
+++ b/aaai_figure1_stuff/fig1_test1.py
@@ -0,0 +1,273 @@
+import os
+import numpy as np
+from matplotlib import pyplot as plt
+
+from pysted import base, utils
+from pysted import exp_data_gen as dg
+
+from gym_sted.rewards.objectives_timed import find_nanodomains, Signal_Ratio, Resolution
+from gym_sted.utils import get_foreground
+import metrics
+
+
+"""
+Voir pages 5-7 de mon doc "Papier aaai" sur mon ipad, j'explique ce que je veux
+ - Pour la fig C, je veux faire un cube de données montrant le % de NDs résolus / f1_score obtenu en fonction de
+   pdt, p_ex, p_sted pour un phy_react fixe
+   
+ - Pour la fig D, je veux choisir la best combinaison (pdt, p_ex) selon ce que j'ai obtenu pour la figure C ^
+   et montrer comment les 3 objectifs (SNR, résolution, Bleach) varient en fonction de p_sted. Je ferais différentes
+   courbes pour différents phy_react
+   
+Comme D dépend de C, je vais le scripte pour C dans ce fichier. 
+*** JE VEUX TOUT ENREGISTRER ***
+ - datamps générées
+    - positions des NDs
+ - images acquises
+ - pdt, p_ex, p_sted utilisés
+ - % NDs résolus
+    - positions des guess de NDs
+ - f1_score
+ - datamaps après l'acq
+ - valeurs photobleaching, SNR, résolution obtenus
+ - am I forgetting something ?
+ 
+structure d'enregistrement des données :
+ - faire un folder pour chaque chose que j'ai listé en haut
+ - enregistrer le data dans le folder approprié (xd), avec un nom du genre
+    <DATA>_pdt_<PDT VALUE>_pex_<P_EX VALUE>_psted_<P_STED VALUE>.npy
+ - je vais répeter (?) fois pour chaque tuple de params, donc enregistrer ^ comme des np arrays de (?)
+"""
+
+def rescale_func(val_to_scale, current_range_min, current_range_max, new_min, new_max):
+    return ( (val_to_scale - current_range_min) / (current_range_max - current_range_min) ) * (new_max - new_min) + new_min
+
+
+path_to_save_dir = os.path.join(os.path.expanduser('~'), "Documents", "research", "NeurIPS", "aaai_paper", "data_gen",
+                                "data_for_fig_1_v1", "c_v1_data")
+
+# make directories for all the data that will be saved
+data_to_save_dict = {
+    "datamaps before": "/datamaps_before_acq",
+    "nd gt": "/nd_gt_positions",
+    "acquired images": "/acquired_images",
+    "% resolved nd": "/ratio_resolved_nd",
+    "nd guess": "/nd_guess_positions",
+    "f1_scores": "/f1_scores",
+    "datamaps after": "/datamaps_after_acq",
+    "photobleaching": "/photobleaching",
+    "SNR": "/snr",
+    "resolution": "/resolution",
+    "confocals before": "/confocals_before",
+    "confocals after": "/confocals_after"
+}
+
+for key in data_to_save_dict.keys():
+    if not os.path.exists(path_to_save_dir + data_to_save_dict[key]):
+        os.makedirs(path_to_save_dir + data_to_save_dict[key])
+
+print("Setting up the microscope ...")
+# Microscope stuff
+egfp = {
+    "lambda_": 535e-9,
+    "qy": 0.6,
+    "sigma_abs": {
+        488: 0.08e-21,
+        575: 0.02e-21
+    },
+    "sigma_ste": {
+        575: 3.0e-22,
+    },
+    "sigma_tri": 10.14e-21,
+    "tau": 3e-09,
+    "tau_vib": 1.0e-12,
+    "tau_tri": 1.2e-6,
+    "phy_react": {
+        488: 0.008e-5,
+        575: 0.008e-8
+    },
+    "k_isc": 0.48e+6
+}
+
+action_spaces = {
+    "p_sted" : {"low" : 0., "high" : 350.0e-3},
+    "p_ex" : {"low" : 0., "high" : 250.0e-6},
+    "pdt" : {"low" : 10.0e-6, "high" : 150.0e-6},
+}
+
+pixelsize = 20e-9
+
+snr_evaluator = Signal_Ratio(percentile=75)
+resolution_evaluator = Resolution(pixelsize=pixelsize)
+
+# Generating objects necessary for acquisition simulation
+laser_ex = base.GaussianBeam(488e-9)
+laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+detector = base.Detector(noise=True, background=0)
+objective = base.Objective()
+fluo = base.Fluorescence(**egfp)
+microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)
+i_ex, i_sted, _ = microscope.cache(pixelsize, save_cache=True)
+
+conf_params = {
+    "P_EX": 25.0e-6,
+    "PDT": 10.0e-6,
+    "P_STED": 0.0
+}
+
+
+# vérifier avec Anthony si ça semble être une bonne discrétisation :)
+# pdt_values = np.linspace(action_spaces["pdt"]["low"], action_spaces["pdt"]["high"], 2)   # I want num = 11, 2 for test
+multipliers = np.array([0, 0.0078125, 0.015625, 0.03125, 0.0625, 0.125, 0.25, 0.5, 1.])
+pdt_values = multipliers * action_spaces["pdt"]["high"]
+pdt_values = rescale_func(pdt_values, np.min(pdt_values), np.max(pdt_values),
+                          action_spaces["pdt"]["low"], action_spaces["pdt"]["high"])
+p_ex_values = multipliers * action_spaces["p_ex"]["high"]
+p_sted_values = multipliers * action_spaces["p_sted"]["high"]
+
+# pdt_values = [15e-6]
+# p_ex_values = [0.0001]
+# p_sted_values = [0.05]
+
+n_repetitions = 10   # I want num = 10, 2 for test
+seeds = [s for s in range(n_repetitions)]
+for pdt in pdt_values:
+    for p_ex in p_ex_values:
+        for p_sted in p_sted_values:
+            print(f"starting {n_repetitions} acquisitions with pdt = {pdt}, p_ex = {p_ex}, p_sted = {p_sted}")
+            datamaps_before, datamaps_after = [], []
+            nd_gt_positions, nd_guess_positions = [], []
+            acquired_images = []
+            f1_scores, ratio_resolved_nds = [], []
+            photobleachings, snrs, resolutions = [], [], []
+            confocals_before, confocals_after = [], []
+            for i in range(n_repetitions):
+
+                # first step is to generate the datamap
+                shroom = dg.Synapse(5, mode="mushroom", seed=seeds[i])
+
+                n_molecs_in_domain = 135
+                min_dist = 50
+                shroom.add_nanodomains(10, min_dist_nm=min_dist, n_molecs_in_domain=n_molecs_in_domain, seed=seeds[i],
+                                       valid_thickness=7)
+                # shroom.rotate_and_translate()
+
+                dmap = base.TemporalDatamap(shroom.frame, pixelsize, shroom)
+                dmap.set_roi(i_ex, "max")
+
+                datamaps_before.append(np.copy(dmap.whole_datamap[dmap.roi]))
+                nd_gt_positions.append(np.copy(np.array(dmap.synapses.nanodomains_coords)))
+
+                # for snr / resolution evaluation
+                conf1, bleached_conf1, _ = microscope.get_signal_and_bleach(
+                    dmap, dmap.pixelsize, conf_params["PDT"], conf_params["P_EX"], conf_params["P_STED"],
+                    bleach=False, update=False, seed=seeds[i]
+                )
+
+                n_molecs_init = np.sum(dmap.whole_datamap)
+
+                acq, bleached_dict, _ = microscope.get_signal_and_bleach(dmap, dmap.pixelsize, pdt, p_ex, p_sted,
+                                                                         bleach=True, update=True, seed=seeds[i])
+
+                n_molecs_post = np.sum(dmap.whole_datamap)
+
+                # foreground on confocal image
+                fg_c = get_foreground(conf1)
+                # foreground on sted image
+                if np.any(acq):
+                    fg_s = get_foreground(acq)
+                else:
+                    fg_s = np.ones_like(fg_c)
+                # remove STED foreground points not in confocal foreground, if any
+                fg_s *= fg_c
+
+                conf2, bleached_conf1, _ = microscope.get_signal_and_bleach(
+                    dmap, dmap.pixelsize, conf_params["PDT"], conf_params["P_EX"], conf_params["P_STED"],
+                    bleach=False, update=False, seed=seeds[i]
+                )
+                confocals_before.append(conf1)
+                confocals_after.append(conf2)
+
+                acquired_images.append(np.copy(acq))
+                nd_guess_positions.append(find_nanodomains(acq, dmap.pixelsize))
+
+                detector = metrics.CentroidDetectionError(nd_gt_positions[i], nd_guess_positions[i], 2,
+                                                          algorithm="hungarian")
+                f1_scores.append(detector.f1_score)
+                ratio_resolved_nds.append(detector.true_positive / nd_gt_positions[i].shape[0])
+                datamaps_after.append(np.copy(dmap.whole_datamap[dmap.roi]))
+
+                # reste juste le photobleaching, SNR, résolution
+                photobleaching = 1 - n_molecs_post / n_molecs_init
+                snr = snr_evaluator.evaluate(acq, conf1, fg_s, fg_c, n_molecs_init, n_molecs_post,
+                                             dmap)
+                resolution = resolution_evaluator.evaluate(acq, conf1, fg_s, fg_c, n_molecs_init, n_molecs_post,
+                                                    dmap)
+
+                photobleachings.append(photobleaching)
+                snrs.append(snr)
+                resolutions.append(resolution)
+
+            max_n_guesses = 0
+            for guesses in nd_guess_positions:
+                if guesses.shape[0] > max_n_guesses:
+                    max_n_guesses = guesses.shape[0]
+            for idx, guesses in enumerate(nd_guess_positions):
+                if guesses.shape[0] < max_n_guesses and guesses.shape[0] != 0:
+                    n_appends = max_n_guesses - guesses.shape[0]
+                    vals_to_append = []
+                    for j in range(n_appends):
+                        vals_to_append.append([999, 999])
+                    guesses = np.append(guesses, vals_to_append, axis=0)
+                elif guesses.shape[0] < max_n_guesses and guesses.shape[0] == 0:
+                    guesses = []
+                    n_appends = max_n_guesses
+                    for j in range(n_appends):
+                        guesses.append([999, 999])
+                    guesses = np.asarray(guesses)
+                nd_guess_positions[idx] = guesses
+
+            # exit()
+
+            # convert into npy arrays, save to the right place with the right name :)
+            datamaps_before = np.asarray(datamaps_before)
+            datamaps_after = np.asarray(datamaps_after)
+            nd_gt_positions = np.asarray(nd_gt_positions)
+            nd_guess_positions = np.asarray(nd_guess_positions)
+            acquired_images = np.asarray(acquired_images)
+            f1_scores = np.asarray(f1_scores)
+            ratio_resolved_nds = np.asarray(ratio_resolved_nds)
+            photobleachings = np.asarray(photobleachings)
+            snrs = np.asarray(snrs)
+            resolutions = np.asarray(resolutions)
+            confocals_before = np.asarray(confocals_before)
+            confocals_after = np.asarray(confocals_after)
+
+            np.save(path_to_save_dir + data_to_save_dict["datamaps before"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", datamaps_before)
+            np.save(path_to_save_dir + data_to_save_dict["datamaps after"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", datamaps_after)
+            np.save(path_to_save_dir + data_to_save_dict["nd gt"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", nd_gt_positions)
+            np.save(path_to_save_dir + data_to_save_dict["nd guess"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", nd_guess_positions)
+            np.save(path_to_save_dir + data_to_save_dict["acquired images"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", acquired_images)
+            np.save(path_to_save_dir + data_to_save_dict["f1_scores"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", f1_scores)
+            np.save(path_to_save_dir + data_to_save_dict["% resolved nd"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", ratio_resolved_nds)
+            np.save(path_to_save_dir + data_to_save_dict["photobleaching"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", photobleachings)
+            np.save(path_to_save_dir + data_to_save_dict["SNR"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", snrs)
+            np.save(path_to_save_dir + data_to_save_dict["resolution"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", resolutions)
+            np.save(path_to_save_dir + data_to_save_dict["confocals before"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", confocals_before)
+            np.save(path_to_save_dir + data_to_save_dict["confocals after"] +
+                    f"/pdt_{pdt}_pex_{p_ex}_psted_{p_sted}.npy", confocals_after)
+
+print("~*! ---------------- !*~")
+print(f"all done without crashing ^_^")
+print("~*! ---------------- !*~")
diff --git a/aaai_figure1_stuff/fig1b_test1.py b/aaai_figure1_stuff/fig1b_test1.py
new file mode 100644
index 0000000..ae5a983
--- /dev/null
+++ b/aaai_figure1_stuff/fig1b_test1.py
@@ -0,0 +1,232 @@
+import os
+import numpy as np
+from matplotlib import pyplot as plt
+
+from pysted import base, utils
+from pysted import exp_data_gen as dg
+
+from gym_sted.rewards.objectives_timed import find_nanodomains, Signal_Ratio, Resolution
+from gym_sted.utils import get_foreground
+import metrics
+
+
+"""
+plan pour cette fig:
+Montrer une datamap, une acq confocale et une acq sted sur cette datamap, la datamap bleaché pour
+chaque acq
+"""
+
+def rescale_func(val_to_scale, current_range_min, current_range_max, new_min, new_max):
+    return ( (val_to_scale - current_range_min) / (current_range_max - current_range_min) ) * (new_max - new_min) + new_min
+
+
+path_to_save_dir = os.path.join(os.path.expanduser('~'), "Documents", "research", "NeurIPS", "aaai_paper", "data_gen",
+                                "data_for_fig_1_v1", "b_v1_data")
+
+data_to_save_dict = {
+    "datamaps before": "/datamaps_before_acq",
+    "nd gt": "/nd_gt_positions",
+    "confoc acq": "/confocal_acquisition",
+    "sted acq": "/sted_acquisitions",
+    "nd guess confocal": "/nd_guess_positions_confocal",
+    "nd guess sted": "/nd_guess_positions_sted",
+    "f1_scores confocal": "/f1_scores_confocal",
+    "f1_scores sted": "/f1_scores_sted",
+    "% resolved nd confocal": "/ratio_resolved_nd_confocal",
+    "% resolved nd sted": "/ratio_resolved_nd_sted",
+    "datamaps after confocal": "/datamaps_after_confocal",
+    "datamaps after sted": "/datamaps_after_sted",
+    "photobleaching confocal": "/photobleaching_confocal",
+    "photobleaching sted": "/photobleaching_sted",
+    "SNR confocal": "/snr_confocal",
+    "SNR sted": "/snr_sted",
+    "resolution confocal": "/resolution_confocal",
+    "resolution sted": "/resolution_sted",
+}
+
+# for key in data_to_save_dict.keys():
+#     if not os.path.exists(path_to_save_dir + data_to_save_dict[key]):
+#         os.makedirs(path_to_save_dir + data_to_save_dict[key])
+
+print("Setting up the microscope ...")
+# Microscope stuff
+egfp = {
+    "lambda_": 535e-9,
+    "qy": 0.6,
+    "sigma_abs": {
+        488: 0.08e-21,
+        575: 0.02e-21
+    },
+    "sigma_ste": {
+        575: 3.0e-22,
+    },
+    "sigma_tri": 10.14e-21,
+    "tau": 3e-09,
+    "tau_vib": 1.0e-12,
+    "tau_tri": 1.2e-6,
+    "phy_react": {
+        488: 0.008e-5,
+        575: 0.008e-8
+    },
+    "k_isc": 0.48e+6
+}
+
+action_spaces = {
+    "p_sted" : {"low" : 0., "high" : 350.0e-3},
+    "p_ex" : {"low" : 0., "high" : 250.0e-6},
+    "pdt" : {"low" : 10.0e-6, "high" : 150.0e-6},
+}
+
+pixelsize = 20e-9
+
+snr_evaluator = Signal_Ratio(percentile=75)
+resolution_evaluator = Resolution(pixelsize=pixelsize)
+
+# Generating objects necessary for acquisition simulation
+laser_ex = base.GaussianBeam(488e-9)
+laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+detector = base.Detector(noise=True, background=0)
+objective = base.Objective()
+fluo = base.Fluorescence(**egfp)
+microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)
+i_ex, i_sted, _ = microscope.cache(pixelsize, save_cache=True)
+
+confoc_ratio, sted_ratio = 0.6, 0.25
+pdt_mult = 1
+
+mode = "same"
+
+if mode == "diff":
+    conf_params = {
+        "p_ex": 25.0e-6,
+        "pdt": pdt_mult * 10.0e-6,
+        "p_sted": 0.0
+    }
+    save_dir = path_to_save_dir + "/diff_params"
+elif mode == "same":
+    conf_params = {
+        "p_ex": confoc_ratio * action_spaces["p_ex"]["high"],
+        "pdt": pdt_mult * 10.0e-6,
+        "p_sted": 0.0
+    }
+    save_dir = path_to_save_dir + "/same_params"
+
+sted_params = {
+    # "p_ex": 25.0e-6,
+    "p_ex": confoc_ratio * action_spaces["p_ex"]["high"],
+    "pdt": pdt_mult * 10.0e-6,
+    "p_sted": sted_ratio * action_spaces["p_sted"]["high"]
+}
+
+print(action_spaces["p_ex"]["high"])
+print(0.25 * action_spaces["p_sted"]["high"])
+exit()
+
+datamaps_before, datamaps_after_confoc, datamaps_after_sted = [], [], []
+nd_gt_positions, nd_guess_positions_confoc, nd_guess_positions_sted = [], [], []
+acq_confocals, acq_steds = [], []
+f1_scores_confoc, f1_scores_sted, ratio_resolved_nds_confoc, ratio_resolved_nds_sted = [], [], [], []
+# photobleachings_confoc, snrs_confoc, resolutions_confoc = [], [], []
+# photobleachings_sted, snrs_sted, resolutions_sted = [], [], []
+
+n_repetitions = 10   # I want num = 10, 1 for test
+seeds = [s for s in range(n_repetitions)]
+for i in range(n_repetitions):
+    print(f"starting acq {i+1} of {n_repetitions}")
+
+    # first step is to generate the datamap
+    shroom = dg.Synapse(5, mode="mushroom", seed=seeds[i])
+
+    n_molecs_in_domain = 135
+    min_dist = 50
+    shroom.add_nanodomains(10, min_dist_nm=min_dist, n_molecs_in_domain=n_molecs_in_domain, seed=seeds[i],
+                           valid_thickness=7)
+    # shroom.rotate_and_translate()
+
+    dmap = base.TemporalDatamap(shroom.frame, pixelsize, shroom)
+    dmap.set_roi(i_ex, "max")
+
+    datamaps_before.append(np.copy(dmap.whole_datamap[dmap.roi]))
+    nd_gt_positions.append(np.copy(np.array(dmap.synapses.nanodomains_coords)))
+
+    confoc_acq, confoc_bleached, _ = microscope.get_signal_and_bleach(dmap, dmap.pixelsize, **conf_params,
+                                                                      bleach=True, update=False, seed=seeds[i])
+    confoc_bleached = confoc_bleached["base"][dmap.roi]
+
+    acq_confocals.append(np.copy(confoc_acq))
+    datamaps_after_confoc.append(np.copy(confoc_bleached))
+
+    nd_guess_positions_confoc.append(find_nanodomains(confoc_acq, dmap.pixelsize))
+
+    detector_confoc = metrics.CentroidDetectionError(nd_gt_positions[i], nd_guess_positions_confoc[i], 2,
+                                                     algorithm="hungarian")
+    f1_scores_confoc.append(detector_confoc.f1_score)
+    ratio_resolved_nds_confoc.append(detector_confoc.true_positive / nd_gt_positions[i].shape[0])
+
+    sted_acq, sted_bleached, _ = microscope.get_signal_and_bleach(dmap, dmap.pixelsize, **sted_params,
+                                                                  bleach=True, update=False, seed=seeds[i])
+    sted_bleached = sted_bleached["base"][dmap.roi]
+
+    acq_steds.append(np.copy(sted_acq))
+    datamaps_after_sted.append(np.copy(sted_bleached))
+
+    nd_guess_positions_sted.append(find_nanodomains(sted_acq, dmap.pixelsize))
+
+    detector_sted = metrics.CentroidDetectionError(nd_gt_positions[i], nd_guess_positions_sted[i], 2,
+                                                   algorithm="hungarian")
+    f1_scores_sted.append(detector_sted.f1_score)
+    ratio_resolved_nds_sted.append(detector_sted.true_positive / nd_gt_positions[i].shape[0])
+
+    # fig, axes = plt.subplots(2, 3)
+    #
+    # axes[0, 0].imshow(dmap.whole_datamap[dmap.roi], cmap='hot')
+    # axes[0, 0].set_title(f"Datamap before acquisition")
+    #
+    # axes[0, 1].imshow(confoc_acq, cmap='hot', vmin=0, vmax=np.max(confoc_acq))
+    # axes[0, 1].set_title(f"Confocal acquisition")
+    #
+    # axes[0, 2].imshow(confoc_bleached, cmap='hot')
+    # axes[0, 2].set_title(f"Datamap after confocal")
+    #
+    # axes[1, 0].imshow(dmap.whole_datamap[dmap.roi], cmap='hot')
+    #
+    # axes[1, 1].imshow(sted_acq, cmap='hot', vmin=0, vmax=np.max(confoc_acq))
+    # axes[1, 1].set_title(f"STED acquisition")
+    #
+    # axes[1, 2].imshow(sted_bleached, cmap='hot')
+    # axes[1, 2].set_title(f"Datamap after STED")
+    #
+    # plt.show()
+    # plt.close(fig)
+
+# datamaps_before, datamaps_after_confoc, datamaps_after_sted = [], [], []
+# nd_gt_positions, nd_guess_positions_confoc, nd_guess_positions_sted = [], [], []
+# acq_confocals, acq_steds = [], []
+# f1_scores_confoc, f1_scores_sted, ratio_resolved_nds_confoc, ratio_resolved_nds_sted = [], [], [], []
+
+datamaps_before = np.asarray(datamaps_before)
+datamaps_after_confoc = np.asarray(datamaps_after_confoc)
+datamaps_after_sted = np.asarray(datamaps_after_sted)
+nd_gt_positions = np.asarray(nd_gt_positions)
+nd_guess_positions_confoc = np.asarray(nd_guess_positions_confoc)
+nd_guess_positions_sted = np.asarray(nd_guess_positions_sted)
+acq_confocals = np.asarray(acq_confocals)
+acq_steds = np.asarray(acq_steds)
+f1_scores_confoc = np.asarray(f1_scores_confoc)
+f1_scores_sted = np.asarray(f1_scores_sted)
+ratio_resolved_nds_confoc = np.asarray(ratio_resolved_nds_confoc)
+ratio_resolved_nds_sted = np.asarray(ratio_resolved_nds_sted)
+
+np.save(save_dir + "/datamaps_before.npy", datamaps_before)
+np.save(save_dir + "/datamaps_after_confoc.npy", datamaps_after_confoc)
+np.save(save_dir + "/datamaps_after_sted.npy", datamaps_after_sted)
+np.save(save_dir + "/nd_gt_positions.npy", nd_gt_positions)
+np.save(save_dir + "/nd_guess_positions_confoc.npy", nd_guess_positions_confoc)
+np.save(save_dir + "/nd_guess_positions_sted.npy", nd_guess_positions_sted)
+np.save(save_dir + "/acq_confocals.npy", acq_confocals)
+np.save(save_dir + "/acq_steds.npy", acq_steds)
+np.save(save_dir + "/f1_scores_confoc.npy", f1_scores_confoc)
+np.save(save_dir + "/f1_scores_sted.npy", f1_scores_sted)
+np.save(save_dir + "/ratio_resolved_nds_confoc.npy", ratio_resolved_nds_confoc)
+np.save(save_dir + "/ratio_resolved_nds_sted.npy", ratio_resolved_nds_sted)
+
diff --git a/aaai_figure1_stuff/fig1d_test1.py b/aaai_figure1_stuff/fig1d_test1.py
new file mode 100644
index 0000000..82f7f68
--- /dev/null
+++ b/aaai_figure1_stuff/fig1d_test1.py
@@ -0,0 +1,249 @@
+import os
+import numpy as np
+from matplotlib import pyplot as plt
+
+from pysted import base, utils
+from pysted import exp_data_gen as dg
+
+from gym_sted.rewards.objectives_timed import find_nanodomains, Signal_Ratio, Resolution
+from gym_sted.utils import get_foreground
+import metrics
+
+
+def rescale_func(val_to_scale, current_range_min, current_range_max, new_min, new_max):
+    return ( (val_to_scale - current_range_min) / (current_range_max - current_range_min) ) * (new_max - new_min) + new_min
+
+
+path_to_save_dir = os.path.join(os.path.expanduser('~'), "Documents", "research", "NeurIPS", "aaai_paper", "data_gen",
+                                "data_for_fig_1_v1", "d_v1_data")
+
+# make directories for all the data that will be saved
+data_to_save_dict = {
+    "datamaps before": "/datamaps_before_acq",
+    "nd gt": "/nd_gt_positions",
+    "acquired images": "/acquired_images",
+    "% resolved nd": "/ratio_resolved_nd",
+    "nd guess": "/nd_guess_positions",
+    "f1_scores": "/f1_scores",
+    "datamaps after": "/datamaps_after_acq",
+    "photobleaching": "/photobleaching",
+    "SNR": "/snr",
+    "resolution": "/resolution",
+    "confocals before": "/confocals_before",
+    "confocals after": "/confocals_after"
+}
+for key in data_to_save_dict.keys():
+    if not os.path.exists(path_to_save_dir + data_to_save_dict[key]):
+        os.makedirs(path_to_save_dir + data_to_save_dict[key])
+
+action_spaces = {
+    "p_sted" : {"low" : 0., "high" : 350.0e-3},
+    "p_ex" : {"low" : 0., "high" : 250.0e-6},
+    "pdt" : {"low" : 10.0e-6, "high" : 150.0e-6},
+}
+
+conf_params = {
+    "P_EX": 25.0e-6,
+    "PDT": 10.0e-6,
+    "P_STED": 0.0
+}
+
+egfp = {
+    "lambda_": 535e-9,
+    "qy": 0.6,
+    "sigma_abs": {
+        488: 0.08e-21,
+        575: 0.02e-21
+    },
+    "sigma_ste": {
+        575: 3.0e-22,
+    },
+    "sigma_tri": 10.14e-21,
+    "tau": 3e-09,
+    "tau_vib": 1.0e-12,
+    "tau_tri": 1.2e-6,
+    "phy_react": None,
+    "k_isc": 0.48e+6
+}
+
+pixelsize = 20e-9
+
+snr_evaluator = Signal_Ratio(percentile=75)
+resolution_evaluator = Resolution(pixelsize=pixelsize)
+
+# Generating objects necessary for acquisition simulation
+laser_ex = base.GaussianBeam(488e-9)
+laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+detector = base.Detector(noise=True, background=0)
+objective = base.Objective()
+
+multipliers = np.array([0, 0.0078125, 0.015625, 0.03125, 0.0625, 0.125, 0.25, 0.5, 1.])
+# multipliers = np.array([0, 1.])
+p_sted_values = multipliers * action_spaces["p_sted"]["high"]   # 25% donnait les best results
+pdt = action_spaces["pdt"]["low"]
+p_ex = action_spaces["p_ex"]["high"]
+
+# lists go from très gentil to très méchant
+phy_react_488_values = [0.008e-6, 4.4e-8, 0.008e-5, 4.4e-7, 0.008e-4]
+phy_react_575_values = [0.008e-9, 4.4e-11, 0.008e-8, 4.4e-10, 0.008e-7]
+# phy_react_488_values = [0.008e-6, 0.008e-4]
+# phy_react_575_values = [0.008e-9, 0.008e-7]
+
+# these are combos that I know how they act together, unsure about the other (488, 575) mixes
+phy_reacts_combos = [
+    {488: 0.008e-6, 575: 0.008e-9},   # très gentil
+    {488: 4.4e-8, 575: 4.4e-11},   # gentil
+    {488: 0.008e-5, 575: 0.008e-8},   # base
+    {488: 4.4e-7, 575: 4.4e-10},   # méchant
+    {488: 0.008e-4, 575: 0.008e-7},   # très méchant
+]
+
+n_repetitions = 10   # I want num = 10, 2 for test
+seeds = [s for s in range(n_repetitions)]
+for p_sted in p_sted_values:
+    for phy_react_488 in phy_react_488_values:
+        for phy_react_575 in phy_react_575_values:
+            print(f"starting {n_repetitions} acquisitions with p_sted = {p_sted}, "
+                  f"phy_react_488 = {phy_react_488}, phy_react_575 = {phy_react_575}")
+            datamaps_before, datamaps_after = [], []
+            nd_gt_positions, nd_guess_positions = [], []
+            acquired_images = []
+            f1_scores, ratio_resolved_nds = [], []
+            photobleachings, snrs, resolutions = [], [], []
+            confocals_before, confocals_after = [], []
+            for i in range(n_repetitions):
+                egfp["phy_react"] = {488: phy_react_488, 575: phy_react_575}
+                fluo = base.Fluorescence(**egfp)
+                microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)
+                i_ex, i_sted, _ = microscope.cache(pixelsize, save_cache=True)
+
+                # first step is to generate the datamap
+                shroom = dg.Synapse(5, mode="mushroom", seed=seeds[i])
+
+                n_molecs_in_domain = 135
+                min_dist = 50
+                shroom.add_nanodomains(10, min_dist_nm=min_dist, n_molecs_in_domain=n_molecs_in_domain, seed=seeds[i],
+                                       valid_thickness=7)
+                # shroom.rotate_and_translate()
+
+                dmap = base.TemporalDatamap(shroom.frame, pixelsize, shroom)
+                dmap.set_roi(i_ex, "max")
+
+                datamaps_before.append(np.copy(dmap.whole_datamap[dmap.roi]))
+                nd_gt_positions.append(np.copy(np.array(dmap.synapses.nanodomains_coords)))
+
+                # for snr / resolution evaluation
+                conf1, bleached_conf1, _ = microscope.get_signal_and_bleach(
+                    dmap, dmap.pixelsize, conf_params["PDT"], conf_params["P_EX"], conf_params["P_STED"],
+                    bleach=False, update=False, seed=seeds[i]
+                )
+
+                n_molecs_init = np.sum(dmap.whole_datamap)
+
+                acq, bleached_dict, _ = microscope.get_signal_and_bleach(dmap, dmap.pixelsize, pdt, p_ex, p_sted,
+                                                                         bleach=True, update=True, seed=seeds[i])
+
+                n_molecs_post = np.sum(dmap.whole_datamap)
+
+                # foreground on confocal image
+                fg_c = get_foreground(conf1)
+                # foreground on sted image
+                if np.any(acq):
+                    fg_s = get_foreground(acq)
+                else:
+                    fg_s = np.ones_like(fg_c)
+                # remove STED foreground points not in confocal foreground, if any
+                fg_s *= fg_c
+
+                conf2, bleached_conf1, _ = microscope.get_signal_and_bleach(
+                    dmap, dmap.pixelsize, conf_params["PDT"], conf_params["P_EX"], conf_params["P_STED"],
+                    bleach=False, update=False, seed=seeds[i]
+                )
+                confocals_before.append(conf1)
+                confocals_after.append(conf2)
+
+                acquired_images.append(np.copy(acq))
+                nd_guess_positions.append(find_nanodomains(acq, dmap.pixelsize))
+
+                peak_detector = metrics.CentroidDetectionError(nd_gt_positions[i], nd_guess_positions[i], 2,
+                                                          algorithm="hungarian")
+                f1_scores.append(peak_detector.f1_score)
+                ratio_resolved_nds.append(peak_detector.true_positive / nd_gt_positions[i].shape[0])
+                datamaps_after.append(np.copy(dmap.whole_datamap[dmap.roi]))
+
+                # reste juste le photobleaching, SNR, résolution
+                photobleaching = 1 - n_molecs_post / n_molecs_init
+                snr = snr_evaluator.evaluate(acq, conf1, fg_s, fg_c, n_molecs_init, n_molecs_post,
+                                             dmap)
+                resolution = resolution_evaluator.evaluate(acq, conf1, fg_s, fg_c, n_molecs_init, n_molecs_post,
+                                                           dmap)
+
+                photobleachings.append(photobleaching)
+                snrs.append(snr)
+                resolutions.append(resolution)
+
+            max_n_guesses = 0
+            for guesses in nd_guess_positions:
+                if guesses.shape[0] > max_n_guesses:
+                    max_n_guesses = guesses.shape[0]
+            for idx, guesses in enumerate(nd_guess_positions):
+                if guesses.shape[0] < max_n_guesses and guesses.shape[0] != 0:
+                    n_appends = max_n_guesses - guesses.shape[0]
+                    vals_to_append = []
+                    for j in range(n_appends):
+                        vals_to_append.append([999, 999])
+                    guesses = np.append(guesses, vals_to_append, axis=0)
+                elif guesses.shape[0] < max_n_guesses and guesses.shape[0] == 0:
+                    guesses = []
+                    n_appends = max_n_guesses
+                    for j in range(n_appends):
+                        guesses.append([999, 999])
+                    guesses = np.asarray(guesses)
+                nd_guess_positions[idx] = guesses
+
+            # exit()
+
+            # convert into npy arrays, save to the right place with the right name :)
+            datamaps_before = np.asarray(datamaps_before)
+            datamaps_after = np.asarray(datamaps_after)
+            nd_gt_positions = np.asarray(nd_gt_positions)
+            nd_guess_positions = np.asarray(nd_guess_positions)
+            acquired_images = np.asarray(acquired_images)
+            f1_scores = np.asarray(f1_scores)
+            ratio_resolved_nds = np.asarray(ratio_resolved_nds)
+            photobleachings = np.asarray(photobleachings)
+            snrs = np.asarray(snrs)
+            resolutions = np.asarray(resolutions)
+            confocals_before = np.asarray(confocals_before)
+            confocals_after = np.asarray(confocals_after)
+
+            save_name_ext = f"/psted_{p_sted}_phyreact488_{phy_react_488}_phyreact575_{phy_react_575}.npy"
+
+            np.save(path_to_save_dir + data_to_save_dict["datamaps before"] +
+                    save_name_ext, datamaps_before)
+            np.save(path_to_save_dir + data_to_save_dict["datamaps after"] +
+                    save_name_ext, datamaps_after)
+            np.save(path_to_save_dir + data_to_save_dict["nd gt"] +
+                    save_name_ext, nd_gt_positions)
+            np.save(path_to_save_dir + data_to_save_dict["nd guess"] +
+                    save_name_ext, nd_guess_positions)
+            np.save(path_to_save_dir + data_to_save_dict["acquired images"] +
+                    save_name_ext, acquired_images)
+            np.save(path_to_save_dir + data_to_save_dict["f1_scores"] +
+                    save_name_ext, f1_scores)
+            np.save(path_to_save_dir + data_to_save_dict["% resolved nd"] +
+                    save_name_ext, ratio_resolved_nds)
+            np.save(path_to_save_dir + data_to_save_dict["photobleaching"] +
+                    save_name_ext, photobleachings)
+            np.save(path_to_save_dir + data_to_save_dict["SNR"] +
+                    save_name_ext, snrs)
+            np.save(path_to_save_dir + data_to_save_dict["resolution"] +
+                    save_name_ext, resolutions)
+            np.save(path_to_save_dir + data_to_save_dict["confocals before"] +
+                    save_name_ext, confocals_before)
+            np.save(path_to_save_dir + data_to_save_dict["confocals after"] +
+                    save_name_ext, confocals_after)
+
+print("~*! ---------------- !*~")
+print(f"all done without crashing ^_^")
+print("~*! ---------------- !*~")
diff --git a/tests/TestBleachingConstants.ipynb b/tests/TestBleachingConstants.ipynb
new file mode 100644
index 0000000..b9c07a4
--- /dev/null
+++ b/tests/TestBleachingConstants.ipynb
@@ -0,0 +1,434 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "id": "62486a0b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "import numpy\n",
+    "\n",
+    "from matplotlib import pyplot\n",
+    "from tqdm.auto import tqdm\n",
+    "from ipywidgets import interact\n",
+    "from IPython.display import display, clear_output\n",
+    "\n",
+    "from pysted import base, utils, raster, exp_data_gen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "id": "25730581",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "LASER_EX = {\"lambda_\" : 488e-9}\n",
+    "LASER_STED = {\"lambda_\" : 575e-9, \"zero_residual\" : 0.01}\n",
+    "DETECTOR = {\"noise\" : True}\n",
+    "OBJECTIVE = {}\n",
+    "# FLUO = {\n",
+    "#     \"lambda_\": 535e-9,\n",
+    "#     \"qy\": 0.6,\n",
+    "#     \"sigma_abs\": {488: 4.5e-21,   # was 1.15e-20\n",
+    "#                   575: 6e-21},\n",
+    "#     \"sigma_ste\": {560: 1.2e-20,\n",
+    "#                   575: 3.0e-22,   # was 6.0e-21\n",
+    "#                   580: 5.0e-21},\n",
+    "#     \"sigma_tri\": 1e-21,\n",
+    "#     \"tau\": 3e-09,\n",
+    "#     \"tau_vib\": 1.0e-12,\n",
+    "#     \"tau_tri\": 5e-6,\n",
+    "#     \"phy_react\": {488: 0.25e-7,   # 1e-4\n",
+    "#                   575: 25.0e-11},   # 1e-8\n",
+    "#     \"k_isc\": 0.26e6\n",
+    "# }\n",
+    "FLUO = {\n",
+    "    \"lambda_\": 535e-9,\n",
+    "    \"qy\": 0.6,\n",
+    "    \"sigma_abs\": {\n",
+    "        488: 0.2e-21,   # was 1.15e-20\n",
+    "        575: 0.01e-21\n",
+    "    },\n",
+    "    \"sigma_ste\": {\n",
+    "        575: 3.0e-22,   # was 6.0e-21\n",
+    "    },\n",
+    "    \"sigma_tri\": 0.01e-21, # 1e-21\n",
+    "    \"tau\": 3e-09,\n",
+    "    \"tau_vib\": 1.0e-12,\n",
+    "    \"tau_tri\": 5e-6,\n",
+    "    \"phy_react\": {488: 5.0e-5,   # 1e-4, 12e-7\n",
+    "                  575: 5.0e-8},   # 1e-8\n",
+    "    \"k_isc\": 0.26e+6\n",
+    "}\n",
+    "\n",
+    "action_spaces = {\n",
+    "    \"p_sted\" : {\"low\" : 0., \"high\" : 350.0e-3},\n",
+    "    # \"p_ex\" : {\"low\" : 0., \"high\" : 100.0e-6},\n",
+    "    \"p_ex\" : {\"low\" : 0., \"high\" : 250.0e-6},\n",
+    "    \"pdt\" : {\"low\" : 10.0e-6, \"high\" : 150.0e-6},\n",
+    "}\n",
+    "\n",
+    "percents_p_sted = [0.00, 0.10, 0.30, 0.50]\n",
+    "percents_p_ex = [0.05, 0.1, 0.25, 0.7, 0.9]\n",
+    "\n",
+    "percent_pdt = 0.\n",
+    "\n",
+    "def generate_bleach(sigma_tri, phy_488, phy_575, tau_vib=1.0, tau_tri=1.0, k_isc=0.26):\n",
+    "    numpy.random.seed(None)\n",
+    "    FLUO = {\n",
+    "        \"lambda_\": 535e-9,\n",
+    "        \"qy\": 0.6,\n",
+    "        \"sigma_abs\": {\n",
+    "            488: 0.2e-21,   # was 1.15e-20\n",
+    "            575: 0.01e-21\n",
+    "        },\n",
+    "        \"sigma_ste\": {\n",
+    "            575: 3.0e-22,   # was 6.0e-21\n",
+    "        },\n",
+    "        \"sigma_tri\": sigma_tri * 1e-21, # 1e-21\n",
+    "        \"tau\": 3e-09,\n",
+    "        \"tau_vib\": tau_vib * 1e-12,\n",
+    "        \"tau_tri\": tau_tri * 1e-6,\n",
+    "        \"phy_react\": {488: phy_488 * 1e-5,   # 1e-4, 12e-7\n",
+    "                      575: phy_575 * 1e-8},   # 1e-8\n",
+    "        \"k_isc\": k_isc * 1e+6\n",
+    "    }\n",
+    "\n",
+    "    laser_ex = base.GaussianBeam(**LASER_EX)\n",
+    "    laser_sted = base.DonutBeam(**LASER_STED)\n",
+    "    detector = base.Detector(**DETECTOR)\n",
+    "    objective = base.Objective(**OBJECTIVE)\n",
+    "    fluo = base.Fluorescence(**FLUO)\n",
+    "    microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)\n",
+    "\n",
+    "    i_ex, i_sted, psf_det = microscope.cache(20e-9)\n",
+    "\n",
+    "    percents_p_sted = [0]\n",
+    "    percents_p_ex = numpy.linspace(0.05, 0.95, num=9)\n",
+    "\n",
+    "    acquisitions = []\n",
+    "    for percent_p_sted in percents_p_sted:\n",
+    "        for percent_p_ex in percents_p_ex:\n",
+    "            p_ex = percent_p_ex * (action_spaces[\"p_ex\"][\"high\"] - action_spaces[\"p_ex\"][\"low\"]) + action_spaces[\"p_ex\"][\"low\"]\n",
+    "            p_sted = percent_p_sted * (action_spaces[\"p_sted\"][\"high\"] - action_spaces[\"p_sted\"][\"low\"]) + action_spaces[\"p_sted\"][\"low\"]\n",
+    "            pdt = percent_pdt * (action_spaces[\"pdt\"][\"high\"] - action_spaces[\"pdt\"][\"low\"]) + action_spaces[\"pdt\"][\"low\"]\n",
+    "\n",
+    "            photons_ex = fluo.get_photons(i_ex * p_ex)\n",
+    "            k_ex = fluo.get_k_bleach(laser_ex.lambda_, photons_ex)\n",
+    "            duty_cycle = laser_sted.tau * laser_sted.rate\n",
+    "            photons_sted = fluo.get_photons(i_sted * p_sted * duty_cycle)\n",
+    "            k_sted = fluo.get_k_bleach(laser_sted.lambda_, photons_sted)\n",
+    "\n",
+    "            prob_sted = numpy.ones(1)\n",
+    "            prob_ex = numpy.ones(1)\n",
+    "\n",
+    "            prob_ex = prob_ex * numpy.prod(numpy.exp(-1. * k_ex * pdt))\n",
+    "            prob_sted = prob_sted * numpy.prod(numpy.exp(-1. * k_sted * pdt))\n",
+    "            prob = prob_ex * prob_sted\n",
+    "\n",
+    "            initial_value = 125\n",
+    "            numpy.random.seed(42)\n",
+    "            current_value = numpy.random.binomial(initial_value, prob ** k_sted.size)\n",
+    "\n",
+    "            acquisitions.append((initial_value - current_value) / initial_value)\n",
+    "    acquisitions = numpy.array(acquisitions)\n",
+    "    acquisitions = acquisitions.reshape(len(percents_p_sted), len(percents_p_ex))\n",
+    "\n",
+    "    percents_p_sted = numpy.linspace(0.05, 0.95, num=9)\n",
+    "    percents_p_ex = [0.1]\n",
+    "\n",
+    "    acquisitions_sted = []\n",
+    "    for percent_p_sted in percents_p_sted:\n",
+    "        for percent_p_ex in percents_p_ex:\n",
+    "            p_ex = percent_p_ex * (action_spaces[\"p_ex\"][\"high\"] - action_spaces[\"p_ex\"][\"low\"]) + action_spaces[\"p_ex\"][\"low\"]\n",
+    "            p_sted = percent_p_sted * (action_spaces[\"p_sted\"][\"high\"] - action_spaces[\"p_sted\"][\"low\"]) + action_spaces[\"p_sted\"][\"low\"]\n",
+    "            pdt = percent_pdt * (action_spaces[\"pdt\"][\"high\"] - action_spaces[\"pdt\"][\"low\"]) + action_spaces[\"pdt\"][\"low\"]\n",
+    "\n",
+    "            photons_ex = fluo.get_photons(i_ex * p_ex)\n",
+    "            k_ex = fluo.get_k_bleach(laser_ex.lambda_, photons_ex)\n",
+    "            duty_cycle = laser_sted.tau * laser_sted.rate\n",
+    "            photons_sted = fluo.get_photons(i_sted * p_sted * duty_cycle)\n",
+    "            k_sted = fluo.get_k_bleach(laser_sted.lambda_, photons_sted)\n",
+    "            \n",
+    "            fig, ax = pyplot.subplots()\n",
+    "            ax.imshow(k_sted)\n",
+    "            pyplot.show()\n",
+    "\n",
+    "            prob_sted = numpy.ones(1)\n",
+    "            prob_ex = numpy.ones(1)\n",
+    "\n",
+    "            prob_ex = prob_ex * numpy.prod(numpy.exp(-1. * k_ex * pdt))\n",
+    "            prob_sted = prob_sted * numpy.prod(numpy.exp(-1. * k_sted * pdt))\n",
+    "            prob = prob_ex * prob_sted\n",
+    "\n",
+    "            initial_value = 125\n",
+    "            running_sum = 0\n",
+    "            current_value = numpy.random.binomial(initial_value, prob ** k_sted.size, size=10000)\n",
+    "                \n",
+    "            acquisitions_sted.append((initial_value - current_value.mean()) / initial_value)\n",
+    "    acquisitions_sted = numpy.array(acquisitions_sted)\n",
+    "    acquisitions_sted = acquisitions_sted.reshape(len(percents_p_sted), len(percents_p_ex))\n",
+    "\n",
+    "    formatted = \"\"\"\n",
+    "sigma_tri : {:0.4f}\n",
+    "phy_488 : {:0.4f}\n",
+    "phy_575 : {:0.4f}\n",
+    "tau_vib : {:0.4f}\n",
+    "tau_tri : {:0.4f}\n",
+    "k_isc : {:0.4f}\n",
+    "    \"\"\".format(sigma_tri, phy_488, phy_575, tau_vib, tau_tri, k_isc)\n",
+    "    print(formatted)\n",
+    "    print(acquisitions)\n",
+    "    print(acquisitions_sted.ravel())\n",
+    "\n",
+    "#     return acquisitions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "id": "dcbbde47",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "105c85f1754f41a6b8e87f4adda72ef5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=25.05, description='sigma_tri', max=50.0, min=0.1, step=0.01), FloatSl…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib notebook\n",
+    "w = interact(\n",
+    "    generate_bleach, \n",
+    "    sigma_tri=(0.1, 50., 0.01),\n",
+    "    phy_488=(0.0001, 0.01, 0.00001),\n",
+    "    phy_575=(0.00001, 0.01, 0.00001),\n",
+    "    tau_tri=(0.001, 5, 0.001),\n",
+    "    k_isc=(0.01, 5, 0.01)\n",
+    ")\n",
+    "\n",
+    "# fig, ax = pyplot.subplots()\n",
+    "# ax.plot(percents_p_ex, acquisitions[0])\n",
+    "# ax.set(ylim=(-0.1, 1.1), xlim=(-0.1, 1.1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "fdb1d360",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "LASER_EX = {\"lambda_\" : 488e-9}\n",
+    "LASER_STED = {\"lambda_\" : 575e-9, \"zero_residual\" : 0.01}\n",
+    "DETECTOR = {\"noise\" : True}\n",
+    "OBJECTIVE = {}\n",
+    "# FLUO = {\n",
+    "#     \"lambda_\": 535e-9,\n",
+    "#     \"qy\": 0.6,\n",
+    "#     \"sigma_abs\": {488: 4.5e-21,   # was 1.15e-20\n",
+    "#                   575: 6e-21},\n",
+    "#     \"sigma_ste\": {560: 1.2e-20,\n",
+    "#                   575: 3.0e-22,   # was 6.0e-21\n",
+    "#                   580: 5.0e-21},\n",
+    "#     \"sigma_tri\": 1e-21,\n",
+    "#     \"tau\": 3e-09,\n",
+    "#     \"tau_vib\": 1.0e-12,\n",
+    "#     \"tau_tri\": 5e-6,\n",
+    "#     \"phy_react\": {488: 0.25e-7,   # 1e-4\n",
+    "#                   575: 25.0e-11},   # 1e-8\n",
+    "#     \"k_isc\": 0.26e6\n",
+    "# }\n",
+    "FLUO = {\n",
+    "    \"lambda_\": 535e-9,\n",
+    "    \"qy\": 0.6,\n",
+    "    \"sigma_abs\": {\n",
+    "        488: 0.2e-21,   # was 1.15e-20\n",
+    "        575: 0.01e-21\n",
+    "    },\n",
+    "    \"sigma_ste\": {\n",
+    "        575: 3.0e-22,   # was 6.0e-21\n",
+    "    },\n",
+    "    \"sigma_tri\": 0.01e-21, # 1e-21\n",
+    "    \"tau\": 3e-09,\n",
+    "    \"tau_vib\": 1.0e-12,\n",
+    "    \"tau_tri\": 5e-6,\n",
+    "    \"phy_react\": {488: 5.0e-5,   # 1e-4, 12e-7\n",
+    "                  575: 5.0e-8},   # 1e-8\n",
+    "    \"k_isc\": 0.26e+6\n",
+    "}\n",
+    "\n",
+    "action_spaces = {\n",
+    "    \"p_sted\" : {\"low\" : 0., \"high\" : 350.0e-3},\n",
+    "    # \"p_ex\" : {\"low\" : 0., \"high\" : 100.0e-6},\n",
+    "    \"p_ex\" : {\"low\" : 0., \"high\" : 250.0e-6},\n",
+    "    \"pdt\" : {\"low\" : 10.0e-6, \"high\" : 150.0e-6},\n",
+    "}\n",
+    "\n",
+    "percents_p_sted = [0.00, 0.10, 0.30, 0.50]\n",
+    "percents_p_ex = [0.05, 0.1, 0.25, 0.7, 0.9]\n",
+    "percent_pdt = 0.\n",
+    "\n",
+    "def generate_bleach(sigma_tri, phy_488, phy_575, tau_vib=1.0, tau_tri=1.0, k_isc=0.26):\n",
+    "    numpy.random.seed(None)\n",
+    "    FLUO = {\n",
+    "        \"lambda_\": 535e-9,\n",
+    "        \"qy\": 0.6,\n",
+    "        \"sigma_abs\": {\n",
+    "            488: 0.2e-21,   # was 1.15e-20\n",
+    "            575: 0.01e-21\n",
+    "        },\n",
+    "        \"sigma_ste\": {\n",
+    "            575: 3.0e-22,   # was 6.0e-21\n",
+    "        },\n",
+    "        \"sigma_tri\": sigma_tri * 1e-21, # 1e-21\n",
+    "        \"tau\": 3e-09,\n",
+    "        \"tau_vib\": tau_vib * 1e-12,\n",
+    "        \"tau_tri\": tau_tri * 1e-6,\n",
+    "        \"phy_react\": {488: phy_488 * 1e-5,   # 1e-4, 12e-7\n",
+    "                      575: phy_575 * 1e-8},   # 1e-8\n",
+    "        \"k_isc\": k_isc * 1e+6\n",
+    "    }\n",
+    "\n",
+    "    laser_ex = base.GaussianBeam(**LASER_EX)\n",
+    "    laser_sted = base.DonutBeam(**LASER_STED)\n",
+    "    detector = base.Detector(**DETECTOR)\n",
+    "    objective = base.Objective(**OBJECTIVE)\n",
+    "    fluo = base.Fluorescence(**FLUO)\n",
+    "    microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)\n",
+    "\n",
+    "    i_ex, i_sted, psf_det = microscope.cache(20e-9)\n",
+    "\n",
+    "    percents_p_ex = [0.05]\n",
+    "\n",
+    "    acquisitions = []\n",
+    "    for percent_p_sted in percents_p_sted:\n",
+    "        for percent_p_ex in percents_p_ex:\n",
+    "            p_ex = percent_p_ex * (action_spaces[\"p_ex\"][\"high\"] - action_spaces[\"p_ex\"][\"low\"]) + action_spaces[\"p_ex\"][\"low\"]\n",
+    "            p_sted = percent_p_sted * (action_spaces[\"p_sted\"][\"high\"] - action_spaces[\"p_sted\"][\"low\"]) + action_spaces[\"p_sted\"][\"low\"]\n",
+    "            pdt = percent_pdt * (action_spaces[\"pdt\"][\"high\"] - action_spaces[\"pdt\"][\"low\"]) + action_spaces[\"pdt\"][\"low\"]\n",
+    "\n",
+    "            photons_ex = fluo.get_photons(i_ex * p_ex)\n",
+    "            k_ex = fluo.get_k_bleach(laser_ex.lambda_, photons_ex)\n",
+    "            duty_cycle = laser_sted.tau * laser_sted.rate\n",
+    "            photons_sted = fluo.get_photons(i_sted * p_sted * duty_cycle)\n",
+    "            k_sted = fluo.get_k_bleach(laser_sted.lambda_, photons_sted)\n",
+    "\n",
+    "            prob_sted = numpy.ones(1)\n",
+    "            prob_ex = numpy.ones(1)\n",
+    "\n",
+    "            prob_ex = prob_ex * numpy.prod(numpy.exp(-1. * k_ex * pdt))\n",
+    "            prob_sted = prob_sted * numpy.prod(numpy.exp(-1. * k_sted * pdt))\n",
+    "            prob = prob_ex * prob_sted\n",
+    "\n",
+    "            initial_value = 125\n",
+    "            numpy.random.seed(42)\n",
+    "            current_value = numpy.random.binomial(initial_value, prob ** k_sted.size)\n",
+    "\n",
+    "            acquisitions.append((initial_value - current_value) / initial_value)\n",
+    "    acquisitions = numpy.array(acquisitions)\n",
+    "    acquisitions = acquisitions.reshape(len(percents_p_sted), len(percents_p_ex))\n",
+    "\n",
+    "#     clear_output()\n",
+    "#     print(acquisitions)\n",
+    "#     fig, ax = pyplot.subplots()\n",
+    "#     ax.plot(percents_p_ex, acquisitions[0])\n",
+    "#     ax.set(ylim=(-0.1, 1.1), xlim=(-0.1, 1.1))\n",
+    "#     pyplot.show()    \n",
+    "\n",
+    "    formatted = \"\"\"\n",
+    "sigma_tri : {:0.4f}\n",
+    "phy_488 : {:0.4f}\n",
+    "phy_575 : {:0.6f}\n",
+    "tau_vib : {:0.4f}\n",
+    "tau_tri : {:0.4f}\n",
+    "k_isc : {:0.4f}\n",
+    "    \"\"\".format(sigma_tri, phy_488, phy_575, tau_vib, tau_tri, k_isc)\n",
+    "    print(formatted)\n",
+    "    return acquisitions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "id": "e5365e3e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "24b93f9da51646248f575f333a924ef9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=30.32, description='sigma_tri', max=90.96000000000001, min=-30.32), Fl…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib notebook\n",
+    "w = interact(\n",
+    "    generate_bleach, \n",
+    "    sigma_tri=30.32,\n",
+    "    phy_488=0.0007,\n",
+    "    phy_575=(0.00001, 0.001, 0.00001),\n",
+    "    tau_tri=3.08,\n",
+    "    k_isc=1.34\n",
+    ")\n",
+    "\n",
+    "# fig, ax = pyplot.subplots()\n",
+    "# ax.plot(percents_p_ex, acquisitions[0])\n",
+    "# ax.set(ylim=(-0.1, 1.1), xlim=(-0.1, 1.1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0feea471",
+   "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.8.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/TestBleachingConstants.py b/tests/TestBleachingConstants.py
new file mode 100644
index 0000000..0f7870f
--- /dev/null
+++ b/tests/TestBleachingConstants.py
@@ -0,0 +1,259 @@
+
+import time
+import numpy
+
+from matplotlib import pyplot
+from tqdm import tqdm
+
+from pysted import base, utils, raster, exp_data_gen
+
+############################################
+############################################
+# Defaults
+############################################
+############################################
+
+P_STED = 35.0e-3
+P_EX = 25.0e-6
+PDT = 10.0e-6
+
+LASER_EX = {"lambda_" : 488e-9}
+LASER_STED = {"lambda_" : 575e-9, "zero_residual" : 0.01}
+DETECTOR = {"noise" : True}
+OBJECTIVE = {}
+FLUO = {
+    "lambda_": 535e-9,
+    "qy": 0.6,
+    "sigma_abs": {488: 4.5e-21,   # was 1.15e-20
+                  575: 6e-21},
+    "sigma_ste": {560: 1.2e-20,
+                  575: 3.0e-22,   # was 6.0e-21
+                  580: 5.0e-21},
+    "sigma_tri": 1e-21,
+    "tau": 3e-09,
+    "tau_vib": 1.0e-12,
+    "tau_tri": 5e-6,
+    "phy_react": {488: 0.25e-7,   # 1e-4
+                  575: 25.0e-11},   # 1e-8
+    "k_isc": 0.26e6
+}
+# Best for now
+FLUO = {
+    "lambda_": 535e-9,
+    "qy": 0.6,
+    "sigma_abs": {
+        488: 0.08e-21,   # was 1.15e-20
+        575: 0.02e-21
+    },
+    "sigma_ste": {
+        575: 3.0e-22,   # was 6.0e-21
+    },
+    "sigma_tri": 10.14e-21, # 1e-21
+    "tau": 3e-09,
+    "tau_vib": 1.0e-12,
+    "tau_tri": 1.2e-6,
+    "phy_react": {488: 0.008e-5,   # 1e-4, 12e-7
+                  575: 0.008e-8},   # 1e-8
+    "k_isc": 0.48e+6
+}
+
+# default
+# "phy_react": {488: 0.008e-5,
+#               575: 0.008e-8},
+# min 488
+# "phy_react": {488: 0.001e-5,
+#               575: 0.008e-8},
+# max 488
+# "phy_react": {488: 0.015e-5,
+#               575: 0.008e-8},
+# min 575
+# "phy_react": {488: 0.008e-5,
+#               575: 0.004e-8},
+# max 575
+# "phy_react": {488: 0.008e-5,
+#               575: 0.012e-8},
+
+# FLUO = {
+#     "lambda_": 535e-9,
+#     "qy": 0.6,
+#     "sigma_abs": {
+#         488: 0.2e-21,   # was 1.15e-20
+#         575: 0.08e-21
+#     },
+#     "sigma_ste": {
+#         575: 3.0e-22,   # was 6.0e-21
+#     },
+#     "sigma_tri": 10.14e-21, # 1e-21
+#     "tau": 3e-09,
+#     "tau_vib": 1.0e-12,
+#     "tau_tri": 1.2e-6,
+#     "phy_react": {488: 0.075e-26 ** 2,   # 1e-4, 12e-7
+#                   575: 0.000015e-26 ** 1.5},   # 1e-8
+#     "k_isc": 0.48e+6
+# }
+
+action_spaces = {
+    "p_sted" : {"low" : 0., "high" : 350.0e-3},
+    # "p_ex" : {"low" : 0., "high" : 100.0e-6},
+    "p_ex" : {"low" : 0., "high" : 250.0e-6},
+    "pdt" : {"low" : 10.0e-6, "high" : 150.0e-6},
+}
+
+percents_p_sted = [0.00, 0.10, 0.30, 0.50]
+percents_p_ex = [0.05, 0.25, 0.5, 0.75, 0.95]
+percents_pdt = [0., 0.1, 0.25, 0.5, 0.75, 1.0][:3]
+
+def generate_example():
+    for percent_pdt in percents_pdt:
+        pdt = percent_pdt * (action_spaces["pdt"]["high"] - action_spaces["pdt"]["low"]) + action_spaces["pdt"]["low"]
+        print(f"pdt : {pdt * 1e+6:0.4f} µs")
+
+        fig, axes = pyplot.subplots(len(percents_p_sted), len(percents_p_ex), sharex=True, sharey=True, tight_layout=True, figsize=(10,10))
+
+        acquisitions = []
+        for percent_p_sted in tqdm(percents_p_sted):
+            for percent_p_ex in tqdm(percents_p_ex, leave=False):
+
+                pixelsize = 20e-9
+                bleach = True
+                p_ex = percent_p_ex * (action_spaces["p_ex"]["high"] - action_spaces["p_ex"]["low"]) + action_spaces["p_ex"]["low"]
+                p_sted = percent_p_sted * (action_spaces["p_sted"]["high"] - action_spaces["p_sted"]["low"]) + action_spaces["p_sted"]["low"]
+                pdt = percent_pdt * (action_spaces["pdt"]["high"] - action_spaces["pdt"]["low"]) + action_spaces["pdt"]["low"]
+                roi = 'max'
+
+                shroom = exp_data_gen.Synapse(5, mode="mushroom", seed=42)
+                n_molecs_in_domain = 125
+                min_dist = 100
+                shroom.add_nanodomains((5, 10), min_dist_nm=min_dist, n_molecs_in_domain=n_molecs_in_domain, seed=42, valid_thickness=3)
+                molecules_disposition = shroom.frame.astype(int)
+                molecules_disposition = molecules_disposition[:, :]
+
+                # Generating objects necessary for acquisition simulation
+                laser_ex = base.GaussianBeam(**LASER_EX)
+                laser_sted = base.DonutBeam(**LASER_STED)
+                detector = base.Detector(**DETECTOR)
+                objective = base.Objective(**OBJECTIVE)
+                fluo = base.Fluorescence(**FLUO)
+                datamap = base.Datamap(molecules_disposition, pixelsize)
+                microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)
+                i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)
+                datamap.set_roi(i_ex, roi)
+
+                # print(f'starting acq with phy_react = {FLUO["phy_react"]}')
+                # print(f"p_sted : {p_sted * 1e+3:0.4f} mW")
+                # print(f"p_ex : {p_ex * 1e+6:0.4f} µW")
+                # print(f"pdt : {pdt * 1e+6:0.4f} µs")
+                time_start = time.time()
+                acquisition, bleached, intensity = microscope.get_signal_and_bleach(datamap, datamap.pixelsize, pdt, p_ex, p_sted,
+                                                                                    bleach=True, update=True, seed=42)
+                # print("Acquisition : ", acquisition[molecules_disposition > 0].mean())
+                bleach = (molecules_disposition.sum() - bleached["base"].sum()) / molecules_disposition.sum()
+
+                # print(f"ran in {time.time() - time_start} s")
+                axes.ravel()[len(acquisitions)].set_title("{:0.2f} - {:0.2f}".format(bleach, acquisition.max()))
+                acquisitions.append(acquisition)
+
+        acquisitions = numpy.array(acquisitions)
+
+        for ax, acquisition in zip(axes.ravel(), acquisitions):
+            ax.imshow(acquisition, cmap="hot")#, vmin=0, vmax=0.1 * acquisitions.max(), cmap="hot")
+        # for ax in axes.ravel():
+        #     ax.get_xaxis().set_visible(False)
+        #     ax.get_yaxis().set_visible(False)
+        if axes.ndim == 1:
+            axes = axes[numpy.newaxis, :]
+        for ax, p in zip(axes[:, 0], percents_p_sted):
+            ax.set(ylabel="sted : {:0.2f}".format(p))
+        for ax, p in zip(axes[-1, :], percents_p_ex):
+            ax.set(xlabel="ex : {:0.2f}".format(p))
+
+        # fig.savefig(f"./panels/bleachConstants/previous-{pdt * 1e+6:0.0f}.png", transparent=True, dpi=300)
+        # pyplot.close("all")
+    pyplot.show()
+
+def generate_random_curve():
+    while True:
+
+        numpy.random.seed(None)
+        FLUO = {
+            "lambda_": 535e-9,
+            "qy": 0.6,
+            "sigma_abs": {
+                488: 0.2e-21,   # was 1.15e-20
+                575: 0.01e-21
+            },
+            "sigma_ste": {
+                575: 3.0e-22,   # was 6.0e-21
+            },
+            "sigma_tri": numpy.random.uniform(0.01e-21, 0.1e-21), # 1e-21
+            "tau": 3e-09,
+            "tau_vib": 1.0e-12,
+            "tau_tri": 5e-6,
+            "phy_react": {488: numpy.random.uniform(1.0e-5, 10e-5),   # 1e-4, 12e-7
+                          575: numpy.random.uniform(1.0e-8, 10e-8)},   # 1e-8
+            "k_isc": 0.26e+6
+        }
+
+        laser_ex = base.GaussianBeam(**LASER_EX)
+        laser_sted = base.DonutBeam(**LASER_STED)
+        detector = base.Detector(**DETECTOR)
+        objective = base.Objective(**OBJECTIVE)
+        fluo = base.Fluorescence(**FLUO)
+        microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)
+
+        i_ex, i_sted, psf_det = microscope.cache(20e-9)
+
+        percents_p_sted = [0]
+
+        acquisitions = []
+        for percent_p_sted in tqdm(percents_p_sted):
+            for percent_p_ex in tqdm(percents_p_ex, leave=False):
+                p_ex = percent_p_ex * (action_spaces["p_ex"]["high"] - action_spaces["p_ex"]["low"]) + action_spaces["p_ex"]["low"]
+                p_sted = percent_p_sted * (action_spaces["p_sted"]["high"] - action_spaces["p_sted"]["low"]) + action_spaces["p_sted"]["low"]
+                pdt = percent_pdt * (action_spaces["pdt"]["high"] - action_spaces["pdt"]["low"]) + action_spaces["pdt"]["low"]
+
+                photons_ex = fluo.get_photons(i_ex * p_ex)
+                k_ex = fluo.get_k_bleach(laser_ex.lambda_, photons_ex)
+                duty_cycle = laser_sted.tau * laser_sted.rate
+                photons_sted = fluo.get_photons(i_sted * p_sted * duty_cycle)
+                k_sted = fluo.get_k_bleach(laser_sted.lambda_, photons_sted)
+
+                prob_sted = numpy.ones(1)
+                prob_ex = numpy.ones(1)
+
+                prob_ex = prob_ex * numpy.prod(numpy.exp(-1. * k_ex * pdt))
+                prob_sted = prob_sted * numpy.prod(numpy.exp(-1. * k_sted * pdt))
+                prob = prob_ex * prob_sted
+
+                initial_value = 125
+                numpy.random.seed(42)
+                current_value = numpy.random.binomial(initial_value, prob ** k_sted.size)
+
+                acquisitions.append((initial_value - current_value) / initial_value)
+        acquisitions = numpy.array(acquisitions)
+        acquisitions = acquisitions.reshape(len(percents_p_sted), len(percents_p_ex))
+
+        fig, ax = pyplot.subplots()
+        ax.plot(percents_p_ex, acquisitions[0])
+        ax.set(ylim=(-0.1, 1.1), xlim=(-0.1, 1.1))
+
+
+        print(FLUO)
+
+        pyplot.show()
+
+if __name__ == "__main__":
+
+    print(0.008e-5, 0.008e-5 - 0.007e-5, 0.008e-5 + 0.007e-5)
+    samples = numpy.random.normal(
+        loc=0.008e-5, scale=0.007e-5 / 2.576, size=10000
+    )
+    print(samples.mean(), samples.min(), samples.max())
+
+    print(0.008e-8, 0.008e-8 - 0.004e-8, 0.008e-8 + 0.004e-8)
+    samples = numpy.random.normal(
+        loc=0.008e-8, scale=0.004e-8 / 2.576, size=10000
+    )
+    print(samples.mean(), samples.min(), samples.max())
+
+    generate_example()
diff --git a/tests/TestScanTime.py b/tests/TestScanTime.py
new file mode 100644
index 0000000..d5c1d7c
--- /dev/null
+++ b/tests/TestScanTime.py
@@ -0,0 +1,55 @@
+import numpy as np
+from pysted import base, utils, raster, bleach_funcs
+from matplotlib import pyplot as plt
+import time
+
+
+molecules_disposition = np.zeros((64, 64))
+molecules_disposition[30:40, 30:40] = 10
+# molecules_disposition = np.zeros((3, 3))
+# molecules_disposition[1, 1] = 10
+
+print("test")
+print("Setting up the microscope ...")
+# Microscope stuff
+egfp = {"lambda_": 535e-9,
+        "qy": 0.6,
+        "sigma_abs": {488: 1.15e-20,
+                      575: 6e-21},
+        "sigma_ste": {560: 1.2e-20,
+                      575: 6.0e-21,
+                      580: 5.0e-21},
+        "sigma_tri": 1e-21,
+        "tau": 3e-09,
+        "tau_vib": 1.0e-12,
+        "tau_tri": 5e-6,
+        "phy_react": {488: 1e-7,   # 1e-4
+                      575: 1e-11},   # 1e-8
+        "k_isc": 0.26e6}
+pixelsize = 10e-9
+bleach = True
+p_ex = 1e-6
+p_ex_array = np.ones(molecules_disposition.shape) * p_ex
+p_sted = 30e-3
+p_sted_array = np.ones(molecules_disposition.shape) * p_sted
+pdt = 10e-6
+pdt_array = np.ones(molecules_disposition.shape) * pdt
+roi = 'max'
+bleach_func = bleach_funcs.default_update_survival_probabilities
+
+# Generating objects necessary for acquisition simulation
+laser_ex = base.GaussianBeam(488e-9)
+laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+detector = base.Detector(noise=True, background=0)
+objective = base.Objective()
+fluo = base.Fluorescence(**egfp)
+datamap = base.Datamap(molecules_disposition, pixelsize)
+microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)
+i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)
+datamap.set_roi(i_ex, roi)
+
+print(f'starting acq with phy_react = {egfp["phy_react"]}')
+time_start = time.time()
+acquisition, bleached, intensity = microscope.get_signal_and_bleach(datamap, datamap.pixelsize, pdt, p_ex, p_sted,
+                                                                    bleach=True, update=False)
+print(f"ran in {time.time() - time_start} s")
diff --git a/tests/TestSynapseGenerationWithNanodomains.py b/tests/TestSynapseGenerationWithNanodomains.py
new file mode 100644
index 0000000..3b68d9b
--- /dev/null
+++ b/tests/TestSynapseGenerationWithNanodomains.py
@@ -0,0 +1,17 @@
+from matplotlib import pyplot as plt
+from pysted import exp_data_gen as dg
+
+
+# generating the molecules dispositions
+shroom = dg.Synapse(5, mode="mushroom", seed=42)
+
+shroom_no_nd = dg.Synapse(5, mode="mushroom", seed=42)
+
+n_molecs_in_domain = 10
+min_dist = 100
+# valid_pos_shroom = shroom.filter_valid_nanodomain_pos()
+shroom.add_nanodomains(40, min_dist_nm=min_dist, n_molecs_in_domain=n_molecs_in_domain, seed=42, valid_thickness=3)
+# shroom.fatten_nanodomains()
+
+plt.imshow(shroom.frame)
+plt.show()
\ No newline at end of file
diff --git a/tests/TestTimedExp.py b/tests/TestTimedExp.py
new file mode 100644
index 0000000..cbf2529
--- /dev/null
+++ b/tests/TestTimedExp.py
@@ -0,0 +1,108 @@
+import numpy as np
+import tqdm
+from pysted import base, utils, exp_data_gen
+import time
+import os
+import argparse
+from matplotlib import pyplot as plt
+import sys
+import argparse
+
+parser = argparse.ArgumentParser(description="Example of experiment script")
+parser.add_argument("--save_path", type=str, default="", help="Where to save the files")
+args = parser.parse_args()
+
+save_path = utils.make_path_sane(args.save_path)
+if not os.path.exists(save_path):
+    os.mkdir(save_path)
+
+hand_crafted_light_curve = utils.hand_crafted_light_curve(delay=2, n_decay_steps=10, n_molecules_multiplier=14)
+
+time_quantum_us = 1
+# exp_time = 819200   # testing with bleach is much longer :)
+exp_time = 300000
+
+print("Setting up the microscope ...")
+# Microscope stuff
+egfp = {"lambda_": 535e-9,
+        "qy": 0.6,
+        "sigma_abs": {488: 1.15e-20,
+                      575: 6e-21},
+        "sigma_ste": {560: 1.2e-20,
+                      575: 6.0e-21,
+                      580: 5.0e-21},
+        "sigma_tri": 1e-21,
+        "tau": 3e-09,
+        "tau_vib": 1.0e-12,
+        "tau_tri": 5e-6,
+        "phy_react": {488: 1e-6,   # 1e-4
+                      575: 1e-10},   # 1e-8
+        "k_isc": 0.26e6}
+pixelsize = 20e-9
+bleach = False
+p_ex_val = 1e-6
+p_sted_val = 30e-3
+pdt_val = 10e-6
+# pdt_val = np.random.randint(0, 100, size=(64, 64)) * 1e-6
+
+# Generating objects necessary for acquisition simulation
+laser_ex = base.GaussianBeam(488e-9)
+laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+detector = base.Detector(noise=True, background=0)
+objective = base.Objective()
+fluo = base.Fluorescence(**egfp)
+microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo, load_cache=True)
+i_ex, _, _ = microscope.cache(pixelsize, save_cache=True)
+molecs_disp = np.ones((64, 64))
+shroom = exp_data_gen.Synapse(5, mode="mushroom", seed=42)
+n_molecs_in_domain = 0
+min_dist = 100
+shroom.add_nanodomains(40, min_dist_nm=min_dist, n_molecs_in_domain=n_molecs_in_domain, seed=42, valid_thickness=3)
+shroom.frame = shroom.frame.astype(int)
+
+# here I want to make it look like multiple episodes are happening and in each episode an experiment that lasts exp_time
+# is launched
+agent = base.RandomActionSelector(pdt_val, p_ex_val, p_sted_val, roi_shape=molecs_disp.shape)
+n_episodes = 1
+for n in range(n_episodes):   # each loop iter would correspond to an env.reset()
+    action_counter = 0
+    # create an experiment object with a new clock and datamap
+    # temporal_dmap = base.TestTemporalDmap(molecs_disp, datamap_pixelsize=20e-9)
+    temporal_dmap = base.TemporalSynapseDmap(shroom.frame, datamap_pixelsize=20e-9, synapse_obj=shroom)
+    temporal_dmap.set_roi(i_ex, intervals='max')
+
+    decay_time_us = 1000000  # 1 seconde
+    temporal_dmap.create_t_stack_dmap(decay_time_us)
+
+    clock = base.Clock(time_quantum_us=time_quantum_us)
+
+    temporal_exp = base.TemporalExperiment(clock, microscope, temporal_dmap, exp_runtime=exp_time, bleach=False)
+    acquisitions = []
+    actions = []
+    dmaps_after_actions = []
+    while clock.current_time < temporal_exp.exp_runtime:
+        agent.select_action()
+        action_params = {"pdt": agent.current_action_pdt,
+                         "p_ex": agent.current_action_p_ex,
+                         "p_sted": agent.current_action_p_sted}
+        actions.append(agent.action_selected)
+        # each temporal_exp.play_action would correspond to a env.step()
+        acq, bleached = temporal_exp.play_action(**action_params)
+        dmaps_after_actions.append(np.copy(temporal_dmap.whole_datamap))
+        acquisitions.append(np.copy(acq))
+        action_counter += 1
+        print(f"!!!!!!! {action_counter} action(s) completed !!!!!!!")
+
+    # for i in range(len(acquisitions)):
+    #     fig, axes = plt.subplots(1, 2)
+    #
+    #     axes[0].imshow(acquisitions[i])
+    #     axes[0].set_title(f"i = {i}, action = {actions[i]}")
+    #
+    #     axes[1].imshow(dmaps_after_actions[i])
+    #     axes[1].set_title(f"dmap after actions")
+    #
+    #     plt.show()
+    #     plt.close()
+
+print("done!")
diff --git a/tests/bleach.py b/tests/bleach.py
new file mode 100644
index 0000000..20f39ff
--- /dev/null
+++ b/tests/bleach.py
@@ -0,0 +1,97 @@
+
+import numpy
+import time
+import random
+
+from pysted import base, utils, raster, bleach_funcs
+# from dymin import DyMINMicroscope
+from matplotlib import pyplot
+from collections import defaultdict
+from tqdm import tqdm, trange
+
+START = time.time()
+
+# molecules_disposition = (numpy.random.rand(40, 40) > 0.9).astype(int) * 10
+delta = 1
+molecules_disposition = numpy.zeros((50, 50))
+# molecules_disposition[
+#     molecules_disposition.shape[0]//2 - delta : molecules_disposition.shape[0]//2+delta,
+#     molecules_disposition.shape[1]//2 - delta : molecules_disposition.shape[1]//2+delta] = 8
+num_mol = 10
+for i in range(1, 4):
+    for j in range(1, 4):
+        molecules_disposition[
+            i * molecules_disposition.shape[0]//4,
+            j * molecules_disposition.shape[1]//4] = num_mol
+
+# Microscope stuff
+egfp = {"lambda_": 535e-9,
+        "qy": 0.6,
+        "sigma_abs": {488: 1.15e-20,
+                      575: 6e-21},
+        "sigma_ste": {560: 1.2e-20,
+                      575: 6.0e-21,
+                      580: 5.0e-21},
+        "sigma_tri": 1e-21,
+        "tau": 3e-09,
+        "tau_vib": 1.0e-12,
+        "tau_tri": 5e-6,
+        "phy_react": {488: 1e-7,   # 1e-4
+                      575: 1e-11},   # 1e-8
+        "k_isc": 0.26e6}
+pixelsize = 20e-9
+bleach = True
+p_ex = 2e-6
+p_ex_array = numpy.ones(molecules_disposition.shape) * p_ex
+p_sted = 2.5e-3
+p_sted_array = numpy.ones(molecules_disposition.shape) * p_sted
+pdt = 100e-6
+pdt_array = numpy.ones(molecules_disposition.shape) * pdt
+roi = 'max'
+
+out = defaultdict(list)
+argwhere = numpy.argwhere(molecules_disposition)
+for i in trange(10, desc="Reps"):
+
+    numpy.random.seed(42 + i)
+    random.seed(42 + i)
+
+    # Generating objects necessary for acquisition simulation
+    laser_ex = base.GaussianBeam(488e-9)
+    laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+    detector = base.Detector(noise=False, background=0)
+    objective = base.Objective()
+    fluo = base.Fluorescence(**egfp)
+    datamap = base.Datamap(molecules_disposition, pixelsize)
+    # microscope = DyMINMicroscope(laser_ex, laser_sted, detector, objective, fluo)
+    microscope = base.Microscope(laser_ex, laser_sted, detector, objective, fluo)
+    start = time.time()
+    i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)
+    datamap.set_roi(i_ex, roi)
+
+    time_start = time.time()
+    values = []
+    for _ in trange(2, desc="Bleach", leave=False):
+
+        left_mol = datamap.sub_datamaps_dict["base"][datamap.roi][argwhere[:, 0], argwhere[:, 1]]
+        values.append(left_mol)
+
+        acquisition, bleached, scaled_power = microscope.get_signal_and_bleach(datamap, datamap.pixelsize, pdt, p_ex, p_sted,
+                                                                            bleach=bleach, update=True)
+    for arg, value in zip(argwhere, numpy.array(values).T):
+        # for arg, val in zip(argwhere, value):
+        out["{}".format(arg//12)].append(value)
+
+fig, ax = pyplot.subplots(figsize=(3, 3))
+cmap = pyplot.cm.get_cmap("tab10")
+for i, (key, values) in enumerate(out.items()):
+    mean, std = numpy.mean(values, axis=0), numpy.std(values, axis=0)
+    x = numpy.arange(len(mean))
+    ax.plot(x, mean, label=key, color=cmap(i))
+    # ax.fill_between(x, mean - std, mean + std, color=cmap(i), alpha=0.3)
+ax.set(
+    ylabel="Molecules left", xlabel="Num. scans"
+)
+ax.legend()
+fig.savefig("./panels/bleach.pdf", transparent=True, bbox_inches="tight")
+pyplot.show()
diff --git a/tests/bleachMultipleSteps.py b/tests/bleachMultipleSteps.py
new file mode 100644
index 0000000..739e531
--- /dev/null
+++ b/tests/bleachMultipleSteps.py
@@ -0,0 +1,338 @@
+
+import numpy
+import time
+import random
+
+from pysted import base, utils, raster, bleach_funcs
+from matplotlib import pyplot
+from collections import defaultdict
+from tqdm import tqdm
+
+"""
+This is a test in which I bleach in multiple steps. The complete pixel dwelltime
+is the same for all tests, i.e. 100 microseconds.
+In the multiple steps implementation, I will use 10 steps of 10 microseconds.
+
+I compare the bleaching of the datamap if the bleaching is performed at every steps
+OR if it is a combination of all the steps at the current pixel.
+
+get_signal_and_bleach
+    Implements the default bleach without steps
+
+get_signal_and_bleach_test1
+    Implements the bleach at every steps of each pixel
+
+get_signal_and_bleach_test2
+    Implements the bleach after steps completion at each pixel
+
+In all tests, the STED power is set at 0.
+"""
+
+class DebugMicroscope(base.Microscope):
+    def __init__(self, excitation, sted, detector, objective, fluo):
+        super(DebugMicroscope, self).__init__(excitation, sted, detector, objective, fluo)
+
+    def get_signal_and_bleach_test1(self, datamap, pixelsize, pdt, p_ex, p_sted, indices=None, acquired_intensity=None,
+                                  pixel_list=None, bleach=True, update=True, seed=None, filter_bypass=False,
+                                  bleach_func=bleach_funcs.default_bleach):
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pdt = utils.float_to_array_verifier(pdt, datamap_roi.shape)
+        p_ex = utils.float_to_array_verifier(p_ex, datamap_roi.shape)
+        p_sted = utils.float_to_array_verifier(p_sted, datamap_roi.shape)
+
+        datamap_pixelsize = datamap.pixelsize
+        i_ex, i_sted, psf_det = self.cache(datamap_pixelsize)
+        if datamap.roi is None:
+            datamap.set_roi(i_ex)
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pixel_list = utils.pixel_list_filter(datamap_roi, pixel_list, pixelsize, datamap_pixelsize)
+
+        ratio = utils.pxsize_ratio(pixelsize, datamap_pixelsize)
+        rows_pad, cols_pad = datamap.roi_corners['tl'][0], datamap.roi_corners['tl'][1]
+        laser_pad = i_ex.shape[0] // 2
+
+        prob_ex = numpy.ones(datamap.whole_datamap.shape)
+        prob_sted = numpy.ones(datamap.whole_datamap.shape)
+        bleached_datamap = numpy.copy(datamap.whole_datamap)
+        returned_photons = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+        scaled_power = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+
+        bleached_sub_datamaps_dict = {}
+        if isinstance(indices, type(None)):
+            indices = 0   # VÉRIF À QUOI INDICES SERT?
+        for key in datamap.sub_datamaps_dict:
+            bleached_sub_datamaps_dict[key] = numpy.copy(datamap.sub_datamaps_dict[key])
+
+        for (row, col) in tqdm(pixel_list, desc="Pixels", leave=False):
+            row_slice = slice(row + rows_pad - laser_pad, row + rows_pad + laser_pad + 1)
+            col_slice = slice(col + cols_pad - laser_pad, col + cols_pad + laser_pad + 1)
+
+            scale_power, threshold_count, steps = 0., 0., 10
+            for _ in range(0, int(pdt[row, col] * 1e+6), steps):
+
+                decision_time = steps * 1e-6
+
+                effective = self.get_effective(datamap_pixelsize, p_ex[row, col], scale_power * p_sted[row, col])
+                h, w = effective.shape
+
+                # Uses the bleached datamap
+                bleached_datamap = numpy.zeros(bleached_sub_datamaps_dict["base"].shape, dtype=numpy.int32)
+                for key in bleached_sub_datamaps_dict:
+                    bleached_datamap += bleached_sub_datamaps_dict[key]
+
+                pixel_intensity = numpy.sum(effective * bleached_datamap[row_slice, col_slice])
+                pixel_photons = self.detector.get_signal(self.fluo.get_photons(pixel_intensity), decision_time)
+
+                if bleach:
+                    bleach_func(self, i_ex, i_sted, p_ex[row, col], scale_power * p_sted[row, col],
+                                decision_time, bleached_sub_datamaps_dict,
+                                row, col, h, w, prob_ex, prob_sted)
+
+                # If signal is less than threshold count then skip pixel
+                scaled_power[row, col] = scale_power
+                if pixel_photons < threshold_count:
+                    break
+
+                # Update the photon counts only on the last pixel power scale
+                if scale_power > 0.:
+                    returned_photons[row, col] += pixel_photons
+
+        if update and bleach:
+            datamap.sub_datamaps_dict = bleached_sub_datamaps_dict
+            datamap.base_datamap = datamap.sub_datamaps_dict["base"]
+            datamap.whole_datamap = numpy.copy(datamap.base_datamap)
+
+        return returned_photons, bleached_sub_datamaps_dict, scaled_power
+
+    def get_signal_and_bleach_test2(self, datamap, pixelsize, pdt, p_ex, p_sted, indices=None, acquired_intensity=None,
+                                  pixel_list=None, bleach=True, update=True, seed=None, filter_bypass=False,
+                                  bleach_func=bleach_funcs.default_bleach_multisteps):
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pdt = utils.float_to_array_verifier(pdt, datamap_roi.shape)
+        p_ex = utils.float_to_array_verifier(p_ex, datamap_roi.shape)
+        p_sted = utils.float_to_array_verifier(p_sted, datamap_roi.shape)
+
+        datamap_pixelsize = datamap.pixelsize
+        i_ex, i_sted, psf_det = self.cache(datamap_pixelsize)
+        if datamap.roi is None:
+            datamap.set_roi(i_ex)
+
+        datamap_roi = datamap.whole_datamap[datamap.roi]
+        pixel_list = utils.pixel_list_filter(datamap_roi, pixel_list, pixelsize, datamap_pixelsize)
+
+        ratio = utils.pxsize_ratio(pixelsize, datamap_pixelsize)
+        rows_pad, cols_pad = datamap.roi_corners['tl'][0], datamap.roi_corners['tl'][1]
+        laser_pad = i_ex.shape[0] // 2
+
+        prob_ex = numpy.ones(datamap.whole_datamap.shape)
+        prob_sted = numpy.ones(datamap.whole_datamap.shape)
+        bleached_datamap = numpy.copy(datamap.whole_datamap)
+        returned_photons = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+        scaled_power = numpy.zeros(datamap.whole_datamap[datamap.roi].shape)
+
+        bleached_sub_datamaps_dict = {}
+        if isinstance(indices, type(None)):
+            indices = 0   # VÉRIF À QUOI INDICES SERT?
+        for key in datamap.sub_datamaps_dict:
+            bleached_sub_datamaps_dict[key] = numpy.copy(datamap.sub_datamaps_dict[key])
+
+        for (row, col) in tqdm(pixel_list, desc="Pixels", leave=False):
+            row_slice = slice(row + rows_pad - laser_pad, row + rows_pad + laser_pad + 1)
+            col_slice = slice(col + cols_pad - laser_pad, col + cols_pad + laser_pad + 1)
+
+            scale_power, threshold_count, steps = 0., 0., 10
+            pdts, p_exs, p_steds = [], [], []
+            for _ in range(0, int(pdt[row, col] * 1e+6), steps):
+
+                decision_time = steps * 1e-6
+
+                effective = self.get_effective(datamap_pixelsize, p_ex[row, col], scale_power * p_sted[row, col])
+                h, w = effective.shape
+
+                # Uses the bleached datamap
+                bleached_datamap = numpy.zeros(bleached_sub_datamaps_dict["base"].shape, dtype=numpy.int32)
+                for key in bleached_sub_datamaps_dict:
+                    bleached_datamap += bleached_sub_datamaps_dict[key]
+
+                pixel_intensity = numpy.sum(effective * bleached_datamap[row_slice, col_slice])
+                pixel_photons = self.detector.get_signal(self.fluo.get_photons(pixel_intensity), decision_time)
+
+                # If signal is less than threshold count then skip pixel
+                scaled_power[row, col] = scale_power
+                if pixel_photons < threshold_count:
+                    break
+
+                # Update the photon counts only on the last pixel power scale
+                if scale_power > 0.:
+                    returned_photons[row, col] += pixel_photons
+
+                pdts.append(decision_time)
+                p_exs.append(p_ex[row, col])
+                p_steds.append(scale_power * p_sted[row, col])
+
+            pdts, p_exs, p_steds = map(numpy.array, (pdts, p_exs, p_steds))
+            if bleach:
+                bleach_func(self, i_ex, i_sted, p_exs, p_steds,
+                            pdts, bleached_sub_datamaps_dict,
+                            row, col, h, w, prob_ex, prob_sted)
+        if update and bleach:
+            datamap.sub_datamaps_dict = bleached_sub_datamaps_dict
+            datamap.base_datamap = datamap.sub_datamaps_dict["base"]
+            datamap.whole_datamap = numpy.copy(datamap.base_datamap)
+
+        return returned_photons, bleached_sub_datamaps_dict, scaled_power
+
+START = time.time()
+
+out = defaultdict(list)
+
+delta = 1
+molecules_disposition = numpy.zeros((50, 50))
+num_mol = 2
+for j in range(1,4):
+    for i in range(1,4):
+        molecules_disposition[
+            j * molecules_disposition.shape[0]//4 - delta : j * molecules_disposition.shape[0]//4 + delta + 1,
+            i * molecules_disposition.shape[1]//4 - delta : i * molecules_disposition.shape[1]//4 + delta + 1] = num_mol
+
+egfp = {"lambda_": 535e-9,
+        "qy": 0.6,
+        "sigma_abs": {488: 3e-20,
+                      575: 6e-21},
+        "sigma_ste": {560: 1.2e-20,
+                      575: 6.0e-21,
+                      580: 5.0e-21},
+        "sigma_tri": 1e-21,
+        "tau": 3e-09,
+        "tau_vib": 1.0e-12,
+        "tau_tri": 5e-6,
+        "phy_react": {488: 0.25e-7,   # 1e-4
+                      575: 0.25e-11},   # 1e-8
+        "k_isc": 0.26e6}
+pixelsize = 20e-9
+bleach = True
+p_ex = 2e-6
+p_ex_array = numpy.ones(molecules_disposition.shape) * p_ex
+p_sted = 2.5e-3
+p_sted = 0.
+p_sted_array = numpy.ones(molecules_disposition.shape) * p_sted
+pdt = 100e-6
+pdt_array = numpy.ones(molecules_disposition.shape) * pdt
+roi = 'max'
+
+print_msg = """
+Imaging parameters
+==================
+Bleach : {bleach}
+p_ex : {p_ex}
+p_sted : {p_sted}
+pdt : {pdt}
+==================
+""".format(bleach=bleach, p_ex=p_ex, p_sted=p_sted, pdt=pdt)
+print(print_msg)
+
+seed, reps = 42, 5
+for i in range(reps):
+    seed = seed + i
+
+    numpy.random.seed(seed)
+    random.seed(seed)
+
+    # Generating objects necessary for acquisition simulation
+    laser_ex = base.GaussianBeam(488e-9)
+    laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+    detector = base.Detector(noise=False, background=0, pcef=0.1)
+    objective = base.Objective()
+    fluo = base.Fluorescence(**egfp)
+    datamap = base.Datamap(molecules_disposition, pixelsize)
+    microscope = DebugMicroscope(laser_ex, laser_sted, detector, objective, fluo)
+    start = time.time()
+    i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)
+    datamap.set_roi(i_ex, roi)
+
+    time_start = time.time()
+    acquisition, bleached, scaled_power = microscope.get_signal_and_bleach_test1(datamap, datamap.pixelsize, pdt, p_ex, p_sted,
+                                                                        bleach=bleach, update=False, seed=seed)
+    print()
+    print("bleach every steps of the pixel (get_signal_and_bleach_test1)")
+    print(f"ran in {time.time() - time_start} s")
+    print("Average molecules left : ", bleached["base"][datamap.roi][molecules_disposition != 0].mean(axis=-1))
+
+    out["get_signal_and_bleach_test1"].append(bleached["base"][datamap.roi][molecules_disposition != 0].mean(axis=-1) / num_mol)
+
+seed, reps = 42, 5
+for i in range(reps):
+    seed = seed + i
+
+    numpy.random.seed(seed)
+    random.seed(seed)
+
+    # Generating objects necessary for acquisition simulation
+    laser_ex = base.GaussianBeam(488e-9)
+    laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+    detector = base.Detector(noise=False, background=0, pcef=0.1)
+    objective = base.Objective()
+    fluo = base.Fluorescence(**egfp)
+    datamap = base.Datamap(molecules_disposition, pixelsize)
+    microscope = DebugMicroscope(laser_ex, laser_sted, detector, objective, fluo)
+    start = time.time()
+    i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)
+    datamap.set_roi(i_ex, roi)
+
+    time_start = time.time()
+    acquisition, bleached, scaled_power = microscope.get_signal_and_bleach_test2(datamap, datamap.pixelsize, pdt, p_ex, p_sted,
+                                                                        bleach=bleach, update=False, seed=seed)
+
+    print()
+    print("bleach every pixel with array (get_signal_and_bleach_test2)")
+    print(f"ran in {time.time() - time_start} s")
+    print("Average molecules left : ", bleached["base"][datamap.roi][molecules_disposition != 0].mean(axis=-1))
+
+    out["get_signal_and_bleach_test2"].append(bleached["base"][datamap.roi][molecules_disposition != 0].mean(axis=-1) / num_mol)
+
+seed, reps = 42, 5
+for i in range(reps):
+    seed = seed + i
+
+    numpy.random.seed(seed)
+    random.seed(seed)
+
+    # Generating objects necessary for acquisition simulation
+    laser_ex = base.GaussianBeam(488e-9)
+    laser_sted = base.DonutBeam(575e-9, zero_residual=0)
+    detector = base.Detector(noise=False, background=0, pcef=0.1)
+    objective = base.Objective()
+    fluo = base.Fluorescence(**egfp)
+    datamap = base.Datamap(molecules_disposition, pixelsize)
+    microscope = DebugMicroscope(laser_ex, laser_sted, detector, objective, fluo)
+    start = time.time()
+    i_ex, _, _ = microscope.cache(datamap.pixelsize, save_cache=True)
+    datamap.set_roi(i_ex, roi)
+
+    time_start = time.time()
+    acquisition, bleached, scaled_power = microscope.get_signal_and_bleach(datamap, datamap.pixelsize, pdt, p_ex, p_sted,
+                                                                        bleach=bleach, update=False, seed=seed)
+
+    print()
+    print("Normal bleach (get_signal_and_bleach)")
+    print(f"ran in {time.time() - time_start} s")
+    print("Average molecules left : ", bleached["base"][datamap.roi][molecules_disposition != 0].mean(axis=-1))
+
+    out["get_signal_and_bleach"].append(bleached["base"][datamap.roi][molecules_disposition != 0].mean(axis=-1) / num_mol)
+
+
+fig, ax = pyplot.subplots()
+keys = list(sorted(out.keys()))
+for i, key in enumerate(keys):
+    data = out[key]
+    mean, std = numpy.mean(data), numpy.std(data)
+    ax.bar(i, mean, yerr=std, label=key)
+ax.legend(loc="lower right")
+ax.set(
+    ylabel="Average Mol. Left (ratio)"
+)
+fig.savefig(f"./panels/bleachMultipleSteps_{num_mol}.pdf", bbox_inches="tight", transparent=True)
+pyplot.show()