{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling of the thickness of the sensor\n",
    "\n",
    "In this notebook we will re-use the experiment done at ID28 and previously calibrated and model in 3D the detector.\n",
    "\n",
    "This detector is a Pilatus 1M with a 450µm thick silicon sensor. Let's first have a look at the absorption coefficients of this sensor material: \n",
    "\n",
    "Reference absorption coeficients are available from:\n",
    "https://physics.nist.gov/PhysRefData/XrayMassCoef/ElemTab/z14.html\n",
    "\n",
    "First we retieve the results of the previous step, then calculate the absorption efficiency:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "# use `widget` instead of `inline` for better user-experience. `inline` allows to store plots into notebooks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using pyFAI vesrion: 2025.10.0-dev0 on a AMD Ryzen Threadripper PRO 3975WX 32-Cores with 64 threads\n",
      "wavelength: 6.968e-11m,\t dist: 2.845e-01m,\t poni1: 8.865e-02m,\t poni2: 1.779e+01m,\t energy: 17.793keV\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import os\n",
    "from matplotlib.pyplot import subplots\n",
    "import numpy\n",
    "from scipy.sparse import save_npz\n",
    "import pyFAI\n",
    "import pyFAI.units\n",
    "import pyFAI.detectors\n",
    "from pyFAI.detectors.sensors import Si_MATERIAL\n",
    "import json\n",
    "from scipy.sparse import csr_matrix, linalg\n",
    "try:\n",
    "    import cpuinfo\n",
    "except ImportError:\n",
    "    cpu = \"\"\n",
    "else:\n",
    "    cpu = cpuinfo.cpuinfo.get_cpu_info().get(\"brand_raw\")\n",
    "\n",
    "start_time = time.perf_counter()\n",
    "print(f\"Using pyFAI vesrion: {pyFAI.version} on a {cpu} with {os.cpu_count()} threads\")\n",
    "with open(\"id28.json\") as f:\n",
    "    calib = json.load(f)\n",
    "\n",
    "thickness = 450e-6\n",
    "wavelength = calib[\"wavelength\"]\n",
    "dist = calib[\"param\"][calib[\"param_names\"].index(\"dist\")]\n",
    "poni1 = calib[\"param\"][calib[\"param_names\"].index(\"poni1\")]\n",
    "poni2 = calib[\"param\"][calib[\"param_names\"].index(\"poni2\")]\n",
    "energy = pyFAI.units.hc / (wavelength * 1e10)\n",
    "print(f\"wavelength: {wavelength:.3e}m,\\t \"\n",
    "      f\"dist: {dist:.3e}m,\\t \"\n",
    "      f\"poni1: {poni1:.3e}m,\\t \"\n",
    "      f\"poni2: {energy:.3e}m,\\t \"\n",
    "      f\"energy: {energy:.3f}keV\")\n",
    "mask = numpy.load(\"mask.npy\").astype(numpy.int8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Absorption coefficient at 17.8 keV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "µ = 16.4 cm^-1 hence absorption efficiency for 450µm: 52.3 %\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    f\"µ = {Si_MATERIAL.mu(energy, unit='cm'):.1f} cm^-1 \"\n",
    "    f\"hence absorption efficiency for 450µm: {100 * Si_MATERIAL.absorbance(energy, thickness):.1f} %\"\n",
    ")\n",
    "mu = Si_MATERIAL.mu(energy, unit=\"m\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pyFAI.detectors.sensors import Si_MATERIAL\n",
    "\n",
    "depth = numpy.linspace(0, 1000, 100)\n",
    "res = [1 - Si_MATERIAL.absorbance(energy, d, \"µm\") for d in depth]\n",
    "fig, ax = subplots()\n",
    "ax.plot(depth, res, \"-\")\n",
    "ax.set_xlabel(\"Depth (µm)\")\n",
    "ax.set_ylabel(\"Residual signal\")\n",
    "ax.set_title(f\"Silicon @ {energy:.1} keV\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is consistent with:\n",
    "[henke.lbl.gov](http://henke.lbl.gov/optical_constants/filter2.html) or \n",
    "[web-docs.gsi.de](https://web-docs.gsi.de/~stoe_exp/web_programs/x_ray_absorption/index.php)\n",
    "\n",
    "Now we can model the detector\n",
    "\n",
    "## Modeling of the detector:\n",
    "\n",
    "The detector is represented as a 2D array of voxels. Let vox, voy, and voz denote the dimensions of the detector along the three axes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detector Pilatus 1M\tPixelSize= 172µm, 172µm\t BottomRight(3)\n",
      "Voxel size: (x:0.000172, y:0.000172, z:0.00045)\n"
     ]
    }
   ],
   "source": [
    "detector = pyFAI.detector_factory(calib[\"detector\"])\n",
    "print(detector)\n",
    "\n",
    "vox = detector.pixel2  # this is not a typo\n",
    "voy = detector.pixel1  # x <--> axis 2\n",
    "voz = thickness\n",
    "\n",
    "print(f\"Voxel size: (x:{vox}, y:{voy}, z:{voz})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The intensity grabbed in this voxel is the triple integral of the absorbed signal coming from this pixel or from the neighboring ones.\n",
    "\n",
    "There are 3 ways to perform this intergral:\n",
    "* Volumetric analytic integral. Looks feasible with a change of variable in the depth\n",
    "* Slice per slice, the remaining intensity depand on the incidence angle + pixel splitting between neighbooring pixels\n",
    "* raytracing: the decay can be solved analytically for each ray, one has to throw many ray to average out the signal.\n",
    "\n",
    "For sake of simplicity, this integral will be calculated numerically using this raytracing algorithm.\n",
    "http://www.cse.yorku.ca/~amana/research/grid.pdf\n",
    "\n",
    "Knowing the input position for a X-ray on the detector and its propagation vector, this algorithm allows us to calculate  the length of the path in all voxel it crosses in a fairly efficient way.\n",
    "\n",
    "To speed up the calculation, we will use a few tricks:\n",
    "* One ray never crosses more than 16 pixels, which is reasonable considering the incidance angle \n",
    "* we use numba to speed-up the calculation of loops in python\n",
    "* We will allocate the needed memory by chuncks of 1 million elements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: numba in /users/kieffer/.venv/py313/lib/python3.13/site-packages (0.62.1)\n",
      "Requirement already satisfied: cython in /users/kieffer/.venv/py313/lib/python3.13/site-packages (3.0.12)\n",
      "Requirement already satisfied: llvmlite<0.46,>=0.45.0dev0 in /users/kieffer/.venv/py313/lib/python3.13/site-packages (from numba) (0.45.1)\n",
      "Requirement already satisfied: numpy<2.4,>=1.22 in /users/kieffer/.venv/py313/lib/python3.13/site-packages (from numba) (2.3.1)\n"
     ]
    }
   ],
   "source": [
    "! pip install numba cython"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Raytracing using numba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "BLOCK_SIZE = 1 << 20  # 1 million\n",
    "BUFFER_SIZE = 16\n",
    "BIG = numpy.finfo(numpy.float32).max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we are able to perform raytracing for any ray entering the detector, we can calculate the contribution to the neighboring pixels, using the absorption law (the length traveled is already known). \n",
    "To average-out the signal, we will sample a few dozens of rays per pixel to get an approximation of the volume integral. \n",
    "\n",
    "Now we need to store the results so that this transformation can be represented as a sparse matrix multiplication:\n",
    "\n",
    "b = M.a\n",
    "\n",
    "Where b is the recorded image (blurred) and a is the \"perfect\" signal. \n",
    "M being the sparse matrix where every pixel of a gives a limited number of contribution to b.\n",
    "\n",
    "Each pixel in *b* is represented by one line in *M* and we store the indices of *a* of interest with the coefficients of the matrix.\n",
    "So if a pixel i,j contributes to (i,j), (i+1,j), (i+1,j+1), there are only 3 elements in the line. \n",
    "This is advantageous for storage.\n",
    "\n",
    "We will use the CSR sparse matrix representation:\n",
    "https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_.28CSR.2C_CRS_or_Yale_format.29\n",
    "where there are 3 arrays:\n",
    "* data: containing the actual non zero values\n",
    "* indices: for a given line, it contains the column number of the associated data (at the same indice)\n",
    "* idptr: this array contains the index of the start of every line.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numba.experimental import jitclass\n",
    "from numba import int8, int32, int64, float32, float64\n",
    "\n",
    "spec = [\n",
    "    (\"vox\", float64),\n",
    "    (\"voy\", float64),\n",
    "    (\"voz\", float64),\n",
    "    (\"mu\", float64),\n",
    "    (\"dist\", float64),\n",
    "    (\"poni1\", float64),\n",
    "    (\"poni2\", float64),\n",
    "    (\"width\", int64),\n",
    "    (\"height\", int64),\n",
    "    (\"mask\", int8[:, :]),\n",
    "    (\"sampled\", int64),\n",
    "    (\"data\", float32[:]),\n",
    "    (\"indices\", int32[:]),\n",
    "    (\"idptr\", int32[:]),\n",
    "]\n",
    "\n",
    "\n",
    "@jitclass(spec)\n",
    "class ThickDetector(object):\n",
    "    \"Calculate the point spread function as function of the geometry of the experiment\"\n",
    "\n",
    "    def __init__(self, vox, voy, thickness, mask, mu, dist, poni1, poni2):\n",
    "        \"\"\"Constructor of the class:\n",
    "\n",
    "        :param vox, voy: detector pixel size in the plane\n",
    "        :param thickness: thickness of the sensor in meters\n",
    "        :param mask:\n",
    "        :param mu: absorption coefficient of the sensor material\n",
    "        :param dist: sample detector distance as defined in the geometry-file\n",
    "        :param poni1, poni2: coordinates of the PONI as defined in the geometry\n",
    "        \"\"\"\n",
    "        self.vox = vox\n",
    "        self.voy = voy\n",
    "        self.voz = thickness\n",
    "        self.mu = mu\n",
    "        self.dist = dist\n",
    "        self.poni1 = poni1\n",
    "        self.poni2 = poni2\n",
    "        self.width = mask.shape[-1]\n",
    "        self.height = mask.shape[0]\n",
    "        self.mask = mask\n",
    "        self.sampled = 0\n",
    "        self.data = numpy.zeros(BLOCK_SIZE, dtype=numpy.float32)\n",
    "        self.indices = numpy.zeros(BLOCK_SIZE, dtype=numpy.int32)\n",
    "        self.idptr = numpy.zeros(self.width * self.height + 1, dtype=numpy.int32)\n",
    "\n",
    "    def calc_one_ray(self, entx, enty):\n",
    "        \"\"\"For a ray entering at position (entx, enty), with a propagation vector (kx, ky,kz),\n",
    "        calculate the length spent in every voxel where energy is deposited from a bunch of photons entering the detector\n",
    "        at a given position and and how much energy they deposit in each voxel.\n",
    "\n",
    "        Direct implementation of http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.42.3443&rep=rep1&type=pdf\n",
    "\n",
    "        :param entx, enty: coordinate of the entry point in meter (2 components, x,y)\n",
    "        :return: coordinates voxels in x, y and length crossed when leaving the associated voxel\n",
    "        \"\"\"\n",
    "        array_x = numpy.empty(BUFFER_SIZE, dtype=numpy.int32)\n",
    "        array_x[:] = -1\n",
    "        array_y = numpy.empty(BUFFER_SIZE, dtype=numpy.int32)\n",
    "        array_y[:] = -1\n",
    "        array_len = numpy.empty(BUFFER_SIZE, dtype=numpy.float32)\n",
    "\n",
    "        # normalize the input propagation vector\n",
    "        kx = entx - self.poni2\n",
    "        ky = enty - self.poni1\n",
    "        kz = self.dist\n",
    "        n = numpy.sqrt(kx * kx + ky * ky + kz * kz)\n",
    "        kx /= n\n",
    "        ky /= n\n",
    "        kz /= n\n",
    "\n",
    "        step_X = -1 if kx < 0.0 else 1\n",
    "        step_Y = -1 if ky < 0.0 else 1\n",
    "\n",
    "        X = int(entx / self.vox)\n",
    "        Y = int(enty / self.voy)\n",
    "\n",
    "        if kx > 0.0:\n",
    "            t_max_x = ((entx // self.vox + 1) * (self.vox) - entx) / kx\n",
    "        elif kx < 0.0:\n",
    "            t_max_x = ((entx // self.vox) * (self.vox) - entx) / kx\n",
    "        else:\n",
    "            t_max_x = BIG\n",
    "\n",
    "        if ky > 0.0:\n",
    "            t_max_y = ((enty // self.voy + 1) * (self.voy) - enty) / ky\n",
    "        elif ky < 0.0:\n",
    "            t_max_y = ((enty // self.voy) * (self.voy) - enty) / ky\n",
    "        else:\n",
    "            t_max_y = BIG\n",
    "\n",
    "        # Only one case for z as the ray is travelling in one direction only\n",
    "        t_max_z = self.voz / kz\n",
    "\n",
    "        t_delta_x = abs(self.vox / kx) if kx != 0 else BIG\n",
    "        t_delta_y = abs(self.voy / ky) if ky != 0 else BIG\n",
    "        t_delta_z = self.voz / kz\n",
    "\n",
    "        finished = False\n",
    "        last_id = 0\n",
    "        array_x[last_id] = X\n",
    "        array_y[last_id] = Y\n",
    "\n",
    "        while not finished:\n",
    "            if t_max_x < t_max_y:\n",
    "                if t_max_x < t_max_z:\n",
    "                    array_len[last_id] = t_max_x\n",
    "                    last_id += 1\n",
    "                    X += step_X\n",
    "                    array_x[last_id] = X\n",
    "                    array_y[last_id] = Y\n",
    "                    t_max_x += t_delta_x\n",
    "                else:\n",
    "                    array_len[last_id] = t_max_z\n",
    "                    last_id += 1\n",
    "                    finished = True\n",
    "            else:\n",
    "                if t_max_y < t_max_z:\n",
    "                    array_len[last_id] = t_max_y\n",
    "                    last_id += 1\n",
    "                    Y += step_Y\n",
    "                    array_x[last_id] = X\n",
    "                    array_y[last_id] = Y\n",
    "                    t_max_y += t_delta_y\n",
    "                else:\n",
    "                    array_len[last_id] = t_max_z\n",
    "                    last_id += 1\n",
    "                    finished = True\n",
    "            if last_id >= array_len.size - 1:\n",
    "                print(\"resize arrays\")\n",
    "                old_size = len(array_len)\n",
    "                new_size = (old_size // BUFFER_SIZE + 1) * BUFFER_SIZE\n",
    "                new_array_x = numpy.empty(new_size, dtype=numpy.int32)\n",
    "                new_array_x[:] = -1\n",
    "                new_array_y = numpy.empty(new_size, dtype=numpy.int32)\n",
    "                new_array_y[:] = -1\n",
    "                new_array_len = numpy.empty(new_size, dtype=numpy.float32)\n",
    "                new_array_x[:old_size] = array_x\n",
    "                new_array_y[:old_size] = array_y\n",
    "                new_array_len[:old_size] = array_len\n",
    "                array_x = new_array_x\n",
    "                array_y = new_array_y\n",
    "                array_len = new_array_len\n",
    "        return array_x[:last_id], array_y[:last_id], array_len[:last_id]\n",
    "\n",
    "    def one_pixel(self, row, col, sample):\n",
    "        \"\"\"calculate the contribution of one pixel to the sparse matrix and populate it.\n",
    "\n",
    "        :param row: row index of the pixel of interest\n",
    "        :param col: column index of the pixel of interest\n",
    "        :param sample: Oversampling rate, 10 will cast 10x10 ray per pixel\n",
    "\n",
    "        :return: the extra number of pixel allocated\n",
    "        \"\"\"\n",
    "        if self.mask[row, col]:\n",
    "            return (\n",
    "                numpy.empty(0, dtype=numpy.int32),\n",
    "                numpy.empty(0, dtype=numpy.float32),\n",
    "            )\n",
    "\n",
    "        counter = 0\n",
    "        tmp_size = 0\n",
    "        last_buffer_size = BUFFER_SIZE\n",
    "        tmp_idx = numpy.empty(last_buffer_size, dtype=numpy.int32)\n",
    "        tmp_idx[:] = -1\n",
    "        tmp_coef = numpy.zeros(last_buffer_size, dtype=numpy.float32)\n",
    "\n",
    "        pos = row * self.width + col\n",
    "        start = self.idptr[pos]\n",
    "        for i in range(sample):\n",
    "            posx = (col + 1.0 * i / sample) * vox\n",
    "            for j in range(sample):\n",
    "                posy = (row + 1.0 * j / sample) * voy\n",
    "                array_x, array_y, array_len = self.calc_one_ray(posx, posy)\n",
    "\n",
    "                rem = 1.0\n",
    "                for i in range(array_x.size):\n",
    "                    x = array_x[i]\n",
    "                    y = array_y[i]\n",
    "                    l = array_len[i]\n",
    "                    if (x < 0) or (y < 0) or (y >= self.height) or (x >= self.width):\n",
    "                        break\n",
    "                    elif self.mask[y, x]:\n",
    "                        continue\n",
    "                    idx = x + y * self.width\n",
    "                    dos = numpy.exp(-self.mu * l)\n",
    "                    value = rem - dos\n",
    "                    rem = dos\n",
    "                    for j in range(last_buffer_size):\n",
    "                        if tmp_size >= last_buffer_size:\n",
    "                            # Increase buffer size\n",
    "                            new_buffer_size = last_buffer_size + BUFFER_SIZE\n",
    "                            new_idx = numpy.empty(new_buffer_size, dtype=numpy.int32)\n",
    "                            new_coef = numpy.zeros(new_buffer_size, dtype=numpy.float32)\n",
    "                            new_idx[:last_buffer_size] = tmp_idx\n",
    "                            new_idx[last_buffer_size:] = -1\n",
    "                            new_coef[:last_buffer_size] = tmp_coef\n",
    "                            last_buffer_size = new_buffer_size\n",
    "                            tmp_idx = new_idx\n",
    "                            tmp_coef = new_coef\n",
    "\n",
    "                        if tmp_idx[j] == idx:\n",
    "                            tmp_coef[j] += value\n",
    "                            break\n",
    "                        elif tmp_idx[j] < 0:\n",
    "                            tmp_idx[j] = idx\n",
    "                            tmp_coef[j] = value\n",
    "                            tmp_size += 1\n",
    "                            break\n",
    "        return tmp_idx[:tmp_size], tmp_coef[:tmp_size]\n",
    "\n",
    "    def calc_csr(self, sample):\n",
    "        \"\"\"Calculate the CSR matrix for the whole image\n",
    "        :param sample: Oversampling factor\n",
    "        :return: CSR matrix\n",
    "        \"\"\"\n",
    "        size = self.width * self.height\n",
    "        allocated_size = BLOCK_SIZE\n",
    "        idptr = numpy.zeros(size + 1, dtype=numpy.int32)\n",
    "        indices = numpy.zeros(allocated_size, dtype=numpy.int32)\n",
    "        data = numpy.zeros(allocated_size, dtype=numpy.float32)\n",
    "        self.sampled = sample * sample\n",
    "        pos = 0\n",
    "        start = 0\n",
    "        for row in range(self.height):\n",
    "            for col in range(self.width):\n",
    "                line_idx, line_coef = self.one_pixel(row, col, sample)\n",
    "                line_size = line_idx.size\n",
    "                if line_size == 0:\n",
    "                    new_size = 0\n",
    "                    pos += 1\n",
    "                    idptr[pos] = start\n",
    "                    continue\n",
    "\n",
    "                stop = start + line_size\n",
    "\n",
    "                if stop >= allocated_size:\n",
    "                    new_buffer_size = allocated_size + BLOCK_SIZE\n",
    "                    new_idx = numpy.zeros(new_buffer_size, dtype=numpy.int32)\n",
    "                    new_coef = numpy.zeros(new_buffer_size, dtype=numpy.float32)\n",
    "                    new_idx[:allocated_size] = indices\n",
    "                    new_coef[:allocated_size] = data\n",
    "                    allocated_size = new_buffer_size\n",
    "                    indices = new_idx\n",
    "                    data = new_coef\n",
    "\n",
    "                indices[start:stop] = line_idx\n",
    "                data[start:stop] = line_coef\n",
    "                pos += 1\n",
    "                idptr[pos] = stop\n",
    "                start = stop\n",
    "\n",
    "        last = idptr[-1]\n",
    "        self.data = data\n",
    "        self.indices = indices\n",
    "        self.idptr = idptr\n",
    "        return (self.data[:last] / self.sampled, indices[:last], idptr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.95 s, sys: 236 ms, total: 4.19 s\n",
      "Wall time: 4.2 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([0., 0., 0., ..., 0., 0., 0.], shape=(1902583,), dtype=float32),\n",
       " array([      2,       2,       4, ..., 1023180, 1023181, 1023182],\n",
       "       shape=(1902583,), dtype=int32),\n",
       " array([      0,       0,       0, ..., 1902581, 1902582, 1902583],\n",
       "       shape=(1023184,), dtype=int32))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nbthick = ThickDetector(\n",
    "    vox, voy, thickness=thickness, mu=mu, dist=dist, poni1=poni1, poni2=poni2, mask=mask\n",
    ")\n",
    "%time nbthick.calc_csr(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.68 s, sys: 7.78 ms, total: 3.69 s\n",
      "Wall time: 3.68 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([0.17449115, 0.10933631, 0.17465518, ..., 0.24611568, 0.03161056,\n",
       "        0.24604346], shape=(3410359,), dtype=float32),\n",
       " array([      2,       2,       3, ..., 1023181, 1023182, 1023182],\n",
       "       shape=(3410359,), dtype=int32),\n",
       " array([      0,       0,       0, ..., 3410356, 3410358, 3410359],\n",
       "       shape=(1023184,), dtype=int32))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%time nbthick.calc_csr(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Same implementation using Cython\n",
    "\n",
    "Cython is an ahead of time compiler for Python code. Thus it requires a compiler (gcc, msvc, ...) needs to be installed on your computer and available. This is usually already the case under linux but requires some work under windows or macos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython --compile-args=-fopenmp --link-args=-fopenmp \n",
    "#cython: embedsignature=True, language_level=3, binding=True\n",
    "#cython: boundscheck=False, wraparound=False, cdivision=True, initializedcheck=False,\n",
    "## This is for developping:\n",
    "## cython: profile=True, warn.undeclared=True, warn.unused=True, warn.unused_result=False, warn.unused_arg=True\n",
    "##\n",
    "\n",
    "import cython\n",
    "import numpy\n",
    "from libc.math cimport sqrt, exp\n",
    "from cython.parallel import prange\n",
    "from libc.stdint cimport int8_t, uint8_t, int16_t, uint16_t, \\\n",
    "                         int32_t, uint32_t, int64_t, uint64_t\n",
    "\n",
    "ctypedef double float64_t\n",
    "ctypedef float float32_t\n",
    "\n",
    "cdef int32_t BUFFER_SIZE = 16\n",
    "cdef float64_t BIG = numpy.finfo(numpy.float32).max\n",
    "\n",
    "\n",
    "cdef class CythonThickDetector:\n",
    "    \"Calculate the point spread function as function of the geometry of the experiment\"\n",
    "    cdef:\n",
    "        public float64_t vox\n",
    "        public float64_t voy\n",
    "        public float64_t voz\n",
    "        public float64_t mu\n",
    "        public float64_t dist\n",
    "        public float64_t poni1\n",
    "        public float64_t poni2\n",
    "        public int oversampling\n",
    "        public int buffer_size\n",
    "        public int width\n",
    "        public int height\n",
    "        public int size\n",
    "        public int8_t[:, ::1] mask\n",
    "    \n",
    "    def __init__(self, \n",
    "                 float64_t vox, \n",
    "                 float64_t voy, \n",
    "                 float64_t thickness, \n",
    "                 mask, \n",
    "                 float64_t mu, \n",
    "                 float64_t dist, \n",
    "                 float64_t poni1, \n",
    "                 float64_t poni2,\n",
    "                 int buffer_size=BUFFER_SIZE):\n",
    "        \"\"\"Constructor of the class:\n",
    "        \n",
    "        :param vox, voy: detector pixel size in the plane\n",
    "        :param thickness: thickness of the sensor in meters\n",
    "        :param mask: \n",
    "        :param mu: absorption coefficient of the sensor material\n",
    "        :param dist: sample detector distance as defined in the geometry-file\n",
    "        :param poni1, poni2: coordinates of the PONI as defined in the geometry \n",
    "        \"\"\"\n",
    "        self.vox = float(vox)\n",
    "        self.voy = float(voy)\n",
    "        self.voz = float(thickness)\n",
    "        self.mu = float(mu)\n",
    "        self.dist = float(dist)\n",
    "        self.poni1 = float(poni1)\n",
    "        self.poni2 = float(poni2)\n",
    "        self.width = int(mask.shape[1])\n",
    "        self.height = int(mask.shape[0])\n",
    "        self.size = self.width*self.height\n",
    "        self.mask = numpy.ascontiguousarray(mask, numpy.int8)\n",
    "        self.oversampling = 1\n",
    "        self.buffer_size = int(buffer_size)\n",
    "                \n",
    "    def calc_one_ray(self, entx, enty):\n",
    "        \"\"\"For a ray entering at position (entx, enty), with a propagation vector (kx, ky,kz),\n",
    "        calculate the length spent in every voxel where energy is deposited from a bunch of photons entering the detector \n",
    "        at a given position and and how much energy they deposit in each voxel. \n",
    "\n",
    "        Direct implementation of http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.42.3443&rep=rep1&type=pdf\n",
    "\n",
    "        :param entx, enty: coordinate of the entry point in meter (2 components, x,y)\n",
    "        :return: coordinates voxels in x, y and length crossed when leaving the associated voxel\n",
    "        \"\"\"\n",
    "        \n",
    "        cdef:\n",
    "            int last_id\n",
    "            float64_t _entx = float(entx)\n",
    "            float64_t _enty = float(enty)\n",
    "            int32_t[::1] array_x = numpy.empty(self.buffer_size, dtype=numpy.int32)\n",
    "            int32_t[::1] array_y = numpy.empty(self.buffer_size, dtype=numpy.int32)\n",
    "            float32_t[::1] array_len = numpy.empty(self.buffer_size, dtype=numpy.float32)\n",
    "        with nogil: \n",
    "            last_id = self._calc_one_ray(_entx, _enty, \n",
    "                                         array_x, array_y, array_len)\n",
    "        if last_id>self.buffer_size:\n",
    "            raise RuntimeError(f\"Temporary buffer size ({last_id}) larger than expected ({self.buffer_size})\")\n",
    "        return (numpy.asarray(array_x[:last_id]), \n",
    "                numpy.asarray(array_y[:last_id]), \n",
    "                numpy.asarray(array_len[:last_id]))\n",
    "        \n",
    "    cdef int _calc_one_ray(self, \n",
    "                           float64_t entx, \n",
    "                           float64_t enty,\n",
    "                           int32_t[::1] array_x,\n",
    "                           int32_t[::1] array_y,\n",
    "                           float32_t[::1] array_len\n",
    "                          )noexcept nogil:\n",
    "        \"\"\"Return number of entries in the array_x[:last_id], array_y[:last_id], array_len[:last_id]\"\"\"\n",
    "        cdef:\n",
    "            float64_t kx, ky, kz, n, t_max_x, t_max_y, t_max_z, t_delta_x, t_delta_y#, t_delta_z\n",
    "            int step_X, step_Y, X, Y, last_id\n",
    "            bint finished\n",
    "\n",
    "        # reset arrays\n",
    "        array_x[:] = -1\n",
    "        array_y[:] = -1\n",
    "        array_len[:] = 0.0\n",
    "\n",
    "        # normalize the input propagation vector\n",
    "        kx = entx - self.poni2\n",
    "        ky = enty - self.poni1\n",
    "        kz = self.dist\n",
    "        n = sqrt(kx*kx + ky*ky + kz*kz)\n",
    "        kx /= n\n",
    "        ky /= n\n",
    "        kz /= n\n",
    "\n",
    "        step_X = -1 if kx<0.0 else 1\n",
    "        step_Y = -1 if ky<0.0 else 1\n",
    "\n",
    "        X = int(entx/self.vox)\n",
    "        Y = int(enty/self.voy)\n",
    "\n",
    "        if kx>0.0:\n",
    "            t_max_x = ((entx//self.vox+1)*(self.vox)-entx)/ kx\n",
    "        elif kx<0.0:\n",
    "            t_max_x = ((entx//self.vox)*(self.vox)-entx)/ kx\n",
    "        else:\n",
    "            t_max_x = BIG\n",
    "\n",
    "        if ky>0.0:\n",
    "            t_max_y = ((enty//self.voy+1)*(self.voy)-enty)/ ky\n",
    "        elif ky<0.0:\n",
    "            t_max_y = ((enty//self.voy)*(self.voy)-enty)/ ky\n",
    "        else:\n",
    "            t_max_y = BIG\n",
    "\n",
    "        #Only one case for z as the ray is travelling in one direction only\n",
    "        t_max_z = self.voz / kz\n",
    "\n",
    "        t_delta_x = abs(self.vox/kx) if kx!=0 else BIG\n",
    "        t_delta_y = abs(self.voy/ky) if ky!=0 else BIG\n",
    "        # t_delta_z = self.voz/kz\n",
    "\n",
    "        finished = False\n",
    "        last_id = 0\n",
    "        array_x[last_id] = X\n",
    "        array_y[last_id] = Y\n",
    "\n",
    "        while not finished:\n",
    "            if t_max_x < t_max_y:\n",
    "                if t_max_x < t_max_z:\n",
    "                    array_len[last_id] = t_max_x\n",
    "                    last_id = last_id + 1\n",
    "                    X = X + step_X\n",
    "                    array_x[last_id] = X\n",
    "                    array_y[last_id] = Y\n",
    "                    t_max_x = t_max_x + t_delta_x\n",
    "                else:\n",
    "                    array_len[last_id] = t_max_z\n",
    "                    last_id = last_id + 1\n",
    "                    finished = True\n",
    "            else:\n",
    "                if t_max_y < t_max_z:\n",
    "                    array_len[last_id] = t_max_y\n",
    "                    last_id = last_id +1\n",
    "                    Y = Y + step_Y\n",
    "                    array_x[last_id] = X\n",
    "                    array_y[last_id] = Y                \n",
    "                    t_max_y = t_max_y + t_delta_y\n",
    "                else:\n",
    "                    array_len[last_id] = t_max_z\n",
    "                    last_id = last_id +1\n",
    "                    finished = True\n",
    "            if last_id>=self.buffer_size:\n",
    "                return self.buffer_size\n",
    "        return last_id\n",
    "\n",
    "\n",
    "    def one_pixel(self, row, col, sample=0):\n",
    "        \"\"\"calculate the contribution of one pixel to the sparse matrix and populate it.\n",
    "\n",
    "        :param row: row index of the pixel of interest\n",
    "        :param col: column index of the pixel of interest\n",
    "        :param sample: Oversampling rate, 10 will cast 10x10 ray per pixel\n",
    "        \"\"\"\n",
    "        cdef:\n",
    "            int entries = 0\n",
    "            int _row = int(row)\n",
    "            int _col = int(col) \n",
    "            int32_t[::1] tmp_idx = numpy.empty(self.buffer_size, dtype=numpy.int32)\n",
    "            float32_t[::1] tmp_coef = numpy.empty(self.buffer_size, dtype=numpy.float32)\n",
    "            int32_t[::1] array_x = numpy.empty(self.buffer_size, dtype=numpy.int32)\n",
    "            int32_t[::1] array_y = numpy.empty(self.buffer_size, dtype=numpy.int32)\n",
    "            float32_t[::1] array_len = numpy.empty(self.buffer_size, dtype=numpy.float32)\n",
    "\n",
    "        if  sample:\n",
    "            self.oversampling = sample\n",
    "        with nogil:\n",
    "            entries = self._one_pixel(_row, _col, tmp_idx, tmp_coef, array_x, array_y, array_len)\n",
    "        if entries<self.buffer_size:\n",
    "            return (numpy.asarray(tmp_idx)[:entries],numpy.asarray(tmp_coef)[:entries])\n",
    "        else:\n",
    "            raise RuntimeError(f\"Pixel produced {entries} voxels, limited to {self.buffer_size}. Increase Buffer size ! in constructor\")\n",
    "\n",
    "    cdef int _one_pixel(self, int row, int col,\n",
    "                       int32_t[::1] tmp_idx,\n",
    "                       float32_t[::1] tmp_coef,\n",
    "                       int32_t[::1] array_x,\n",
    "                       int32_t[::1] array_y,\n",
    "                       float32_t[::1] array_len\n",
    "                    )noexcept nogil:\n",
    "        \"return the number of elements in tmp_idx/tmp_coef which are to be used\"\n",
    "        \n",
    "        cdef:\n",
    "            int i, j, tmp_size, last_buffer_size, n, x, y, idx\n",
    "            float64_t rem, l, posx, posy, value, dos\n",
    "\n",
    "        if self.mask[row, col]:\n",
    "            return 0\n",
    "\n",
    "        tmp_size = 0\n",
    "        last_buffer_size = tmp_idx.shape[0]\n",
    "        tmp_idx[:] = -1\n",
    "        tmp_coef[:] = 0.0\n",
    "\n",
    "        for i in range(self.oversampling):\n",
    "            posx = (col+1.0*i/self.oversampling)*self.vox\n",
    "            for j in range(self.oversampling):\n",
    "                posy = (row+1.0*j/self.oversampling)*self.voy\n",
    "                n = self._calc_one_ray(posx, posy, array_x, array_y, array_len)\n",
    "                rem = 1.0\n",
    "                for i in range(min(n, self.buffer_size)):\n",
    "                    x = array_x[i]\n",
    "                    y = array_y[i]\n",
    "                    l = array_len[i]\n",
    "                    if (x<0) or (y<0) or (y>=self.height) or (x>=self.width):\n",
    "                        break\n",
    "                    elif (self.mask[y, x]):\n",
    "                        continue\n",
    "                    idx = x + y*self.width\n",
    "                    dos = exp(-self.mu*l)\n",
    "                    value = rem - dos\n",
    "                    rem = dos\n",
    "                    for j in range(self.buffer_size):                        \n",
    "                        if tmp_idx[j] == idx:\n",
    "                            tmp_coef[j] = tmp_coef[j] + value\n",
    "                            break\n",
    "                        elif tmp_idx[j] < 0:\n",
    "                            tmp_idx[j] = idx\n",
    "                            tmp_coef[j] = value\n",
    "                            tmp_size = tmp_size + 1\n",
    "                            break\n",
    "                    if tmp_size >= self.buffer_size:\n",
    "                            break\n",
    "        return tmp_size\n",
    "\n",
    "    def calc_csr(self, sample=0, int threads=0):\n",
    "        \"\"\"Calculate the content of the sparse matrix for the whole image\n",
    "        :param sample: Oversampling factor\n",
    "        :param threads: number of threads to be used\n",
    "        :return: spase matrix?\n",
    "        \"\"\"\n",
    "        cdef:\n",
    "            int pos, i, current, next, size\n",
    "            int32_t[::1] sizes, indptr = numpy.zeros(self.size+1, dtype=numpy.int32)\n",
    "            int32_t[:, ::1] indices\n",
    "            float32_t[:, ::1] data\n",
    "            int32_t[::1] csr_indices\n",
    "            float32_t[::1] csr_data\n",
    "            int32_t[:, ::1] array_x\n",
    "            int32_t[:, ::1] array_y\n",
    "            float32_t[:, ::1] array_len\n",
    "\n",
    "        if sample:\n",
    "            self.oversampling = sample\n",
    "        self.oversampling = sample\n",
    "        data = numpy.zeros((self.size, self.buffer_size), dtype=numpy.float32)\n",
    "        indices = numpy.zeros((self.size, self.buffer_size),dtype=numpy.int32)\n",
    "        sizes = numpy.zeros(self.size, dtype=numpy.int32)\n",
    "\n",
    "        #single threaded version:\n",
    "        array_x = numpy.empty((self.size, self.buffer_size), dtype=numpy.int32)\n",
    "        array_y = numpy.empty((self.size, self.buffer_size), dtype=numpy.int32)\n",
    "        array_len = numpy.empty((self.size, self.buffer_size), dtype=numpy.float32)\n",
    "\n",
    "        for pos in prange(self.size, num_threads=threads, nogil=True):\n",
    "            size = sizes[pos] = self._one_pixel(pos//self.width, pos%self.width, \n",
    "                                             indices[pos], data[pos], \n",
    "                                             array_x[pos], array_y[pos], array_len[pos])\n",
    "        size = numpy.sum(sizes)\n",
    "        csr_indices = numpy.empty(size, numpy.int32)\n",
    "        csr_data = numpy.empty(size, numpy.float32)\n",
    "        current = 0\n",
    "        for i in range(self.size):\n",
    "            size = sizes[i]\n",
    "            next = current + size\n",
    "            indptr[i+1] = next\n",
    "            csr_indices[current:next] = indices[i,:size]\n",
    "            csr_data[current:next] = data[i,:size]\n",
    "            current = next\n",
    "        return (numpy.asarray(csr_data)/(self.oversampling*self.oversampling), \n",
    "                numpy.asarray(csr_indices), \n",
    "                numpy.asarray(indptr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance of Cython implementation:\n",
      "CPU times: user 1.01 s, sys: 47.9 ms, total: 1.05 s\n",
      "Wall time: 1.05 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([0.17449115, 0.10933631, 0.17465518, ..., 0.35667214, 0.05905784,\n",
       "        0.35653958], shape=(3328700,), dtype=float32),\n",
       " array([      2,       2,       3, ..., 1023181, 1023182, 1023182],\n",
       "       shape=(3328700,), dtype=int32),\n",
       " array([      0,       0,       0, ..., 3328697, 3328699, 3328700],\n",
       "       shape=(1023184,), dtype=int32))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cythick = CythonThickDetector(\n",
    "    172e-6,\n",
    "    172e-6,\n",
    "    thickness=thickness,\n",
    "    mu=mu,\n",
    "    dist=dist,\n",
    "    poni1=poni1,\n",
    "    poni2=poni2,\n",
    "    mask=mask,\n",
    ")\n",
    "print(\"Performance of Cython implementation:\")\n",
    "%time cythick.calc_csr(4, threads=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance of Numba implementation:\n",
      "CPU times: user 3.65 s, sys: 28 ms, total: 3.68 s\n",
      "Wall time: 3.67 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([0.17449115, 0.10933631, 0.17465518, ..., 0.24611568, 0.03161056,\n",
       "        0.24604346], shape=(3410359,), dtype=float32),\n",
       " array([      2,       2,       3, ..., 1023181, 1023182, 1023182],\n",
       "       shape=(3410359,), dtype=int32),\n",
       " array([      0,       0,       0, ..., 3410356, 3410358, 3410359],\n",
       "       shape=(1023184,), dtype=int32))"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparison with Numba, Cython is usually slightly faster\n",
    "print(\"Performance of Numba implementation:\")\n",
    "%time nbthick.calc_csr(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validation of the CSR matrix obtained:\n",
    "\n",
    "For this we will build a simple 2D image with one pixel in a regular grid and calculate the effect of the transformation calculated previously on it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 11.1 s, sys: 403 ms, total: 11.5 s\n",
      "Wall time: 358 ms\n"
     ]
    }
   ],
   "source": [
    "%time csr = csr_matrix(cythick.calc_csr(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dummy_image = numpy.ones(mask.shape, dtype=\"float32\")\n",
    "dummy_image[::5, ::5] = 10\n",
    "\n",
    "dummy_blurred = csr.T.dot(dummy_image.ravel()).reshape(mask.shape)\n",
    "fix, ax = subplots(2, 2, figsize=(8, 8))\n",
    "ax[0, 0].imshow(dummy_image)\n",
    "ax[0, 0].set_title(\"Original image\")\n",
    "ax[0, 1].imshow(dummy_blurred)\n",
    "ax[0, 1].set_title(\"Convolved image (i.e. blurred)\")\n",
    "ax[1, 1].imshow(csr.dot(dummy_blurred.ravel()).reshape(mask.shape))\n",
    "ax[1, 1].set_title(\"Retro-projected of the blurred\")\n",
    "ax[0, 0].set_xlim(964, 981)\n",
    "ax[0, 0].set_ylim(0, 16)\n",
    "ax[0, 1].set_xlim(964, 981)\n",
    "ax[0, 1].set_ylim(0, 16)\n",
    "ax[1, 1].set_xlim(964, 981)\n",
    "ax[1, 1].set_ylim(0, 16);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Least squares refinement of the pseudo-inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/users/kieffer/.venv/py313/lib/python3.13/site-packages/scipy/sparse/linalg/_isolve/lsmr.py:407: RuntimeWarning: overflow encountered in cast\n",
      "  condA = max(maxrbar, rhotemp) / min(minrbar, rhotemp)\n",
      "/users/kieffer/.venv/py313/lib/python3.13/site-packages/scipy/sparse/linalg/_isolve/lsmr.py:406: RuntimeWarning: overflow encountered in cast\n",
      "  minrbar = min(minrbar, rhobarold)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 26.8 s, sys: 4.04 ms, total: 26.8 s\n",
      "Wall time: 455 ms\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "blured = dummy_blurred.ravel()\n",
    "\n",
    "# Invert this matrix: see https://arxiv.org/abs/1006.0758\n",
    "\n",
    "%time res = linalg.lsmr(csr.T, blured)\n",
    "restored = res[0].reshape(mask.shape)\n",
    "\n",
    "fix, ax = subplots(2, 2, figsize=(8, 8))\n",
    "ax[0, 0].imshow(dummy_image)\n",
    "ax[0, 0].set_title(\"Original image\")\n",
    "ax[0, 1].imshow(dummy_blurred)\n",
    "ax[0, 1].set_title(\"Convolved image (i.e. blurred)\")\n",
    "ax[1, 1].imshow(csr.dot(dummy_blurred.ravel()).reshape(mask.shape))\n",
    "ax[1, 1].set_title(\"Retro-projected of the blurred\")\n",
    "ax[0, 0].set_xlim(964, 981)\n",
    "ax[0, 0].set_ylim(0, 16)\n",
    "ax[0, 1].set_xlim(964, 981)\n",
    "ax[0, 1].set_ylim(0, 16)\n",
    "ax[1, 1].set_xlim(964, 981)\n",
    "ax[1, 1].set_ylim(0, 16)\n",
    "ax[1, 0].imshow(restored)\n",
    "ax[1, 0].set_title(\"Restored LSMR\")\n",
    "ax[1, 0].set_xlim(964, 981)\n",
    "ax[1, 0].set_ylim(0, 16);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pseudo inverse with positivitiy constrain and poissonian noise (MLEM)\n",
    "\n",
    "The MLEM algorithm was initially developed within the framework of reconstruction of\n",
    "images in emission tomography [Shepp and Vardi, 1982], [Vardi et al., 1985], [Lange and\n",
    "Carson, 1984]. Nowadays, this algorithm is employed in numerous tomographic reconstruction\n",
    "problems and often associated to regularization techniques. It is based on the iterative\n",
    "maximization of the log-likelihood function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_3870469/3638533218.py:4: RuntimeWarning: divide by zero encountered in divide\n",
      "  norm = 1 / R.T.dot(numpy.ones_like(F))\n",
      "/tmp/ipykernel_3870469/3638533218.py:5: RuntimeWarning: invalid value encountered in divide\n",
      "  cor = R.T.dot(M / R.dot(F))\n",
      "/tmp/ipykernel_3870469/3638533218.py:6: RuntimeWarning: invalid value encountered in multiply\n",
      "  res = norm * F * cor\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1.7501588\n",
      "100 0.0014371872\n",
      "200 0.00016927719\n",
      "228 9.930134e-05\n",
      "CPU times: user 2.66 s, sys: 19.9 ms, total: 2.67 s\n",
      "Wall time: 2.67 s\n"
     ]
    }
   ],
   "source": [
    "def iterMLEM_scipy(F, M, R):\n",
    "    \"Implement one step of MLEM\"\n",
    "    # res = F * (R.T.dot(M))/R.dot(F)# / M.sum(axis=-1)\n",
    "    norm = 1 / R.T.dot(numpy.ones_like(F))\n",
    "    cor = R.T.dot(M / R.dot(F))\n",
    "    res = norm * F * cor\n",
    "    res[numpy.isnan(res)] = 1.0\n",
    "    return res\n",
    "\n",
    "\n",
    "def deconv_MLEM(csr, data, thres=0.2, maxiter=1000):\n",
    "    R = csr.T\n",
    "    msk = data < 0\n",
    "    img = data.astype(\"float32\")\n",
    "    img[msk] = 0.0  # set masked values to 0, negative values could induce errors\n",
    "    M = img.ravel()\n",
    "    # F0 = numpy.random.random(data.size)#M#\n",
    "    F0 = R.T.dot(M)\n",
    "    F1 = iterMLEM_scipy(F0, M, R)\n",
    "    delta = abs(F1 - F0).max()\n",
    "    for i in range(maxiter):\n",
    "        if delta < thres:\n",
    "            break\n",
    "        F2 = iterMLEM_scipy(F1, M, R)\n",
    "        delta = abs(F1 - F2).max()\n",
    "        if i % 100 == 0:\n",
    "            print(i, delta)\n",
    "        F1 = F2\n",
    "        i += 1\n",
    "    print(i, delta)\n",
    "    return F2.reshape(img.shape)\n",
    "\n",
    "\n",
    "%time res = deconv_MLEM(csr, dummy_blurred, 1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fix, ax = subplots(2, 2, figsize=(8, 8))\n",
    "ax[0, 0].imshow(dummy_image)\n",
    "ax[0, 1].imshow(dummy_blurred)\n",
    "ax[1, 1].imshow(csr.dot(dummy_blurred.ravel()).reshape(mask.shape))\n",
    "ax[0, 0].set_xlim(964, 981)\n",
    "ax[0, 0].set_ylim(0, 16)\n",
    "ax[0, 0].set_title(\"Original image\")\n",
    "ax[0, 1].set_xlim(964, 981)\n",
    "ax[0, 1].set_ylim(0, 16)\n",
    "ax[0, 1].set_title(\"Convolved image (i.e. blurred)\")\n",
    "ax[1, 1].set_xlim(964, 981)\n",
    "ax[1, 1].set_ylim(0, 16)\n",
    "ax[1, 1].set_title(\"Retro-projected of the blurred\")\n",
    "# ax[1,0].set_title(\"Corrected image\");\n",
    "ax[1, 0].imshow(res)\n",
    "ax[1, 0].set_xlim(964, 981)\n",
    "ax[1, 0].set_ylim(0, 16)\n",
    "ax[1, 0].set_title(\"Corrected image: MLEM\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance measurements ... multi-threaded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1 threads: 3.47 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "  2 threads: 1.87 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "  4 threads: 1.07 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "  8 threads: 679 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      " 16 threads: 516 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      " 32 threads: 392 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      " 64 threads: 325 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "128 threads: 312 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "perfs = {}\n",
    "for i in range(8):\n",
    "    j = 1 << i\n",
    "    print(f\"{j:3d} threads: \", end=\"\")\n",
    "    perfs[(j, cythick.buffer_size)] = %timeit -o -n1 -r1 cythick.calc_csr(8, threads=j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1 threads: 3.55 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "  2 threads: 1.93 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "  4 threads: 1.1 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "  8 threads: 685 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      " 16 threads: 532 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      " 32 threads: 402 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      " 64 threads: 347 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "128 threads: 337 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "buf = 32\n",
    "cythick = CythonThickDetector(\n",
    "    172e-6,\n",
    "    172e-6,\n",
    "    thickness=thickness,\n",
    "    mu=mu,\n",
    "    dist=dist,\n",
    "    poni1=poni1,\n",
    "    poni2=poni2,\n",
    "    mask=mask,\n",
    "    buffer_size=buf,\n",
    ")\n",
    "cythick.calc_csr(1)\n",
    "for i in range(8):\n",
    "    j = 1 << i\n",
    "    print(f\"{j:3d} threads: \", end=\"\")\n",
    "    perfs[(j, cythick.buffer_size)] = %timeit -o -n1 -r1 cythick.calc_csr(8, threads=j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "    \n",
    "fig, ax = subplots(1,2, figsize=(12,6))\n",
    "t = [i[0] for i in perfs if i[1] == 16]\n",
    "y16 = [v.best for k,v in perfs.items() if k[1] == 16]\n",
    "y32 = [v.best for k,v in perfs.items() if k[1] == 32]\n",
    "p16 = [8e-6*cythick.size/v.best for k,v in perfs.items() if k[1] == 16]\n",
    "p32 = [8e-6*cythick.size/v.best for k,v in perfs.items() if k[1] == 32]\n",
    "ax[0].plot(t, y16, label=\"16 voxel/ray buffer\")\n",
    "ax[0].plot(t, y32, label=\"32 voxel/ray buffer\")\n",
    "ax[0].set_title(\"Execution time\")\n",
    "ax[0].set_xlabel(\"Number of threads\")\n",
    "ax[0].set_ylabel(\"Runtime (s)\")\n",
    "ax[1].plot(t, p16, label=\"16 voxel/ray\")\n",
    "ax[1].plot(t, p32, label=\"32 voxel/ray\")\n",
    "ax[1].set_xlabel(\"Number of threads\")\n",
    "ax[1].set_ylabel(\"Millions of rays per second\")\n",
    "ax[1].set_title(cpu)\n",
    "ax[0].legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion of the raytracing part:\n",
    "\n",
    "We are able to simulate the path and the absorption of the photon in the thickness of the detector. \n",
    "Numba/Cython helped substentially to make the raytracing calculation much faster. \n",
    "The signal of each pixel is indeed spread on the neighboors, depending on the position of the PONI and this effect can be inverted using sparse-matrix pseudo-inversion. \n",
    "The MLEM can garanteee that the total signal is conserved and that no pixel gets negative value.\n",
    "\n",
    "We will now save this sparse matrix to file in order to be able to re-use it in next notebook. But before saving it, it makes sense to spend some time in generating a high quality sparse matrix in throwing thousand rays per pixel in a grid of 64x64 (4 billions rays launched)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 20min 57s, sys: 961 ms, total: 20min 58s\n",
      "Wall time: 22.7 s\n"
     ]
    }
   ],
   "source": [
    "%time pre_csr = cythick.calc_csr(128, threads=os.cpu_count())\n",
    "hq_csr = csr_matrix(pre_csr)\n",
    "save_npz(\"csr.npz\", hq_csr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total execution time: 61.854 s\n"
     ]
    }
   ],
   "source": [
    "print(f\"Total execution time: {time.perf_counter() - start_time:.3f} s\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}