numerical_simulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<div align=center>\n",
    "\n",
    "# 📜 **Abstract**\n",
    "\n",
    "</div>\n",
    "\n",
    "Nulling interferometry $^1$ is a promising technique for direct detection of exoplanets. However, the performance of current devices is limited by the sensitivity to any phase aberrations. The work presented here attempts to overcome those limitations by using a four-telescopes nulling interferometer architecture, called Kernel-Nuller $^2$, which includes a recombiner that positions the four signals in phase quadrature. This architecture is based on an integrated optical component containing 14 electronically controlled phase shifters, used to correct optical path differences that would be induced by manufacturing defects. The first part of the study consists in the development of an algorithm providing the delays to be injected into the component to optimize the performance of that device. The next step of this study deals with the analysis of the intensity distributions produced at the output of the Kernel-Nuller $^{2,3}$ through a series of observations, and then apply statistical tests and data treatment techniques to detect the presence of exoplanets.\n",
    "\n",
    "> **References**\n",
    "> 1. Bracewell, R.N., MacPhie, R.H., 1979. Searching for nonsolar planets. Icarus 38, 136–147. https://doi.org/10.1016/0019-1035(79)90093-9\n",
    "> 2. Martinache, F., Ireland, M.J., 2018. Kernel-nulling for a robust direct interferometric detection of extrasolar planets. A&A 619, A87. https://doi.org/10.1051/0004-6361/201832847\n",
    "> 3. Cvetojevic, N. et al., 2022. 3-beam self-calibrated Kernel nulling photonic interferometer. arXiv e-prints. https://doi.org/10.48550/arXiv.2206.04977\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<div align=center>\n",
    "\n",
    "# **🖥️ Simulation requirements**\n",
    "\n",
    "</div>\n",
    "\n",
    "## 📥 Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from io import BytesIO\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['image.origin'] = 'lower'\n",
    "import astropy.units as u\n",
    "import astropy.constants as const\n",
    "import ipywidgets as widgets\n",
    "from IPython.display import clear_output, display\n",
    "import sympy as sp\n",
    "import fitter\n",
    "import numba as nb\n",
    "from scipy.optimize import curve_fit\n",
    "from scipy.ndimage import rotate\n",
    "from LRFutils import color\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🎛️ Parameters\n",
    "\n",
    "<div align=center>\n",
    "👉 <i><U>Only edit the following block</u></i>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wavelength\n",
    "L = 1.65 * u.um\n",
    "\n",
    "# Telescopes properties\n",
    "TELESCOPE_POSITIONS = np.array([\n",
    "    [0, 0],\n",
    "    [1, 1],\n",
    "    [2, 1.5],\n",
    "    [3, 0.7],\n",
    "]) * 42.2 * u.m\n",
    "LATITUDE = -24.6275 * u.deg\n",
    "DECLINATION = -64.71 * u.deg\n",
    "FOV = 10 * u.mas # Field of view\n",
    "\n",
    "# Observation conditions\n",
    "STAR_MAGNITUDE = 0 * u.mag\n",
    "SPECTRAL_WIDTH = 0.3 * u.um\n",
    "OPTICAL_EFFICIENCY = 0.01\n",
    "DH = 8 * u.hourangle # Observation duration\n",
    "DT = 1 * u.s # Exposure time\n",
    "\n",
    "# Companions properties\n",
    "COMPANIONS = [\n",
    "    {'contrast':1e-3, 'angular_separation':5.23 * u.mas, 'parallactic_angle':49.68 * u.deg},\n",
    "    {'contrast':1e-3, 'angular_separation':7 * u.mas, 'parallactic_angle':-25 * u.deg},\n",
    "    {'contrast':1e-3, 'angular_separation':3 * u.mas, 'parallactic_angle':141 * u.deg},\n",
    "]\n",
    "\n",
    "# Cophasing errors\n",
    "INPUT_CE_RMS = 10 * u.nm # ~100 nm for ground based telescopes, 10 to 1 nm for space telescopes\n",
    "SHIFTS_CE_RMS = 10 * u.nm\n",
    "SHIFTS_CE_OFFSET = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) * u.nm\n",
    "\n",
    "# SHIFTS_CE_OFFSET = np.array([1.64214688, 1.64216085, 0.00554631, 1.64884721, 1.62784278, 0.03160111, 0.0182902, 0.02791266, 0.01329669, 0.01020052, 1.63187602, 1.64524911, 0.02049508, 0.0165746]) * L.unit\n",
    "# SHIFTS_CE_RMS = L*0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Processing parameters (conversion to commonly used units)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "TELESCOPE_POSITIONS = TELESCOPE_POSITIONS.to(u.m)\n",
    "LATITUDE = LATITUDE.to(u.deg)\n",
    "DECLINATION = DECLINATION.to(u.deg)\n",
    "INPUT_CE_RMS = INPUT_CE_RMS.to(L.unit)\n",
    "SHIFTS_CE_RMS = SHIFTS_CE_RMS.to(L.unit)\n",
    "SHIFTS_CE_OFFSET = SHIFTS_CE_OFFSET.to(L.unit)\n",
    "PARALLACTIC_ANGLE_RANGE = np.linspace(0,2*np.pi,360)*u.rad\n",
    "EXTENT = (-FOV.value, FOV.value, -FOV.value, FOV.value)\n",
    "H_RANGE = np.linspace(-DH/2, DH/2, 100)\n",
    "FOV = FOV.to(u.mas)\n",
    "for companion in COMPANIONS:\n",
    "    companion['angular_separation'] = companion['angular_separation'].to(u.mas)\n",
    "    companion['parallactic_angle'] = companion['parallactic_angle'].to(u.rad)\n",
    "π = np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🔧 Utils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We only consider relative phases, so we only consider phase shift in `[0,wavelenght[`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bound_phase(δφ:u.Quantity, λ:u.Quantity=L) -> u.Quantity:\n",
    "    \"\"\"Bring a phase to the interval [0, wavelenght[.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - δφ: Phase to bound (any distance unit)\n",
    "    - λ: Wavelenght of the light (any distance unit)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Phase in the interval [0, wavelenght]\n",
    "    \"\"\"\n",
    "    return bound_phase_njit(δφ.value, λ.to(δφ.unit).value) * δφ.unit\n",
    "\n",
    "@nb.njit()\n",
    "def bound_phase_njit(\n",
    "        δφ:float,\n",
    "        λ:float=L.value,\n",
    "    ) -> float:\n",
    "    \"\"\"Bring a phase to the interval [0, wavelenght[.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - δφ: Phase to bound (in distance unit)\n",
    "    - λ: Wavelenght of the light (same unit as phase) \n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Phase in the interval [0, wavelenght]\n",
    "    \"\"\"\n",
    "    return np.mod(δφ, λ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<div align=center>\n",
    "\n",
    "# 🤔 **Context**\n",
    "\n",
    "</div>\n",
    "\n",
    "## 🎯 Goal\n",
    "\n",
    "We aim to detect make direct detection of exoplanets. There is two main challenges to achieve this goal:\n",
    "- The **contrast**: the exoplanet is much fainter than the star it orbits. The contrast is typically of the order of $10^{-6}$ to $10^{-10}$.\n",
    "- The **angular separation**: the exoplanet is very close to the star. The angular separation depend on the distance of the exoplanet to the star and the distance of the star to the observer and can easily goes below the arcsecond."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🔎 Detection methods\n",
    "\n",
    "It exist several methods to detect exoplanets. The most common are:\n",
    "- **Radial velocity method**: the exoplanet induce a wobble in the star it orbits. This wobble can be detected by the Doppler effect (the light is alternatively redshifted and blueshifted).\n",
    "- **Transit method**: the exoplanet pass in front of the star and block a fraction of the light. This fraction can be detected by the decrease of the star luminosity.\n",
    "- **Microlensing**: the exoplanet act as a lens and magnify the light of a background star. This magnification can be detected by the increase of the star luminosity.\n",
    "- **Astrometry**: the exoplanet induce a wobble in the star it orbits. This wobble can be detected by the change of the star position.\n",
    "- **Coronography**: the exoplanet is directly imaged. This is the most challenging method because of the contrast and the angular separation.\n",
    "\n",
    "<div align=center>\n",
    "<img src=\"img/detection_methods.jpg\" width=500px>\n",
    "<p><i>Paul Anthony Wilson - Exoplanet detection techniques</i><p>\n",
    "</div>\n",
    "\n",
    "Until now, the coronography was the only method allowing direct detection. But it has two main limitations:\n",
    "- It require huge telescopes in order to have a good angular resolution.\n",
    "- The contrast we can achieve is limited by unperfect fabrication process of the optical components which lead to undesired diffraction effects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ➖ Nulling\n",
    "\n",
    "This is where the Nulling technic $^1$ come into play. The idea is to use two several telescopes and take advantage of destructives interferances to cancel the star light and using the fact that the planet is not perfectly in the line of sight, which will lead to an unperfect destructive interference, or in best scenarios, on constructive ones! This is a very challenging technic because it is highly phase sensitive and require a very good control of the optical path.\n",
    "\n",
    "<div align=center>\n",
    "<img src=\"img/nulling_principle.jpg\" width=500px>\n",
    "</div>\n",
    "\n",
    "In a perfect 2-telescope nulling system, we can express the two acquired electric field (cf. section \"Signal nature\" below) in a vector:\n",
    "\n",
    "$$\n",
    "E = \\begin{pmatrix}\n",
    "E_1 \\\\\n",
    "E_2\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "And then express the nulling operation using the following matrix:\n",
    "\n",
    "$$\n",
    "N = \\begin{pmatrix}\n",
    "1 & 1 \\\\\n",
    "1 & -1\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "Such as it gives us two outputs with a constructive and a destructive interference (we will focus on the latter):\n",
    "\n",
    "$$\n",
    "N \\cdot E = \\begin{pmatrix}\n",
    "E_1 + E_2 \\\\\n",
    "E_1 - E_2\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "> **References**\n",
    "> 1. Bracewell, R.N., MacPhie, R.H., 1979. Searching for nonsolar planets. Icarus 38, 136–147. https://doi.org/10.1016/0019-1035(79)90093-9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2x2 nuller\n",
    "\n",
    "@nb.njit()\n",
    "def nuller_2x2(beams:np.ndarray[complex]) -> np.ndarray[complex]:\n",
    "    \"\"\"\n",
    "    Simulate a 2 input beam nuller.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - beams: Array of 2 input beams complex amplitudes\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of 2 output beams complex amplitudes\n",
    "        - 1st output is the bright channel\n",
    "        - 2nd output is the dark channel\n",
    "    \"\"\"\n",
    "\n",
    "    # Nuller matrix\n",
    "    N = 1/np.sqrt(2) * np.array([\n",
    "        [1,   1],\n",
    "        [1,  -1],\n",
    "    ], dtype=np.complex128)\n",
    "\n",
    "    # Operation\n",
    "    return N @ beams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📡 Projected telescope position\n",
    "\n",
    "The interferometry process depend on the projected geometry of the telescope position in the plane perpendicular to the line of sight. For each observation, we will then need to compute these projected positions in order to have the correct baseline lenght (and thus the correct phase shifts).\\\n",
    "These projected location can be computed using the following formula $^{1,2}$:\n",
    "\n",
    "$$\n",
    "\\begin{pmatrix}\n",
    "u \\\\\n",
    "v\n",
    "\\end{pmatrix} =\n",
    "\\begin{pmatrix}\n",
    "- \\sin(l) \\sin(h) & \\cos(h)\\\\\n",
    "\\sin(l) \\cos(h) \\sin(\\delta) + \\cos(l) \\cos(\\delta) & \\sin(h) \\sin(\\delta)\n",
    "\\end{pmatrix}\n",
    "\\begin{pmatrix}\n",
    "B_\\text{north} \\\\\n",
    "B_\\text{east}\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "with\n",
    "- $l$ the latitude of the observatory\n",
    "- $h$ the hour angle\n",
    "- $\\delta$ the declination of the star\n",
    "\n",
    "> *Rerefence*\n",
    "> 1. Chingaipe, P.M. et al., 2023. High-contrast detection of exoplanets with a kernel-nuller at the VLTI. A&A 676, A43. https://doi.org/10.1051/0004-6361/202346118\n",
    "> 2. Ségransan, D., 2007. Observability and UV coverage. New Astronomy Reviews 51, 597–603. https://doi.org/10.1016/j.newar.2007.06.005"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ut_position():\n",
    "\n",
    "    # UT coordinates... obtained on Google map 😅 <- TODO: update with precise positions\n",
    "    UT_pos = np.array([\n",
    "        [-70.4048732988764, -24.627602893919807],\n",
    "        [-70.40465753243652, -24.627118902835786],\n",
    "        [-70.40439460074228, -24.62681028261176],\n",
    "        [-70.40384287956437, -24.627033500373024]\n",
    "    ]) # ⚠️ Expressed in [longitude, latitude] to easily convert to [x, y]\n",
    "    \n",
    "    # We are only interested in the relative positions of the UTs\n",
    "    # The first UT is the reference\n",
    "    UT_pos -= UT_pos[0]\n",
    "\n",
    "    # Altitude of the UTs\n",
    "    earth_radius = 6_378_137 * u.m\n",
    "    UTs_elevation = 2_635 * u.m\n",
    "\n",
    "    # Angle to distance conversion\n",
    "    return np.tan((UT_pos * u.deg).to(u.rad)) * (earth_radius + UTs_elevation)\n",
    "\n",
    "TELESCOPE_POSITIONS = get_ut_position()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\vince\\AppData\\Local\\Temp\\ipykernel_16212\\4009903173.py:30: NumbaPerformanceWarning: \u001b[1m\u001b[1m'@' is faster on contiguous arrays, called on (Array(float64, 2, 'C', False, aligned=True), Array(float64, 1, 'A', False, aligned=True))\u001b[0m\u001b[0m\n",
      "  p_projected[i] = M @ np.flip(pos)\n"
     ]
    }
   ],
   "source": [
    "@nb.njit()\n",
    "def project_position_njit(\n",
    "    p: np.ndarray[float] = TELESCOPE_POSITIONS.value,\n",
    "    h: float = 0,\n",
    "    l: float = LATITUDE.to(u.rad).value,\n",
    "    δ: float = DECLINATION.to(u.rad).value,\n",
    ") -> np.ndarray[float]:\n",
    "    \"\"\"\n",
    "    Project the telescope position in a plane perpendicular to the line of sight.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - p: Array of telescope positions\n",
    "    - h: Hour angle (in radian)\n",
    "    - l: Latitude (in radian)\n",
    "    - δ: Declination (in radian)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of projected telescope positions (same shape and unit as p)\n",
    "    \"\"\"\n",
    "\n",
    "    M = np.array([\n",
    "        [ -np.sin(l)*np.sin(h),                                np.cos(h)          ],\n",
    "        [ np.sin(l)*np.cos(h)*np.sin(δ) + np.cos(l)*np.cos(δ), np.sin(h)*np.sin(δ)],\n",
    "    ])\n",
    "\n",
    "    p_projected = np.empty_like(p)\n",
    "    for i, pos in enumerate(p):\n",
    "        p_projected[i] = M @ np.flip(pos)\n",
    "\n",
    "    return p_projected\n",
    "\n",
    "def project_position(\n",
    "    p: u.Quantity = TELESCOPE_POSITIONS,\n",
    "    h: u.Quantity = 0 * u.hourangle,\n",
    "    l: u.Quantity = LATITUDE,\n",
    "    δ: u.Quantity = DECLINATION,\n",
    ") -> u.Quantity:\n",
    "    \"\"\"\n",
    "    Project the telescope position in a plane perpendicular to the line of sight.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - p: Array of telescope positions\n",
    "    - h: Hour angle\n",
    "    - l: Latitude\n",
    "    - δ: Declination\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of projected telescope positions (same shape and unit as p)\n",
    "    \"\"\"\n",
    "    h = h.to(u.rad)\n",
    "    l = l.to(u.rad)\n",
    "    δ = δ.to(u.rad)\n",
    "    return project_position_njit(p.value, h, l, δ) * p.unit\n",
    "\n",
    "PROJECTED_TELESCOPE_POSITIONS = project_position()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAHHCAYAAADd3gN7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABdGElEQVR4nO3dd3wT9f8H8FeSNuluaOmE0sUoG2RUBBlStvhFAVlqy3SAyFCh+lUBRVQUUEAQkfFDkCFDAUG2iEyBCqjUUsospQi0oS10JJ/fH/nmIDS0aWl7SfN6Ph55tPfJ5e6dy3jl7j53pxBCCBAREVGxlHIXQEREZC8YmkRERFZiaBIREVmJoUlERGQlhiYREZGVGJpERERWYmgSERFZiaFJRERkJYYmERGRlWw2NMPCwhAXFyd3GSW2Z88eKBQK7Nmzp9znFRcXh7CwsHKfDxVtyZIlUCgUOHfuXLHjVuT7wxGZlu/3338vWw22+rlcvXo1fHx8kJWVVeLHTpo0CQqFAv/++2+p5m1LyyQ/Px8hISH48ssvS/X4EoWm6cvBdHNxcUHt2rUxatQoXL16tVQFyOXDDz/Ehg0bZJv//v37MWnSJGRkZMhWA5WfL7/8EkuWLJG7jEprxYoVmDVrlmzzT01NxaRJk5CQkCBbDSWh1+vx3nvv4dVXX4WHh4fUbjAYMH/+fDRp0gQeHh4ICAhAt27dsH//fhmrLV/Ozs4YN24cpk6dijt37pT48aVa05wyZQqWLVuGOXPm4LHHHsO8efPQqlUr5OTklGZyFiUmJuLrr78us+ndzxZCc/LkyQzNSuD555/H7du3ERoaKrU9KDTbtm2L27dvo23bthVYYeVjC6E5efJki6H59ddfIzExseKLKsLGjRuRmJiIESNGmLW/8cYbePnll9GwYUPMmDED48ePxz///IN27drh8OHDMlVb/gYPHox///0XK1asKPFjnUozw27duqF58+YAgGHDhsHX1xczZszADz/8gAEDBlh8THZ2Ntzd3a2eh0ajKU1pRBVOpVJBpVJZNa5SqYSLi0s5V2T/hBC4c+cOXF1d5S6lxJydneUuoZDFixejdevWqFatmtRWUFCAefPmoU+fPli2bJnU3rdvX0RERGD58uVo2bKlHOWWO61Wi86dO2PJkiUYMmRIiR5bJvs0n3jiCQBASkoKAOP2aw8PDyQnJ6N79+7w9PTEoEGDABjDc/z48QgJCYFGo0GdOnXw6aef4v6LrVjap5mRkYExY8ZIj61ZsyY+/vhjGAwGs/EMBgM+//xzNGzYEC4uLvDz80PXrl3x+++/AwAUCgWys7OxdOlSaVPzvfO6fPkyhgwZgoCAAGg0GtSvXx+LFi0q9LwvXbqEXr16wd3dHf7+/hg7dixyc3OLXV6TJk3CG2+8AQAIDw+Xarh3n9i3336LZs2awdXVFT4+Pujfvz8uXrxY7LQNBgNmzZqF+vXrw8XFBQEBAXjxxRdx8+ZNs/F+//13dOnSBVWrVoWrqyvCw8MLvXmKW46A8YP3/vvvIzIyEhqNBmFhYXjrrbcKLYewsDA8+eST2LZtG5o0aQIXFxfUq1cP69atK/QcrH2dLSnJfM6ePYu+ffvCx8cHbm5uePTRR7F58+ZC482ePRv169eHm5sbqlSpgubNm5v9Qr1/n2ZYWBj+/PNP/PLLL9Jr2759ewAP3qe5Zs0a6fWuWrUqnnvuOVy+fNlsHNPn6vLly+jVqxc8PDzg5+eH119/HXq93mzclStXolmzZvD09ISXlxcaNmyIzz//vNjlZ83ns0GDBujQoUOhxxoMBlSrVg19+vQxa7Pm/Wh63X7++Wc0b94crq6u+OqrryzW2L59e2zevBnnz5+Xlu/9+8sMBgOmTp2K6tWrw8XFBR07dsSZM2cKTevQoUPo2rUrvL294ebmhnbt2uG3334rchnt2bMHLVq0AGBcYzHVYNqycP/+u3PnzkGhUODTTz/F3LlzERERATc3N3Tu3BkXL16EEALvv/8+qlevDldXV/znP//BjRs3Cs13y5YtePzxx+Hu7g5PT0/06NEDf/75Z5G1AsCdO3ewdetWxMTEmLXn5+fj9u3bCAgIMGv39/eHUqm0+IMlIyMDcXFx0Gq18Pb2xuDBg0u9hdHaLFAoFBg1ahQ2bNiABg0aSN/JW7duLTTNPXv2oHnz5nBxcUFkZCS++uoraX/s/Tp16oR9+/ZZXNZFEiWwePFiAUAcOXLErP3zzz8XAMT8+fOFEELExsYKjUYjIiMjRWxsrJg/f774v//7P2EwGMQTTzwhFAqFGDZsmJgzZ47o2bOnACDGjBljNs3Q0FARGxsrDWdnZ4tGjRoJX19f8dZbb4n58+eLF154QSgUCvHaa6+ZPTYuLk4AEN26dROzZs0Sn376qfjPf/4jZs+eLYQQYtmyZUKj0YjHH39cLFu2TCxbtkzs379fCCFEWlqaqF69uggJCRFTpkwR8+bNE0899ZQAIGbOnCnNIycnR9SuXVu4uLiIN998U8yaNUs0a9ZMNGrUSAAQu3fvfuBy/OOPP8SAAQOkaZpqyMrKEkII8cEHHwiFQiH69esnvvzySzF58mRRtWpVERYWJm7evClNJzY2VoSGhppNe9iwYcLJyUkMHz5czJ8/X0yYMEG4u7uLFi1aiLy8PCGEEFevXhVVqlQRtWvXFtOnTxdff/21ePvtt0XdunVLtBxNNQAQffr0EXPnzhUvvPCCACB69epV6PWsXbu20Gq1YuLEiWLGjBmiYcOGQqlUim3btpXqdbbE2vmkpaWJgIAA4enpKd5++20xY8YM0bhxY6FUKsW6deuk8RYsWCA9v6+++kp8/vnnYujQoWL06NHSOKbPRUpKihBCiPXr14vq1auLqKgo6bU1zXv37t2F3h+mx7do0ULMnDlTTJw4Ubi6ulp8vV1cXET9+vXFkCFDxLx580Tv3r0FAPHll19K423btk0AEB07dhRz584Vc+fOFaNGjRJ9+/YtctlZ+/mcMmWKUCqV4sqVK2aP/+WXXwQAsWbNGqnNmvej6XWrWbOmqFKlipg4caKYP3/+Az9D27ZtE02aNBFVq1aVlu/69evNlm/Tpk1Fs2bNxMyZM8WkSZOEm5ubaNmypdl0du7cKdRqtWjVqpX47LPPxMyZM0WjRo2EWq0Whw4deuBySktLE1OmTBEAxIgRI6QakpOTpdfp3s9lSkqKACCaNGki6tWrJ2bMmCH++9//CrVaLR599FHx1ltviccee0x88cUXYvTo0UKhUIjBgwebzfP//u//hEKhEF27dhWzZ88WH3/8sQgLCxNarVZ63z3Ivn37BADx448/FrovOjpauLu7i2+//VacP39e/PHHH6JPnz7C19dXej5CCPHee+9Jy/WZZ54RX375pRg2bJgAIN58880i529pmZQkCwCIxo0bi6CgIPH++++LWbNmiYiICOHm5ib+/fdfabxjx44JjUYjwsLCxEcffSSmTp0qgoODRePGjYWlqDMtl40bNxZbv1k9JRnZ9OHesWOHuHbtmrh48aJYuXKl8PX1Fa6uruLSpUtCiLtfpBMnTjR7/IYNGwQA8cEHH5i19+nTRygUCnHmzBmp7f7QfP/994W7u7v4559/zB47ceJEoVKpxIULF4QQQuzatUsAMPtSMzEYDNL/7u7uZtM3GTp0qAgKCjJ7MYQQon///sLb21vk5OQIIYSYNWuWACBWr14tjZOdnS1q1qxZbGgKIcT06dPNvmhNzp07J1QqlZg6dapZ+8mTJ4WTk5NZ+/1vxF9//VUAEMuXLzd77NatW83a169fb/HHz72sWY4JCQkCgBg2bJjZ/a+//roAIHbt2iW1hYaGCgBi7dq1UltmZqYICgoSTZs2ldqsfZ0fxNr5jBkzRgAQv/76q9R269YtER4eLsLCwoRerxdCCPGf//xH1K9fv8h53h+aQghRv3590a5du0Lj3h+aeXl5wt/fXzRo0EDcvn1bGm/Tpk0CgHj33XelNtPnasqUKWbTNAWEyWuvvSa8vLxEQUFBkXXfz9rPZ2JiogBg9uNJCCFeeeUV4eHhIX1GrH0/CnH3ddu6datVtfbo0aPQD0Yh7i7funXritzcXKnd9MP+5MmTQgjje7hWrVqiS5cuZt8LOTk5Ijw8XHTq1KnI+R85ckQAEIsXLy5034NC08/PT2RkZEjt8fHxUiDk5+dL7QMGDBBqtVrcuXNHCGF8X2q1WjF8+HCz+aSlpQlvb+9C7fdbuHCh2XO/V1JSknjkkUcEAOkWEREhTp8+bTaeKTSHDBli1v70008LX1/fIucvROFlUpIsACDUarVZ2x9//FHoPdizZ0/h5uYmLl++bPb8nJycLIZmamqqACA+/vjjYuu/V6k2z8bExMDPzw8hISHo378/PDw8sH79erPt5QDw8ssvmw3/9NNPUKlUGD16tFn7+PHjIYTAli1bHjjPNWvW4PHHH0eVKlXw77//SreYmBjo9Xrs3bsXALB27VooFAq89957haZhaRX9XkIIrF27Fj179oQQwmw+Xbp0QWZmJo4dOyY9l6CgILNNUW5uboV2tJfUunXrYDAY8Oyzz5rNPzAwELVq1cLu3bsf+Ng1a9bA29sbnTp1Mntss2bN4OHhIT1Wq9UCADZt2oT8/HyL07JmOf70008AgHHjxpndP378eAAotKkzODgYTz/9tDTs5eWFF154AcePH0daWpr0HKx5nYtizXx++ukntGzZEm3atJHG8/DwwIgRI3Du3Dn89ddfAIzL6tKlSzhy5Eix8y2N33//Henp6XjllVfM9nX26NEDUVFRFjcXv/TSS2bDjz/+OM6ePSsNa7VaZGdnY/v27SWqxdrPZ+3atdGkSROsWrVKGkev1+P7779Hz549pc161r4fTcLDw9GlS5cS1fwggwcPhlqtloYff/xxAJCWU0JCApKSkjBw4EBcv35dqi07OxsdO3bE3r17rdodUBJ9+/aFt7e3NBwdHQ0AeO655+Dk5GTWnpeXJ22e3759OzIyMjBgwACz5ahSqRAdHV3kdwIAXL9+HQBQpUqVQvd5enqifv36GDlyJNatW4cvv/wSBQUF6NWrl8XDSyy9965fvw6dTmflUjAqaRbExMQgMjJSGm7UqBG8vLyk11Ov12PHjh3o1asXgoODpfFq1qyJbt26WazBtDxKehhNqToCzZ07F7Vr14aTkxMCAgJQp04dKJXm+evk5ITq1aubtZ0/fx7BwcHw9PQ0a69bt650/4MkJSXhxIkT8PPzs3h/eno6ACA5ORnBwcHw8fEp8fO6du0aMjIysGDBAixYsKDI+Zw/fx41a9YsFMR16tQp8XzvlZSUBCEEatWqZfH+ojoZJCUlITMzE/7+/hbvN9Xerl079O7dG5MnT8bMmTPRvn179OrVCwMHDpQ6YFmzHM+fPw+lUomaNWuatQcGBkKr1RZ6PS0tr9q1awMw7vcJDAy0+nUuijXzOX/+vPSlda9734sNGjTAhAkTsGPHDrRs2RI1a9ZE586dMXDgQLRu3brYOqxhWkaW3jdRUVHYt2+fWZtp3/K9qlSpYraP8JVXXsHq1avRrVs3VKtWDZ07d8azzz6Lrl27FluLtZ/Pfv364a233sLly5dRrVo17NmzB+np6ejXr580jrXvR5Pw8PAi6yuJGjVqmA2bviBNyykpKQkAEBsb+8BpZGZmWgyasqrJFKAhISEW2++v1dR35H5eXl5WzV/ct6+woKAAMTExaN++PWbPni21x8TEoH79+pg+fTo+/vjjIp/DvcvV2jqAkmfB/fM1zdu0jNLT03H79u1C30UALLYBd5dHcStT9ytVaLZs2VLqPfsgGo2mUJA+DIPBgE6dOuHNN9+0eL/pS/Fh5wEYf/k96MPUqFGjh55PcTUoFAps2bLFYo/Me4+xsvRYf39/LF++3OL9pi9b08HfBw8exMaNG/Hzzz9jyJAh+Oyzz3Dw4MEi52FJSd90RamI17kk6tati8TERGzatAlbt27F2rVr8eWXX+Ldd9/F5MmTK7QWAFb10vX390dCQgJ+/vlnbNmyBVu2bMHixYvxwgsvYOnSpWVSR79+/RAfH481a9ZgzJgxWL16Nby9vc2C2dr3o0lZ9pR90HIyfVGaPuvTp09HkyZNLI5b0s9BaWuyttZly5YhMDCw0Hj3rqVa4uvrC8AYbPeuyOzduxenTp3CjBkzzMavVasW6tata7FDVHG1lpfymK8pcKtWrVqix5UqNEsrNDQUO3bswK1bt8x+YZw+fVq6/0EiIyORlZVVqAeYpfF+/vln3Lhxo8i1JEtf9H5+fvD09IRery92PqGhoTh16hSEEGbTsvb4rAcFTWRkJIQQCA8PL3FAREZGYseOHWjdurVVX0CPPvooHn30UUydOhUrVqzAoEGDsHLlSgwbNsyq5RgaGgqDwYCkpCTpFyIAXL16FRkZGYVezzNnzhRaXv/88w8ASL0NrX2di2LNfEJDQy2+Vpbei+7u7ujXrx/69euHvLw8PPPMM5g6dSri4+MfePiItT8kTPNJTEwstCaRmJhY5GeiKGq1Gj179kTPnj1hMBjwyiuv4KuvvsI777zzwF/eJfl8hoeHo2XLlli1ahVGjRqFdevWoVevXmaHipX0/VgSD/tDzbSpz8vLq1TvtbL8oVgcU63+/v6lqjUqKgqA8eiGhg0bSu2mE9Lc3/MaMPasLSgoKE25VnmYLLDE398fLi4uFntIW2oD7h7tce93lzUq9DR63bt3h16vx5w5c8zaZ86cCYVC8cBtzwDw7LPP4sCBA/j5558L3ZeRkSG9wL1794YQwuJawL2/Stzd3QudWEClUqF3795Yu3YtTp06Vejx165dM3suqampZqfrysnJeeBm3fuZjlm9v4ZnnnkGKpUKkydPLvQrSggh7Z+w5Nlnn4Ver8f7779f6L6CggJpXjdv3iw0bdOvbdOhItYsx+7duwNAoYPMTb9ce/ToYdaempqK9evXS8M6nQ7/93//hyZNmki/oK19nYtizXy6d++Ow4cP48CBA9J42dnZWLBgAcLCwlCvXj0AKLS81Wo16tWrByHEA/cHA5bfX5Y0b94c/v7+mD9/vtlhOlu2bMHff/9daBla4/6alUqltIWkqEOiSvr57NevHw4ePIhFixbh33//Nds0C1j/fiwNd3d3ZGZmlvrxzZo1Q2RkJD799FOLp5W797P+oPkDhT+/5aFLly7w8vLChx9+aPE9V1ytzZo1g1qtNjtUDLi71WblypVm7ceOHUNiYiKaNm36kJU/2MNkgSUqlQoxMTHYsGEDUlNTpfYzZ848sK/M0aNHoVAo0KpVqxLNq0LXNHv27IkOHTrg7bffxrlz59C4cWNs27YNP/zwA8aMGWO2o/d+b7zxBn788Uc8+eSTiIuLQ7NmzZCdnY2TJ0/i+++/x7lz51C1alV06NABzz//PL744gskJSWha9euMBgM+PXXX9GhQweMGjUKgPGNtGPHDsyYMQPBwcEIDw9HdHQ0PvroI+zevRvR0dEYPnw46tWrhxs3buDYsWPYsWOHdEzP8OHDMWfOHLzwwgs4evQogoKCsGzZMri5uVm1LJo1awYAePvtt9G/f384OzujZ8+eiIyMxAcffID4+HicO3cOvXr1gqenJ1JSUrB+/XqMGDECr7/+usVptmvXDi+++CKmTZuGhIQEdO7cGc7OzkhKSsKaNWvw+eefo0+fPli6dCm+/PJLPP3004iMjMStW7fw9ddfw8vLSwpCa5Zj48aNERsbiwULFiAjI0M6i8jSpUvRq1evQsfy1a5dG0OHDsWRI0cQEBCARYsW4erVq1i8eHGJX+eiWDOfiRMn4rvvvkO3bt0wevRo+Pj4YOnSpUhJScHatWulXQudO3dGYGAgWrdujYCAAPz999+YM2cOevToUWh/zP2v77x58/DBBx+gZs2a8Pf3t7hPytnZGR9//DEGDx6Mdu3aYcCAAbh69So+//xzhIWFYezYsUU+V0uGDRuGGzdu4IknnkD16tVx/vx5zJ49G02aNCnyV3VJP5/PPvssXn/9dbz++uvw8fEptBZk7fuxNJo1a4ZVq1Zh3LhxaNGiBTw8PNCzZ0+rH69UKrFw4UJ069YN9evXx+DBg1GtWjVcvnwZu3fvhpeXFzZu3PjAx0dGRkKr1WL+/Pnw9PSEu7s7oqOjy3S/rImXlxfmzZuH559/Ho888gj69+8PPz8/XLhwAZs3b0br1q0Lhc+9XFxc0LlzZ+zYsQNTpkyR2ps1a4ZOnTph6dKl0Ol06Ny5M65cuYLZs2fD1dUVY8aMKfPnYvIwWfAgkyZNwrZt29C6dWu8/PLLUig3aNDA4pmbtm/fjtatW0ubr61Wkq62DzpO836xsbHC3d3d4n23bt0SY8eOFcHBwcLZ2VnUqlVLTJ8+3azbtxCFDzkxPTY+Pl7UrFlTqNVqUbVqVfHYY4+JTz/91OyYr4KCAjF9+nQRFRUl1Gq18PPzE926dRNHjx6Vxjl9+rRo27atcHV1FQDM5nX16lUxcuRIERISIpydnUVgYKDo2LGjWLBggVk958+fF0899ZRwc3MTVatWFa+99prUnb64Q06EMB5eUa1aNaFUKgsdsrB27VrRpk0b4e7uLtzd3UVUVJQYOXKkSExMNFvOlrrdL1iwQDRr1ky4uroKT09P0bBhQ/Hmm2+K1NRUIYTxeKYBAwaIGjVqCI1GI/z9/cWTTz4pfv/9d7PpWLMc8/PzxeTJk0V4eLhwdnYWISEhIj4+XuoubxIaGip69Oghfv75Z9GoUSOh0WhEVFSU2TF9Jta+zpaUZD7JycmiT58+QqvVChcXF9GyZUuxadMms3G++uor0bZtW+Hr6ysde/zGG2+IzMxMaRxLh5ykpaWJHj16CE9PTwFAOvzE0nGaQgixatUq0bRpU6HRaISPj48YNGiQdAiXyYM+V6bDAUy+//570blzZ+Hv7y/UarWoUaOGePHFFwsdV2mJtZ9Pk9atW1s87Ohexb0fhbj7ulkrKytLDBw4UGi1WgFA+hyYlu/9r7fpsI/7DxE5fvy4eOaZZ6TXNzQ0VDz77LNi586dxdbwww8/iHr16kmHNJim/aBDTqZPn272+AfV+qDv2d27d4suXboIb29v4eLiIiIjI0VcXFyhz60l69atEwqFotAhWzk5OWLKlCmiXr16wtXVVXh7e4snn3xSHD9+3Gw803vs2rVrFmst7lhRS99V1r7XAIiRI0cWmqaljNi5c6do2rSpUKvVIjIyUixcuFCMHz9euLi4mI2XkZEh1Gq1WLhwYZF1W6L4X1E2JyQkBF26dMHChQvlLoXKQFhYGBo0aIBNmzZVivkQ2RO9Xo969erh2Weftbi5vDLr1asX/vzzT6kXMmDcpfTJJ58gOTm5xPvbbfLSYPn5+bh+/XqJezUREVFhKpUKU6ZMwdy5c0t1aTB7cfv2bbPhpKQk/PTTT9JpLAFjvsyYMQP//e9/S9VBrUL3aVrj559/xsqVK3H79m107NhR7nKIiCoFUw/wyiwiIgJxcXGIiIjA+fPnMW/ePKjVarND2JydnXHhwoVSz8PmQvOjjz7CmTNnMHXqVHTq1EnucoiIyE507doV3333HdLS0qDRaNCqVSt8+OGHDzxZTGnY7D5NIiIiW2OT+zSJiIhsEUOTiIjISja3T5OM55pMTU2Fp6dnhZ6ui4hsgxACt27dQnBwcJmew5seHkPTBqWmpha68gEROZ6LFy8WuloUyYuhaYNMp2e7ePFiiS63Q0SVg06nQ0hISJGnaiR5MDRtkGmTrJeXF0OTyIFx94zt4cZyIiIiKzE0iYiIrMTQJCIishJDk4iIyEoMTSIiIisxNImIiKzE0CQiIrISQ5OIiMhKDE0iIiIrMTSJiIisxNAkIiKyEkOTiIjISgzN++zduxc9e/ZEcHAwFAoFNmzYIN2Xn5+PCRMmoGHDhnB3d0dwcDBeeOEFpKammk0jLCwMCoXC7PbRRx9V8DMhIqKyxtC8T3Z2Nho3boy5c+cWui8nJwfHjh3DO++8g2PHjmHdunVITEzEU089VWjcKVOm4MqVK9Lt1VdfrYjyqQRurlyJpCc64ubKlXKXQkR2gpcGu0+3bt3QrVs3i/d5e3tj+/btZm1z5sxBy5YtceHCBdSoUUNq9/T0RGBgYLnWSg/n3wVfoyA1Ff8u+BpV+veXuxwisgNc03xImZmZUCgU0Gq1Zu0fffQRfH190bRpU0yfPh0FBQXyFEgPVHXEcDgFB6PqiOFyl0JEdoJrmg/hzp07mDBhAgYMGGB2sejRo0fjkUcegY+PD/bv34/4+HhcuXIFM2bMsDid3Nxc5ObmSsM6na7cayegSv/+XMMkohJhaJZSfn4+nn32WQghMG/ePLP7xo0bJ/3fqFEjqNVqvPjii5g2bRo0Gk2haU2bNg2TJ08u95qJiOjhcPNsKZgC8/z589i+fbvZWqYl0dHRKCgowLlz5yzeHx8fj8zMTOl28eLFcqiaiIgeFtc0S8gUmElJSdi9ezd8fX2LfUxCQgKUSiX8/f0t3q/RaCyugRIRkW1haN4nKysLZ86ckYZTUlKQkJAAHx8fBAUFoU+fPjh27Bg2bdoEvV6PtLQ0AICPjw/UajUOHDiAQ4cOoUOHDvD09MSBAwcwduxYPPfcc6hSpYpcT4uIiMqAQggh5C7CluzZswcdOnQo1B4bG4tJkyYhPDzc4uN2796N9u3b49ixY3jllVdw+vRp5ObmIjw8HM8//zzGjRtn9dqkTqeDt7c3MjMzi930S0SVD78DbBdD0wbxA0Pk2PgdYLvYEYhIBkKvR97FixB6vdylEFEJMDSJKpjQ63F+0CAkd+qM84MGMTiJ7AhDk6iC5aem4nbCHwCA2wl/IP++E/4Tke1iaBJVMOfgYLg2aQwAcG3SGM7BwTJXRETW4iEnRBVMoVIhdPly5Kemwjk4GAqVSu6SiMhKDE0iGShUKqhDQuQug4hKiJtniYiIrMTQJCIishJDk4iIyEoMTSIiIisxNImIiKzE0CQiIrISQ5OIiMhKDE0iIiIrMTSJiIisxNAkcgD5V64gc/Nm5F+5IncpRHaNp9EjquTyr1zB2Sd7wpCdDaWHByI2/gjnoCC5yyKyS1zTJKrkco4dgyE7GwBgyMrC7ePHZa6IyH4xNIkqObdHHoHSwwMAoPTwgGvTpjJXRGS/uHmWqJJzDgpCxMYfcfv4cbg2bcpNs0QPgaFJ5ACcg4IYlkRlgJtniYiIrMTQJCIishJDk4iIyEoMTSIiIisxNImIiKzE0CQiIrISQ5OIiMhKDE0iIiIrMTSJiIisxNAkIiKyEkOTiIjISgxNIiIiK/GE7URUZrL370f2wUNwfzQa7o89Jnc5RGWOa5pEVCay9+/HhSFDcX3hQlwYMhTZ+/fLXRJRmWNoElGZyD54CFAqAYMBUCqRfeiw3CURlTmG5n327t2Lnj17Ijg4GAqFAhs2bDC7XwiBd999F0FBQXB1dUVMTAySkpLMxrlx4wYGDRoELy8vaLVaDB06FFlZWRX4LIgqnvuj0VJgwmCAe3RLuUsiKnMMzftkZ2ejcePGmDt3rsX7P/nkE3zxxReYP38+Dh06BHd3d3Tp0gV37tyRxhk0aBD+/PNPbN++HZs2bcLevXsxYsSIinoKRLJwf+wx1Fj0DXyHD0eNRd9wnyZVSgohhJC7CFulUCiwfv169OrVC4BxLTM4OBjjx4/H66+/DgDIzMxEQEAAlixZgv79++Pvv/9GvXr1cOTIETRv3hwAsHXrVnTv3h2XLl1CcHBwsfPV6XTw9vZGZmYmvLy8yu35EZFt4neA7eKaZgmkpKQgLS0NMTExUpu3tzeio6Nx4MABAMCBAweg1WqlwASAmJgYKJVKHDp0yOJ0c3NzodPpzG5ERGR7GJolkJaWBgAICAgwaw8ICJDuS0tLg7+/v9n9Tk5O8PHxkca537Rp0+Dt7S3dQkJCyqF6IiJ6WAxNGxAfH4/MzEzpdvHiRblLIiIiCxiaJRAYGAgAuHr1qln71atXpfsCAwORnp5udn9BQQFu3LghjXM/jUYDLy8vsxsREdkehmYJhIeHIzAwEDt37pTadDodDh06hFatWgEAWrVqhYyMDBw9elQaZ9euXTAYDIiOjq7wmomIqOzwNHr3ycrKwpkzZ6ThlJQUJCQkwMfHBzVq1MCYMWPwwQcfoFatWggPD8c777yD4OBgqYdt3bp10bVrVwwfPhzz589Hfn4+Ro0ahf79+1vVc5aIiGwXQ/M+v//+Ozp06CANjxs3DgAQGxuLJUuW4M0330R2djZGjBiBjIwMtGnTBlu3boWLi4v0mOXLl2PUqFHo2LEjlEolevfujS+++KLCnwsREZUtHqdpg3iMFpFj43eA7eI+TSIiIisxNImIiKzE0CQiIrISQ5OIiMhKDE0iIiIrMTTpgfQGPS7eugi9QS93KURENoGhWQmtTlyNzt93xurE1aWeht6gR+zWWHRf1x2xW2MZnEREYGhWSgtPLsSV7CtYeHJhqaeRmp2KP679AQD449ofSM1OLfW00rLTsCVlC9KyLV/lhYjIXjA0K6FhDYchyD0IwxoOK/U0gt2D0divMQCgsV9jBLuX7hSAadlp6PVDL7y59030+qEXg5NKRRgMuL54CS69+iquL14CYTDIXRI5KJ5GrxJ6ts6zeLbOsw81DZVShaVdlyI1OxXB7sFQKVWlms7x9OPIzs8GAGTnZyMhPQFdw7s+VG3keG4s/T+kf/wxoFDg1vYdAADfwXHyFkUOiWua9EAqpQohniGlDkwAaOrfFO7O7gAAd2d3NPFvUkbVkSO5fewooFAAQgAKhXGYSAZc06RyFegeiA3/2YCE9AQ08W+CQHfL1xQlKorrI82Ma5j/C07XR5rJXRI5KIYmlbtA98CH3iR7IPUADqcdRsvAlmgV3KqMKiN74RP7AgDjGqfrI82kYaKKxquc2CBe4cDcgdQDGLF9BJQKJQzCgAWdFjA4qVLjd4Dt4j5NsnmH0w5LgalUKHEk7YjcJRGRg2Joks1rGdhSCkyDMKBFYAu5SyIiB8V9mmTzWgW3woJOC3Ak7QhaBLbgplkikg1Dk+xCq+BWDEsikh03zxIREVmJa5rkEAzCgGV/LcPx9ONo6t8Uz9d7HkoFfzMSUckwNMkhLPtrGT79/VMAwM4LOwEAsfVj5SyJiOwQf2qTQzieflz6XwGF2TARkbUYmuQQmvo3BWAMTAEhDRMRlQQ3z5JDeL7e8wBgtk+TiKikeBo9G8RTaBE5Nn4H2C5uniUiIrISQ5OIiMhKDE0iIiIrsSMQUTGy87Px8eGPpQtpT2g5Ae7O7nKXRUQyYGgSFePjwx/jh+QfYBAGnL91HgAwpfUUmasiIjlw8yxRMRLSE2AQBgDG0/ElpCfIWxARyYahSVSMJv5NpPPUKhVKNPFvIm9BRCQbbp4lKsaElhMAQNqnObHlRJkrotLSZ2Xj6rQPcfvYcbg+0hQB8W9B5cH902Q9hiZRMdyd3bkPs5K4Ou1DZK7fABgMyDtv3D8dPHWqvEWRXeHmWSJyGLePHQcMxv3TMBhw+zhP3E8lw9AkIofh+khTQPm/rz2lEq5NeeJ+KhmGZgmFhYVBoVAUuo0cORIA0L59+0L3vfTSSzJXTUQAEBD/Fryf7gV1RDi8n+6FwLfekrsksjPcp1lCR44cgV6vl4ZPnTqFTp06oW/fvlLb8OHDMWXK3X1gbm5uFVojEVmm8nDnPkx6KAzNEvLz8zMb/uijjxAZGYl27dpJbW5ubggMDKzo0oiIqJxx8+xDyMvLw7fffoshQ4ZAoVBI7cuXL0fVqlXRoEEDxMfHIycnp8jp5ObmQqfTmd3Ivl3JuoLnfnoOzb9tjud+eg5Xsq7IXRIRlQGG5kPYsGEDMjIyEBcXJ7UNHDgQ3377LXbv3o34+HgsW7YMzz33XJHTmTZtGry9vaVbSEhIOVdO5e2NvW/g1L+nkKvPxal/T+GNvW/IXRIRlQFehPohdOnSBWq1Ghs3bnzgOLt27ULHjh1x5swZREZGWhwnNzcXubm50rBOp0NISAgvQGvHmn/bHLn6u6+pRqXB78/9LmNFZE94EWrbxTXNUjp//jx27NiBYcOGFTledHQ0AODMmTMPHEej0cDLy8vsRvYtyicKKoUKAKBSqBDlEyVzRURUFhiapbR48WL4+/ujR48eRY6XkJAAAAgKCqqAqshWTG87HQ2qNoBGpUGDqg0wve10uUsiojLA3rOlYDAYsHjxYsTGxsLJ6e4iTE5OxooVK9C9e3f4+vrixIkTGDt2LNq2bYtGjRrJWDFVtCCPIHzb/Vu5yyCiMsbQLIUdO3bgwoULGDJkiFm7Wq3Gjh07MGvWLGRnZyMkJAS9e/fGf//7X5kqJSKissSOQDaInQCIHBu/A2wX92kSERFZiaFJRERkJYYmERGRlRiaRDLLzs6WroiTnZ0tdzlEVASGJpENMQiD3CUQUREYmkQyyc7ORnZ2Nn6/cPf0el2/64rD5w9zjZPIRvGQExvE7uaO4d4r41jCj6bj4neA7eKaJhERkZUYmkQyycrKgu6WDo8teExqqze7Hh5f+jh0t3hNVSJbxNAkkom7uzs8PTwxs/NMqc3Xyxdfdv8Snh6eMlZGRA/Cc88Syax+1frS/5uf2czAJLJhDE0imbm7u7PTD5Gd4OZZIqJi5Kem4lz/ATjduAnO9R+A/NRUuUsimTA0iYiKcXnceNw+eRIiNxe3T57E5XHj5S6JZMLQJCIqxp2//wb0euOAXm8cJofE0CQiKoZL3bqASmUcUKmMw+SQGJpERMWoNuMzuDZsCIVGA9eGDVFtxmdyl0QyYe9ZIqJiOAcHI2zld3KXQTaAa5pEdkKXp8PpG6ehy+PZgojkwjVNIjuw4/wOTNg7AXmGPKiVanzc9mPEhMbIXRaRw+GaJpGN0+XppMAEgDxDHibsncA1TiIZMDSJbFxqVqoUmCZ5hjykZvEAe6KKxtAksnHBHsFQK9VmbWqlGsEewTJVROS4GJpENs5L7YWP234sBadaqcYnbT+Bl5oXJyaqaOwIRGQHYkJjsLvfbqRmpSLYI5iBSSQThiaRnfBSe8HLh2FJJCduniUiIrISQ5OIiMhKDE0iIiIrMTSJiIisxNAkIiKyEkOTiIjISgxNIiIiK/E4TaJKICUzBRd0F1DDqwbCvcPlLoeo0mJoEtm5pX8uxWe/fwYBAQUUGN98PGLrx8pdFlGlxM2zRHYsJTNFCkwAEBD47PfPkJKZInNlRJUTQ7OEJk2aBIVCYXaLioqS7r9z5w5GjhwJX19feHh4oHfv3rh69aqMFVNldkF3QQpMEwGBC7oLMlVEVLkxNEuhfv36uHLlinTbt2+fdN/YsWOxceNGrFmzBr/88gtSU1PxzDPPyFjt/xj0wI0U498HybwEnPze+JfsQg2vGlBAYdamgAI1vGrIVBFR5cZ9mqXg5OSEwMDAQu2ZmZn45ptvsGLFCjzxxBMAgMWLF6Nu3bo4ePAgHn300You1cigBxZ1AS4dAaq3AIb8DChV5uNkXgLmRgN5WYDGE3jlIOBdvfC0kncDKXuB8LZAZIeKqZ8eKNw7HOObjzfbp/l689fZGYionDA0SyEpKQnBwcFwcXFBq1atMG3aNNSoUQNHjx5Ffn4+YmJipHGjoqJQo0YNHDhw4IGhmZubi9zcXGlYp9OVrKAj3wD7ZgJtxgIthha+P+OCMTAB49+MC4DPfV+qFw4aAxMAcm8BFw8VDs3k3cCyXoBCCeybATy/gcFpA2Lrx6Jt9bbsPWsDsrOz4eHhAQDIysqCu7u7zBVRWePm2RKKjo7GkiVLsHXrVsybNw8pKSl4/PHHcevWLaSlpUGtVkOr1Zo9JiAgAGlpaQ+c5rRp0+Dt7S3dQkJCSlbUvplA5kXjX0u0NYxrmIDxr9bCprsajxrXMAHj35DowuOk7DUGpjAY/577tfA4BgOwfw6wcpDxr8FQsudCpRLuHY52Ie0YmDZE8L1fKXFNs4S6desm/d+oUSNER0cjNDQUq1evhqura6mmGR8fj3HjxknDOp2uZMHZZuzdNU1LlCrjJtmMC8bAvH/TLGBcq3zloHENMyTa8qbZ8LbGNUxTcIY9Xnicg18C294GoABObzK2PTbK+udCZIeys7MBAP8eOSK1newYg1qzv4BrgwZc46xEGJoPSavVonbt2jhz5gw6deqEvLw8ZGRkmK1tXr161eI+UBONRgONRlP6IloMtbxZ9l5KVeFNsvfzrm45LE0iOxg3yZ771RiYljbNXjgAQAFAGP9eOMDQpErPtEn2Xo8dOQz8b5eMEKLQ/WSfuHn2IWVlZSE5ORlBQUFo1qwZnJ2dsXPnTun+xMREXLhwAa1atZKxyjIU2QHo+O6D92XWaAUpMCH+N0xEVDlwTbOEXn/9dfTs2ROhoaFITU3Fe++9B5VKhQEDBsDb2xtDhw7FuHHj4OPjAy8vL7z66qto1aqVfD1nK9qjrxj/XjhgDEzTsEnuLWDrxLubgbt+dHdfKpGdysrKgjAYcLJjjHENE8CvtWrDw9cXNbf9LHN1VJYYmiV06dIlDBgwANevX4efnx/atGmDgwcPws/PDwAwc+ZMKJVK9O7dG7m5uejSpQu+/PJLmauuQEqlcXPsgzbJbp0IJHwHCD1w/ayx7T9zK64+onJg2mdZa/YX0iZZD19f1FnwFVw9+aOwMlEIbmy3OTqdDt7e3sjMzISXl5fc5ZStOc2Bf5PuDletBYz6Xb56iMrQvYec3NLp4FHKwKzU3wF2jvs0qWKFRAOK//XeVagsH9pCZKfc3d0hhIAQotSBSbaNm2epYnX9yPhX2qf5sbz1EBGVgF2Fpo+PT4nGVygUOHbsGEJDQ8upIioxjWfR+zAzLgLfDwHSTgCBjYA+iwBtCU/24OCEEDicdhjndecR6hWKloEtoVAoin8gERXLrkIzIyMDs2bNgre3d7HjCiHwyiuvQK8v4gTlZHu+HwJcPmrsKHT5qHF42Ha5q7IbQghMPTQVqxJXSW396vTD29FvMziJyoBdhSYA9O/fH/7+/laN++qrr5ZzNVTm0k4YAxMw/k07IW89duZw2mGzwASAVYmr0Dm0M1oGtZSpKqLKw646AhkMBqsDEwBu3bqFiIiIcqyIylxgI/OOQoGNpLuys7Ola5iaTltG5s7rzltsP6c7V7GFEFVSdhWa5AD6LAKqNQOcXIx/+yyyPB5Phm1RqJfl/fdhXmEVWwhRJWV3m2fvlZqain379iE9PR2G+75ER48eLVNV9FC0IYX2YZrWKrPP7L/b9lljYND/AcFNeTLse7QMbIl+dfoV2qfZIrCFjFURVR52e3KDJUuW4MUXX4RarYavr69ZJweFQoGzZ8/KWN3D4YHN5orrwGKnb+FyI4TAkbQjOKc7hzCvMLQIbMFOQHaG3wG2y25DMyQkBC+99BLi4+OhVFaurcz8wJhjaJKj4XeA7bLbtMnJyUH//v0rXWBSYVlZWcjS6XD1vbuXNrv6uheypkYiS6eTsTIicjR2mzhDhw7FmjVr5C6DKoC7uzvcPT3hPuj/7rZV8YN77Cq481RlRFSB7HbzrF6vx5NPPonbt2+jYcOGcHZ2Nrt/xowZMlX28LhpxrJ7T4adpdMxMKnS4neA7bLb3rPTpk3Dzz//jDp16gBAoY5AVPmYToZdyO0MIOMCoK0BuGoruiwiciB2G5qfffYZFi1ahLi4OLlLITn99SOwdhigzwVUGqD3QqDeU3JXRUSVlN3u09RoNGjdurXcZZCcbmfcDUzA+HftMGM7EVE5sNvQfO211zB79my5yyA5ZVy4G5gm+lxjOxFRObDbzbOHDx/Grl27sGnTJtSvX79QR6B169bJVBlVGG0N4ybZe4NTpTG2ExGVA7sNTa1Wi2eeeUbuMkhOrlrjPsx792n2+YadgYio3NjtISeVGbublxB7z1pUYCjAlpQtuHjrIkI8Q9AtvBuclHb7O9mh8DvAdvETRPbPVVs4LP9NAq4nA76RQNVaclQlqwJDAUbtHIXfUn+DSqGCXuix+exmzO04FyqlSu7yiOyWXXUEeuSRR3Dz5k2rx2/Tpg0uX75cjhWRTdo/B5jTAviun/Hv/jlyV1ThtqRswW+pvwEA9P+7qPdvqb/hp5Sf5CyLyO7Z1ZpmQkIC/vjjD/j4+Fg9fm5ubvEjUuXxbxKw7b8ATHsdhHG4dheHWuO8eOuitIZpolKocOnWJRmrclx6nQ75ly/DuVo1qLi51a7ZVWgCQMeOHa2+qgXPDOSArifjbmCaCGO7A4VmiGeIWWACxjXO6p7VZarIcem2bUPq629A5OVBoVYj+NPp8OrcWe6yqJTsKjRTUlJK/Jjq1fkl4VB8IwEoYB6civ+1O45u4d2w+exms32arYNbo3t4d7lLcyh6nU4KTAAQeXlIff0NuO97lGucdsquQjM0NFTuEsjWVa0FdP7gnk20CqDLVIdaywQAJ6UT5nScgy0pW3Dp1iVU96yO7uHd2QmoguVfviwFponIy0P+5csMTTtlV6FJZJXHRhn3YTpw71nAGJw9I3vKXYZDc65WDQq12iw4FWo1nKtVk7Eqehh21XuWyGpVawF1ujpsYJJtUHl5IfjT6VCo1QCMgRn82adcy7RjXNOkyk0IIGUvcCMZ8IkEwtsC7CBGFcirc2e473uUvWcrCYYmVV5CAJvHA79/c7et+VCgx2cMTqpQKi8vhmUlYbebZ2NjY7F37165yyBblrLXPDAB4/C5X+Wph4jsnt2GZmZmJmJiYlCrVi18+OGHPPMPFXYj2XL79TMVWwcRVRp2G5obNmzA5cuX8fLLL2PVqlUICwtDt27d8P333yM/P1/u8sgW+Dzg2EzfmhVbBxFVGnYbmgDg5+eHcePG4Y8//sChQ4dQs2ZNPP/88wgODsbYsWORlJQkd4kkp/C2xn2Y92oxDAh7XJ56iMjuVYqOQFeuXMH27duxfft2qFQqdO/eHSdPnkS9evXwySefYOzYsXKXSHJQKIydfur3Mm6S9a1pDEx2AiKiUrLbNc38/HysXbsWTz75JEJDQ7FmzRqMGTMGqampWLp0KXbs2IHVq1djypQpZTrfadOmoUWLFvD09IS/vz969eqFxMREs3Hat28PhUJhdnvppZfKtA6ykkLxvzXOIQ51uElOfg4WnVqEKQemYNGpRcjJz5G7JKJKwW7XNIOCgmAwGDBgwAAcPnwYTZo0KTROhw4doNVqy3S+v/zyC0aOHIkWLVqgoKAAb731Fjp37oy//voL7u7u0njDhw83C2w3N7cyrYNKSF8AnFoL3DgL+EQADXoDKrt9+xcpJz8Hg34ahLMZZ6FUKGEQBmxK3oRvu38LN2e+D4keht1+a8ycORN9+/aFi4vLA8fRarWlOsl7UbZu3Wo2vGTJEvj7++Po0aNo27at1O7m5obAwMAynTeVkr4AWPEskLwTUDoBhgLgxCpg0BqgEp6LdWXiSpzNOAsDDDAIAwAgOSMZKxNXYkiDITJXR2Tf7Hbz7PPPP19kYFaUzMxMACh0jc/ly5ejatWqaNCgAeLj45GTw81jsjm11hiYgDEwAePwye/lq6kcXbp1CUqF+UdbqVDi8i0elkX0sOx2TdMWGAwGjBkzBq1bt0aDBg2k9oEDByI0NBTBwcE4ceIEJkyYgMTERKxbt87idHJzc80ulq3T6cq9dody4+zdNUwTpRNws2y3QtiK6p7VpTVME4MwoJonTxJO9LAYmg9h5MiROHXqFPbt22fWPmLECOn/hg0bIigoCB07dkRycjIiIwsfOzht2jRMnjy53Ot1WD4R5oEJGIerhMtTTznrX6c/NiVvQnJGsrRPM1Ibif51+stdGpHdUwgh7r/MPVlh1KhR+OGHH7B3716Ehxf95ZudnQ0PDw9s3boVXbp0KXS/pTXNkJAQZGZmwovnq3x4lvZpRnastPs0AWNnoJWJK3H51mVU86yG/nX6sxOQHdHpdPD29uZ3gA3immYJCSHw6quvYv369dizZ0+xgQkACQkJAIw9fi3RaDTQaDRlWSbdS+UEDFxt3Ld5M8W4htmwT6UNTABwc3Zjpx+icsDQLKGRI0dixYoV+OGHH+Dp6Ym0tDQAgLe3N1xdXZGcnIwVK1age/fu8PX1xYkTJzB27Fi0bdsWjRo1krl6B6ZyAhr3k7sKIrJz3DxbQooHHBy/ePFixMXF4eLFi3juuedw6tQpZGdnIyQkBE8//TT++9//Wr2ZhZtmykleNnD4a+DmOaBKGNByOKB2L+5RRBWO3wG2i2uaJVTcb4yQkBD88ssvFVQNWS03C/imE3DtNKBQAsJgPFZz2A4GJxFZzW6P0yQqkSMLjYEpDMaOQMJgHD78tdyVEZEdYWiSY7h5zriGeS+FEsg4L0s5RGSfGJrkGKqEGdcu7yUMgDZUlnKIyD4xNMkxtBwO+EUZ1y6VTsa/fnWN7UREVmJHIHIMandjp5/DXxs3yWpD2XuWiEqMoUmOQ+0OtBkjdxXl4lrONaw4vQJJN5NQq0otDIwaCD83P7nLIqp0GJrkOG6lAYe+AtL/AvzrAdEvAp72f/m2aznX0HdjX9zMvQmDMODXy79ifdJ6rOm5hsFpI3LPpiDv/DmoQ8Ogiaic5zx2FNynSY7hVhow/3Hgt8+Bf7Ya/85/3Nhu51acXiEFJmC8osnN3JtYcXqFzJURAFxfvARne/TApZdfwdkePXB98RK5S6KHwNAkx3DoKyDnOiD0xmGhNw4f+kreuspA0s0ki5cCO3PzjEwVkUnu2RSkf/IJYDopihBI/+QT5J6tnJelcwQMTXIM6X/dDUwToQfS/5annjJUq0otixedrlmlpkwVkUne+XN3A9NECGM72SWGJjkG/3qA4r6rmihUgH9deeopQwOjBqKKpooUnEqFElU0VTAwaqDMlZE6NAy4/3zVCoWxnewSQ5McQ/SLgJvv3eBUqIzD0S/KW1cZ8HPzw5qeazCkwRC0r94eQxoMYScgG6GJCIf/m2/eDU6FAv4T3mRnIDvGq5zYIF7hoJxIvWf/Nq5hVpLes2T7Stp7lt8BtouhaYP4gSFybPwOsF08TpMqt2v/AL/NAtJOAoENgdZjAL/acldFRHaKoUmV17V/gAXtAf0dwKAH0v8E/twAjNjD4CSiUmFHIKq8fpt1NzAB49+CO8YTGxARlQJDkyqvtJN3A9NE6I3tRESlwNCkyiuwIaC0cGxmYEN56iEiu8fQpMqr9RhA5WJ+bKaTC9D6NVnLIiL7xY5AVHn51TZ2+vnt83t6z75mt52AzmaexeKTi3H65mlEVYnC4IaDEeEdIXdZRA6Fx2naIB6jRfc7m3kW/Tf1R54+D3qhh0qhglqlxsonVzI4KyF+B9gubp4lsgOLTy6WAhMA9EKPPH0elpxaIm9hRA6GoUlkB07fPC0Fpole6HH6xmmZKiJyTAxNIjsQVSUKqvuu0qJSqBDlEyVTRUSOiaFJZAcGNxwMtUotBadpn2Zcgzh5CyNyMOw9S2QHIrwjsPLJlVhyaglO3ziNKJ8oxDWIYycgogrG3rM2iD3niBwbvwNsFzfPEhERWYmhSUREZCWGJhERkZUYmkRERFZiaBIREVmJoUlERGQlhiYREZGVeHIDIqIyIoRAzqFDyDt3HuqwULhFR0OhUMhdFpUhrmmWk7lz5yIsLAwuLi6Ijo7G4cOH5S6JiMqREAJpU6bgQtxgpE2aZPw7ZQp4/pjKhaFZDlatWoVx48bhvffew7Fjx9C4cWN06dIF6enpcpcm2fV3Gur89yeETdyMOv/9Cbv+TpO7JCK7lnPoEDK+W2nWlvHdSuQc4g/myoShWQ5mzJiB4cOHY/DgwahXrx7mz58PNzc3LFq0SO7SAAA7/0rDkKVHkVtg/AWcWyAwZOlR7D59VebKiOxX3rnzD2g/V7GFULliaJaxvLw8HD16FDExMVKbUqlETEwMDhw4YPExubm50Ol0Zrfy9MqKYxbbX/r2aLnOl6gyU4eFPqA9rGILoXLF0Cxj//77L/R6PQICAszaAwICkJZmeRPotGnT4O3tLd1CQkLKtUbTGqa17URUPLfoaGgH9Ddr0w4cALfoljJVROWBvWdtQHx8PMaNGycN63S6cg1OjZPCYkBqnNjLj6i0FAoFAt99F15duiLv3Dmow8LgFt2SvWcrGYZmGatatSpUKhWuXjXfP3j16lUEBgZafIxGo4FGo6mI8gAA8wY9giFLC2+Knf9cswqrgagyUigUcH80Gu6PRstdCpUTbp4tY2q1Gs2aNcPOnTulNoPBgJ07d6JVq1YyVnbXE3UDsSi2mbRmqXFSYHFcc3SICijmkUREjo1rmuVg3LhxiI2NRfPmzdGyZUvMmjUL2dnZGDx4sNylSZ6oG4jED7rLXQYRkV1haJaDfv364dq1a3j33XeRlpaGJk2aYOvWrYU6BxERkX1RCJ6uwubodDp4e3sjMzMTXl5ecpdDRBWM3wG2i/s0iYiIrMTQJCIishJDk4iIyEoMTSIiIisxNImIiKzE0CQiIrISQ5OIiMhKDE0iIiIrMTSJiIisxNAkIiKyEkOTiIjISgxNIiIiKzE0iYiIrMTQJCIishKvp2nH9Ho98vPz5S7D5jk7O0OlUsldBhFVAgxNOySEQFpaGjIyMuQuxW5otVoEBgZCoVDIXQoR2TGGph0yBaa/vz/c3NwYBEUQQiAnJwfp6ekAgKCgIJkrIiJ7xtC0M3q9XgpMX19fucuxC66urgCA9PR0+Pv7c1MtlYooKIDup5+Qd/4C1KE14NW9OxRO/Ap1NHzF7YxpH6abm5vMldgX0/LKz89naFKJiYICXHzpZWTv2wc4OQEFBcj8cSNCvpoPBd9PDoW9Z+0UN8mWDJcXPQzdTz8ZAxMACgoAANn79kG3ebOMVZEcGJpERMXIO3/BuIZ5Lycn5F24KE9BJBuGJhFRMdShNaQ1TElBAdQ1QuQpiGTD0KQK0759e4wZM6ZQ+5IlS6DVahEWFgaFQvHAW1xcHABg6tSpeOyxx+Dm5gatVluhz4Eck1f37nBv08Y48L81Tvc2beDVo4eMVZEc2BGIbMaRI0eg1+sBAPv370fv3r2RmJgILy8vAHd7webl5aFv375o1aoVvvnmG9nqJcehcHJCyPx5xt6zFy5CXSMEXj16sBOQA2Joks3w8/OT/vfx8QEA+Pv7F1qbnDx5MgDjGipRRVE4OcH7qafkLoNkxtB0UGfSs/DVL8n464oO9YK88GK7SNT095C7LCIim8bQdEBn0rPw1Jx9yC0wQG8QOJ12C5tPXsGPo9owOImIisCOQA7oq1+SpcAEAL1BILfAgAV7k2WujIjItjE0HdBfV3RSYJroDQJ/purKdb5eXl7IzMws1J6RkQFvb+9ynTcRUVlgaDqgekFeUCnNz5CjUipQP9irXOdbp04dHDt2rFD7sWPHULt27XKdNxFRWWBoOqAX20VC46SUglOlVEDjpMSItpHlOt+XX34Z//zzD0aPHo0TJ04gMTERM2bMwHfffYfx48dbPZ0LFy4gISEBFy5cgF6vR0JCAhISEpCVlVWO1RMRsSOQQ6rp74EfR7XBgr3J+DNVh/rBXhjRtvx7z0ZERGDv3r14++23ERMTg7y8PERFRWHNmjXo2rWr1dN59913sXTpUmm4adOmAIDdu3ejffv2ZV02EZFEIYQQxY9GFUmn08Hb2xuZmZnSgf0md+7cQUpKCsLDw+Hi4iJThfaHy43sSVHfASQvbp4lIiKyEkOTiIjISgxNIiIiKzE0S+DcuXMYOnQowsPD4erqisjISLz33nvIy8szG8fSFToOHjwoY+VERFQW2Hu2BE6fPg2DwYCvvvoKNWvWxKlTpzB8+HBkZ2fj008/NRt3x44dqF+/vjTs6+tb0eUSEVEZY2iWQNeuXc0OjYiIiEBiYiLmzZtXKDR9fX0RGBhY0SUSEVE54ubZh5SZmSldxupeTz31FPz9/dGmTRv8+OOPRU4jNzcXOp3O7EZERLaHofkQzpw5g9mzZ+PFF1+U2jw8PPDZZ59hzZo12Lx5M9q0aYNevXoVGZzTpk2Dt7e3dAsJCamI8omIqIR4cgMAEydOxMcff1zkOH///TeioqKk4cuXL6Ndu3Zo3749Fi5cWORjX3jhBaSkpODXX3+1eH9ubi5yc3OlYZ1Oh5CQEJ7coAxxuZE94ckNbBf3aQIYP3484uLiihwnIiJC+j81NRUdOnTAY489hgULFhQ7/ejoaGzfvv2B92s0Gmg0GqvrJSIieXDzLAA/Pz9ERUUVeVOr1QCMa5jt27dHs2bNsHjxYiiVxS/ChIQEBAUFlffTsHnt27fHmDFjCrUvWbIEWq0WYWFhFg/XMd3i4uKsOuyHqCiGnBxcX7gQV96bhOsLF8KQkyN3SWRHuKZZAqbADA0Nxaeffopr165J95l6yi5duhRqtVo6ifi6deuwaNGiYjfhEnDkyBHo9XoAwP79+9G7d28kJiZKm6dcXV1x4MABqw/7IbqfITsb5/oPQG5yMqBUAgYDMn/4EWGrVkLp5iZ3eWQHGJolsH37dpw5cwZnzpxB9erVze67d9fw+++/j/Pnz8PJyQlRUVFYtWoV+vTpU9Hl2h0/Pz/pf1OPZH9/f2i1Wqm9JIf9EN3v5nffGQPTYDDeAOQmJ+PmihXwHTZM5urIHjA0SyAuLq7YfZ+xsbGIjY2tmIIexrV/gN9mAWkngcCGQOsxgJ99Xgj6QYf9EN0v7+IlaQ1TolQi79Il+Yoiu8LQdETX/gEWtAf0dwCDHkj/E/hzAzBij90Fp+mwH65lkjXUIdXNAxMADAao79tyRPQg7AjkiH6bdTcwAePfgjvAb5/LWlZJXb58GV27dkXfvn0xfPhwucshO1Bl4EBoIiONa5tOToBSCU3NmqgycKDcpZGd4JqmI0o7eTcwTYTe2F6OvLy8kJmZWag9IyMD3t7eJZpWSQ/7IQIApZsbwlatxM0VK5B36RLU1aujysCB7AREVmNoOqLAhsZNsvcGp0JlbC9HderUwbZt2wq1Hzt2DLVrW79Z+PLly+jQoUOJDvshMlG6ubHTD5Uav20cUesxgMrFGJSA8a+TC9D6tXKd7csvv4x//vkHo0ePxokTJ5CYmIgZM2bgu+++w/jx462ahumwnxo1akiH/aSlpSEtLa1cayciArim6Zj8ahs7/fz2+T29Z18r905AERER2Lt3L95++23ExMQgLy8PUVFRWLNmjdlhJEWx9rAfIqLywHPP2qCizjvJc6iWDpcb2ROee9Z2cfMsERGRlRiaREREVmJoEhERWYmhSUREZCWGJhERkZUYmkRERFZiaBIREVmJoUlERGQlhiYREZGVGJpUYdq3b48xY8YUal+yZAm0Wi3CwsKgUCgeeDNdAPypp55CjRo14OLigqCgIDz//PNITU2t2CdDRA6J554lm3HkyBHo9cYrr+zfvx+9e/dGYmKidBoxV1dXAECHDh3w1ltvISgoCJcvX8brr7+OPn36YP/+/bLVTkSOgaFJNsPPz0/638fHBwDg7+8PrVZrNt7YsWOl/0NDQzFx4kT06tUL+fn5cHZ2rpBaicgxcfMs2bUbN25g+fLleOyxxxiYRFTuGJoO6mzmWbyz7x303dgX7+x7B2czz8pdUolMmDAB7u7u8PX1xYULF/DDDz/IXRIROQCGpgM6m3kW/Tf1x8azG3H6xmlsPLsR/Tf1t6vgfOONN3D8+HFs27YNKpUKL7zwAq+nWYnlp6cjfcZMXHzpZaTPmIn89HS5SyIHxX2aDmjxycXI0+dBL4ydbvRCjzx9HpacWoIpraeU23y9vLyQmZlZqD0jIwPe3t4lmlbVqlVRtWpV1K5dG3Xr1kVISAgOHjyIVq1alVW5ZCPy09OR8swz0N+4CRgMyNq7Fxnr1iJ83To4+/vLXR45GK5pOqDTN09LgWmiF3qcvnG6XOdbp04dHDt2rFD7sWPHULt27VJP12AwAAByc3NLPQ2yXTe/XS4FJgDAYID+xk3c/Ha5vIWRQ+KapgOKqhKFpJtJZsGpUqgQ5RNVrvN9+eWXMWfOHIwePRrDhg2DRqPB5s2b8d1332Hjxo1WTePQoUM4cuQI2rRpgypVqiA5ORnvvPMOIiMjuZZZSeX+88/dwDQxGJCblCRPQeTQuKbpgAY3HAy1Sg2VQgXAGJhqlRpxDeLKdb4RERHYu3cvTp8+jZiYGERHR2P16tVYs2YNunbtatU03NzcsG7dOnTs2BF16tTB0KFD0ahRI/zyyy/QaDTlWj/JQ1O7NqC876tKqYSmVi15CiKHphDsPWFzdDodvL29kZmZKR3Yb3Lnzh2kpKQgPDwcLi4upZ7H2cyzWHJqCU7fOI0onyjENYhDhHfEw5Zus8pquVHFu3+fJpRKqHyqVOp9mkV9B5C8uHnWQUV4R5Rrpx+isuLs74/wdetw89vlyE1KgqZWLVR5blClDUyybQxNIrJ5zv7+8B83tvgRicoZ92kSERFZiaFJRERkJYYmERGRlRiaREREVmJoEhERWYmhSUREZCWGZgmFhYVBoVCY3T766COzcU6cOIHHH38cLi4uCAkJwSeffCJTtUREVJZ4nGYpTJkyBcOHD5eGPT09pf91Oh06d+6MmJgYzJ8/HydPnsSQIUOg1WoxYsQIOcolIqIywjXNUvD09ERgYKB0c3d3l+5bvnw58vLysGjRItSvXx/9+/fH6NGjMWPGDBkrtg3t27fHmDFjCrUvWbIEWq3W4lr8vbe4uDizx+Xm5qJJkyZQKBRISEiokOdARI6NoVkKH330EXx9fdG0aVNMnz4dBQUF0n0HDhxA27ZtoVarpbYuXbogMTERN2/elKNcu3HkyBFcuXIFV65cwdq1awEAiYmJUtvnn39uNv6bb76J4OBgOUolIgfFzbMlNHr0aDzyyCPw8fHB/v37ER8fjytXrkhrkmlpaQgPDzd7TEBAgHRflSpVCk0zNzfX7FqQOp2uHJ+B7fLz85P+9/HxAQD4+/tDq9UWGnfLli3Ytm0b1q5diy1btlRUiUTk4LimCWDixIlFbhZUKBQ4fdp4geZx48ahffv2aNSoEV566SV89tlnmD179kNdAHnatGnw9vaWbiEhIWX11Cqlq1evYvjw4Vi2bBnc3NzkLoeIHAjXNAGMHz++0P6y+0VEWL5sVnR0NAoKCnDu3DnUqVMHgYGBuHr1qtk4puHAwECL04iPj8e4ceOkYZ1OV+7BmXv2LK4vXIg7f5+GS90o+A4bBs0DnqMtEUIgLi4OL730Epo3b45z587JXRIRORCGJoybBe/dNFgSCQkJUCqV8P/fZYpatWqFt99+G/n5+XB2dgYAbN++HXXq1LG4aRYANBpNhV5AOffsWaT07gORlwfo9cj95x/otmxF+NrvbT44Z8+ejVu3biE+Pl7uUojIAXHzbAkcOHAAs2bNwh9//IGzZ89i+fLlGDt2LJ577jkpEAcOHAi1Wo2hQ4fizz//xKpVq/D555+brUnK7frChVJgAgD0eoi8PFxf+E25ztfLywuZmZmF2jMyMuDt7W3VNHbt2oUDBw5Ao9HAyckJNWvWBAA0b94csbGxZVovlVzu2bNIfestnH36GaS+9RZyz56VuySiMsU1zRLQaDRYuXIlJk2ahNzcXISHh2Ps2LFmgejt7Y1t27Zh5MiRaNasGapWrYp3333Xpo7RvPP36buBaaLX487pv8t1vnXq1MG2bdsKtR87dgy1a9e2ahpffPEFPvjgA2k4NTUVXbp0wapVqxAdHV1mtVLJ2fMWDCJrMTRL4JFHHsHBgweLHa9Ro0b49ddfK6Ci0nGpG4Xcf/4xD06VCi5Rdct1vi+//DLmzJmD0aNHY9iwYdBoNNi8eTO+++47bNy40app1KhRw2zYw8MDABAZGYnq1auXec1kvaK2YAR/OFXe4ojKCDfPOiDfYcOgUKsBlcrYoFJBoVbDd9jQcp1vREQE9u7di9OnTyMmJgbR0dFYvXo11qxZg65du5brvKn8ybUFg6gicU3TAWkiIhC+9ntcX/gN7pz+Gy5RdeE7bGiFbEJr0aKFxU2092vfvj2EEMWOFxYWZtV4VP7k2oJBVJEYmg5KExHBTWZUpnyHDYNuy9a7m2graAsGUUViaBJRmZBzCwZRRWFoElGZ4RYMquzYEYiIiMhKDE0iIiIrMTTtFHuMlgyXFxGVBYamnTGdzzYnJ0fmSuyLaXmZlh8RUWmwI5CdUalU0Gq1SE9PBwC4ublBoVDIXJXtEkIgJycH6enp0Gq1UJlO6EBEVAoMTTtkusSYKTipeFqt9oGXZiMishZD0w4pFAoEBQXB398f+fn5cpdj85ydnbmGSURlgqFpx1QqFcOAiKgCsSMQERGRlRiaREREVmJoEhERWYn7NG2Q6UB8nU4ncyVEJAfTZ58n5bA9DE0bdOvWLQBASEiIzJUQkZxu3boFb29vucugeygEf8rYHIPBgNTUVHh6epbriQt0Oh1CQkJw8eJFeHl5ldt8ypq91g2wdrnYW+1CCNy6dQvBwcFQKrkXzZZwTdMGKZVKVK9evcLm5+XlZRdfJPez17oB1i4Xe6qda5i2iT9hiIiIrMTQJCIishJD04FpNBq899570Gg0cpdSIvZaN8Da5WLPtZNtYUcgIiIiK3FNk4iIyEoMTSIiIisxNImIiKzE0CQiIrISQ9NBzZ07F2FhYXBxcUF0dDQOHz4sd0mFTJs2DS1atICnpyf8/f3Rq1cvJCYmmo3Tvn17KBQKs9tLL70kU8VGkyZNKlRTVFSUdP+dO3cwcuRI+Pr6wsPDA71798bVq1dlrPiusLCwQrUrFAqMHDkSgG0t771796Jnz54IDg6GQqHAhg0bzO4XQuDdd99FUFAQXF1dERMTg6SkJLNxbty4gUGDBsHLywtarRZDhw5FVlZWBT4LsjcMTQe0atUqjBs3Du+99x6OHTuGxo0bo0uXLkhPT5e7NDO//PILRo4ciYMHD2L79u3Iz89H586dkZ2dbTbe8OHDceXKFen2ySefyFTxXfXr1zerad++fdJ9Y8eOxcaNG7FmzRr88ssvSE1NxTPPPCNjtXcdOXLErO7t27cDAPr27SuNYyvLOzs7G40bN8bcuXMt3v/JJ5/giy++wPz583Ho0CG4u7ujS5cuuHPnjjTOoEGD8Oeff2L79u3YtGkT9u7dixEjRlTUUyB7JMjhtGzZUowcOVIa1uv1Ijg4WEybNk3GqoqXnp4uAIhffvlFamvXrp147bXX5CvKgvfee080btzY4n0ZGRnC2dlZrFmzRmr7+++/BQBx4MCBCqrQeq+99pqIjIwUBoNBCGGby1sIIQCI9evXS8MGg0EEBgaK6dOnS20ZGRlCo9GI7777TgghxF9//SUAiCNHjkjjbNmyRSgUCnH58uUKq53sC9c0HUxeXh6OHj2KmJgYqU2pVCImJgYHDhyQsbLiZWZmAgB8fHzM2pcvX46qVauiQYMGiI+PR05OjhzlmUlKSkJwcDAiIiIwaNAgXLhwAQBw9OhR5Ofnmy3/qKgo1KhRw+aWf15eHr799lsMGTLE7MIBtri875eSkoK0tDSz5ezt7Y3o6GhpOR84cABarRbNmzeXxomJiYFSqcShQ4cqvGayDzxhu4P5999/odfrERAQYNYeEBCA06dPy1RV8QwGA8aMGYPWrVujQYMGUvvAgQMRGhqK4OBgnDhxAhMmTEBiYiLWrVsnW63R0dFYsmQJ6tSpgytXrmDy5Ml4/PHHcerUKaSlpUGtVkOr1Zo9JiAgAGlpafIU/AAbNmxARkYG4uLipDZbXN6WmJalpfe56b60tDT4+/ub3e/k5AQfHx+bey3IdjA0yS6MHDkSp06dMts3CMBs/1PDhg0RFBSEjh07Ijk5GZGRkRVdJgCgW7du0v+NGjVCdHQ0QkNDsXr1ari6uspSU2l888036NatG4KDg6U2W1zeRBWJm2cdTNWqVaFSqQr11rx69SoCAwNlqqpoo0aNwqZNm7B79+5iL5kWHR0NADhz5kxFlGYVrVaL2rVr48yZMwgMDEReXh4yMjLMxrG15X/+/Hns2LEDw4YNK3I8W1zeAKRlWdT7PDAwsFDnt4KCAty4ccOmXguyLQxNB6NWq9GsWTPs3LlTajMYDNi5cydatWolY2WFCSEwatQorF+/Hrt27UJ4eHixj0lISAAABAUFlXN11svKykJycjKCgoLQrFkzODs7my3/xMREXLhwwaaW/+LFi+Hv748ePXoUOZ4tLm8ACA8PR2BgoNly1ul0OHTokLScW7VqhYyMDBw9elQaZ9euXTAYDNKPAaJC5O6JRBVv5cqVQqPRiCVLloi//vpLjBgxQmi1WpGWliZ3aWZefvll4e3tLfbs2SOuXLki3XJycoQQQpw5c0ZMmTJF/P777yIlJUX88MMPIiIiQrRt21bWusePHy/27NkjUlJSxG+//SZiYmJE1apVRXp6uhBCiJdeeknUqFFD7Nq1S/z++++iVatWolWrVrLWfC+9Xi9q1KghJkyYYNZua8v71q1b4vjx4+L48eMCgJgxY4Y4fvy4OH/+vBBCiI8++khotVrxww8/iBMnToj//Oc/Ijw8XNy+fVuaRteuXUXTpk3FoUOHxL59+0StWrXEgAEDZHk+ZB8Ymg5q9uzZokaNGkKtVouWLVuKgwcPyl1SIQAs3hYvXiyEEOLChQuibdu2wsfHR2g0GlGzZk3xxhtviMzMTFnr7tevnwgKChJqtVpUq1ZN9OvXT5w5c0a6//bt2+KVV14RVapUEW5ubuLpp58WV65ckbFicz///LMAIBITE83abW1579692+L7IzY2VghhPOzknXfeEQEBAUKj0YiOHTsWek7Xr18XAwYMEB4eHsLLy0sMHjxY3Lp1S4ZnQ/aClwYjIiKyEvdpEhERWYmhSUREZCWGJhERkZUYmkRERFZiaBIREVmJoUlERGQlhiYREZGVGJpEMjt37hwUCgUUCgWaNGny0NMzTev+K6kQ0cNjaBLZiB07dpidK7W0rly5glmzZj18QURUCEOTyEb4+vrC19f3oacTGBgIb2/vMqiIiO7H0CQqQ9euXUNgYCA+/PBDqW3//v1Qq9UlXouMi4tDr1698OGHHyIgIABarRZTpkxBQUEB3njjDfj4+KB69epYvHhxWT8NInoAXoSaqAz5+flh0aJF6NWrFzp37ow6derg+eefx6hRo9CxY8cST2/Xrl2oXr069u7di99++w1Dhw7F/v370bZtWxw6dAirVq3Ciy++iE6dOhV7rVEienhc0yQqY927d8fw4cMxaNAgvPTSS3B3d8e0adNKNS0fHx988cUXqFOnDoYMGYI6deogJycHb731FmrVqoX4+Hio1Wrs27evjJ8FEVnCNU2icvDpp5+iQYMGWLNmDY4ePQqNRlOq6dSvXx9K5d3ftgEBAWjQoIE0rFKp4Ovri/T09IeumYiKxzVNonKQnJyM1NRUGAwGnDt3rtTTcXZ2NhtWKBQW2wwGQ6nnQUTW45omURnLy8vDc889h379+qFOnToYNmwYTp48CX9/f7lLI6KHxDVNojL29ttvIzMzE1988QUmTJiA2rVrY8iQIXKXRURlgKFJVIb27NmDWbNmYdmyZfDy8oJSqcSyZcvw66+/Yt68eXKXR0QPiZtnicpQ+/btkZ+fb9YWFhaGzMzMEk9ryZIlhdr27NlTqO1h9pkSUckwNIlsxGOPPYYmTZpg//79DzUdDw8PFBQUwMXFpYwqIyIThiaRzKpXr46kpCQAKPWhKfdKSEgAYDwchYjKlkIIIeQugoiIyB6wIxAREZGVGJpERERWYmgSERFZiaFJRERkJYYmERGRlRiaREREVmJoEhERWYmhSUREZCWGJhERkZX+HxWMQFqybLUxAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_telescope_positions(\n",
    "        h_range = np.linspace(-4,4,15) * 2*np.pi / 24 * u.rad,\n",
    "        l = LATITUDE,\n",
    "        δ = DECLINATION,\n",
    "        return_image = False,\n",
    "    ):\n",
    "\n",
    "    _, ax = plt.subplots()\n",
    "\n",
    "    # Plot UT trajectory\n",
    "    for i, h in enumerate(h_range):\n",
    "        UTs = project_position(TELESCOPE_POSITIONS, h, l, δ)\n",
    "        for j, UT in enumerate(UTs):\n",
    "            ax.scatter(UT[0], UT[1], label=f\"UT{j+1}\" if i==len(h_range)-1 else None, color=f\"C{j}\", s=1+14*i/len(h_range))\n",
    "\n",
    "    # Plot UT positions at T=0\n",
    "    UTs = project_position(TELESCOPE_POSITIONS, 0*u.hourangle, l, δ)\n",
    "    for UT in UTs[1:]:\n",
    "        ax.scatter(UT[0], UT[1], color=\"black\", marker=\"+\")\n",
    "\n",
    "    ax.set_aspect(\"equal\")\n",
    "    ax.set_xlabel(f\"x [{UTs[0].unit}]\")\n",
    "    ax.set_ylabel(f\"y [{UTs[0].unit}]\")\n",
    "    ax.set_title(f\"Projected telescope positions over the time (8h long)\")\n",
    "    plt.legend()\n",
    "\n",
    "    if return_image:\n",
    "        buffer = BytesIO()\n",
    "        plt.savefig(buffer,format='png')\n",
    "        plt.close()\n",
    "        return buffer.getvalue()\n",
    "    plt.show()\n",
    "\n",
    "# Interactive plot ------------------------------------------------------------\n",
    "\n",
    "def iplot_telescope_positions():\n",
    "    \n",
    "    # GUI elements\n",
    "    h_range = np.linspace(-4,4,15) * 2*np.pi / 24 * u.rad\n",
    "    l_slider = widgets.FloatSlider(\n",
    "        value=LATITUDE.to(u.deg).value,\n",
    "        min=-90,\n",
    "        max=90,\n",
    "        step=0.01,\n",
    "        description='Latitude:',\n",
    "    )\n",
    "    δ_slider = widgets.FloatSlider(\n",
    "        value=DECLINATION.to(u.deg).value,\n",
    "        min=-90,\n",
    "        max=90,\n",
    "        step=0.01,\n",
    "        description='Declination:',\n",
    "    )\n",
    "    reset = widgets.Button(description=\"Reset to defalut\")\n",
    "    plot = widgets.Image(width=500,height=500)\n",
    "\n",
    "    # Callbacks\n",
    "    def update_plot(*_):\n",
    "        plot.value = plot_telescope_positions(\n",
    "            h_range=h_range,\n",
    "            l=l_slider.value*u.deg,\n",
    "            δ=δ_slider.value*u.deg,\n",
    "            return_image=True)\n",
    "\n",
    "    def reset_values(*_):\n",
    "        l_slider.value = LATITUDE.to(u.deg).value\n",
    "        δ_slider.value = DECLINATION.to(u.deg).value\n",
    "\n",
    "    # Triggers\n",
    "    reset.on_click(reset_values)\n",
    "    l_slider.observe(update_plot, 'value')\n",
    "    δ_slider.observe(update_plot, 'value')\n",
    "\n",
    "    # Display\n",
    "    display(widgets.VBox([l_slider, δ_slider, reset, plot]))\n",
    "    update_plot()\n",
    "    return\n",
    "\n",
    "plot_telescope_positions()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🔆 Signal nature\n",
    "\n",
    "The star and the planet are point sources. Seen from a classical telescope, it will result in an image made of the objects convolution with the point spread function (PSF) of the telescope.\n",
    "\n",
    "$$\n",
    "I = O \\otimes PSF\n",
    "$$\n",
    "\n",
    "Here we consider the most simple PSF : the Airy disk. The Airy disk is the diffraction pattern of a point source by a circular aperture. It is given by:\n",
    "\n",
    "$$\n",
    "PSF = \\left(\\frac{2J_1(x)}{x}\\right)^2\n",
    "$$\n",
    "\n",
    "where $J_1$ is the Bessel function of the first kind of order 1 and $x = \\frac{2\\pi r}{\\lambda f}$ is the normalized radius of the Airy disk.\n",
    "\n",
    "Then, we focus the image in a monomode optical fiber which will basically only keep the main lobe of the PSF and reshape it in a Gaussian form. In this process, we lose the spatial information so we have no longer images, but the light flux of each object in the fiber can be simply described by a complex number.\n",
    "\n",
    "Using this formalism, the light flux of the star and the planet can  be described by only 2 complex numbers for each telescope, giving the amplitude and phase of each object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_input_fields(\n",
    "    c: float = 1,\n",
    "    θ: u.Quantity = 0 * u.rad,\n",
    "    α: u.Quantity = 0 * u.rad,\n",
    "    λ: u.Quantity = L,\n",
    "    r: u.Quantity = PROJECTED_TELESCOPE_POSITIONS,\n",
    ") -> np.ndarray[complex]:\n",
    "    \"\"\"\n",
    "    Get the phase of the 4 inputs according to the object and telescope positions.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - c: Contrast with the star\n",
    "    - θ: Angular separation\n",
    "    - α: Parallactic angle\n",
    "    - λ: Wavelength\n",
    "    - r: Projected telescope positions\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of acquired signals (complex amplitudes)\n",
    "    \"\"\"\n",
    "    α = α.to(u.rad).value\n",
    "    θ = θ.to(u.rad).value\n",
    "    λ = λ.to(u.m).value\n",
    "    r = r.to(u.m).value\n",
    "    return get_input_fields_njit(c, θ, α, λ, r)\n",
    "\n",
    "@nb.njit()\n",
    "def get_input_fields_njit(\n",
    "    c: float = 1,\n",
    "    θ: float = 0,\n",
    "    α: float = 0,\n",
    "    λ: float = L.to(u.m).value,\n",
    "    r: np.ndarray[float] = PROJECTED_TELESCOPE_POSITIONS.to(u.m).value,\n",
    ") -> np.ndarray[complex]:\n",
    "    \"\"\"\n",
    "    Get the complexe amplitude of the input signals according to the object and telescopes positions.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - c: Contrast with the star\n",
    "    - θ: Angular separation (in radian)\n",
    "    - α: Parallactic angle (in radian)\n",
    "    - λ: Wavelength (in meter)\n",
    "    - r: Projected telescope positions (in meter)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of acquired signals (complex amplitudes).\n",
    "    \"\"\"\n",
    "\n",
    "    # Array of complex signals\n",
    "    s = np.empty(r.shape[0], dtype=np.complex128)\n",
    "\n",
    "    for i, t in enumerate(r):\n",
    "\n",
    "        # Rotate the projected telescope positions by the parallactic angle\n",
    "        p_rot = t[0] * np.cos(-α) - t[1] * np.sin(-α)\n",
    "\n",
    "        # Compute the phase delay according to the object position\n",
    "        Φ = 2 * np.pi * p_rot * np.sin(θ) / λ\n",
    "\n",
    "        # Build the complex amplitude of the signal\n",
    "        s[i] = np.sqrt(c) * np.exp(1j * Φ)\n",
    "\n",
    "    return s / np.sqrt(r.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def signals_as_str(signals: np.ndarray[complex]) -> str:\n",
    "    \"\"\"\n",
    "    Convert signals to a string.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - signals : Signals to convert.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - String representation of the signals.\n",
    "    \"\"\"\n",
    "\n",
    "    res = \"\"\n",
    "    for i, s in enumerate(signals):\n",
    "        res += f\" - Telescope {i}:   {np.abs(s):.2e} *exp(i* {np.angle(s)/np.pi:.2f} *pi)   ->   {np.abs(s)**2:.2e}\\n\"\n",
    "    return res[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🔉 Photon noise\n",
    "\n",
    "The photon noise is the noise due to the quantization of the light in photons. It is a Poisson noise and can be described by the following formula:\n",
    "\n",
    "$$\n",
    "\\sigma = \\sqrt{N}\n",
    "$$\n",
    "\n",
    "where $N$ is the number of photons.\n",
    "\n",
    "The number of photons can be computed using the Light flux $F_\\lambda$ of the star and the planet, the collecting area $A$ of the telescope, the bandwidth $\\Delta \\lambda$, the transmission efficiency $\\eta$, the magnitude $M$ of the star, and the energy of a photon $E_\\nu$ at the frequency $\\nu$.\n",
    "\n",
    "Light flux is expressed in Jensky:\n",
    "$$\n",
    "1\\:\\text{Jensky} = 1\\:Jy = 10^{-26}\\:W/m^2/Hz = 10^{-26}\\:J/s/m^2/Hz\n",
    "$$\n",
    "The flux $F_\\lambda$ for a star at different wavelengths is given by tables. The following one is an example for AB class stars such as Vega $^1$:\n",
    "\n",
    "| Band | $\\lambda$ ($\\mu m$) | $F_\\lambda$ ($Jy$) |\n",
    "|------|---------------------|--------------------|\n",
    "| V    | 0.55                | 3540               |\n",
    "| J    | 1.21                | 1630               |\n",
    "| H    | 1.65                | 1050               |\n",
    "| K    | 2.17                | 655                |\n",
    "| L    | 3.55                | 276                |\n",
    "\n",
    "The number of acquired photons per second is given by:\n",
    "\n",
    "$$\n",
    "N = F_\\lambda \\times A \\times \\Delta \\nu \\times \\eta \\times 10^{-\\frac{M}{2.5}} / E_\\nu\n",
    "$$\n",
    "\n",
    "where $A$ is the collecting area of the telescope, $\\Delta \\lambda$ is the bandwidth, $\\eta$ is the transmission efficiency of the system, $M$ is the magnitude of the star, and $E_\\nu$ is the energy of a photon at the frequency $\\nu$.\n",
    "\n",
    "We can also express the bandwidth and eneergy in terms of the wavelength:\n",
    "$$\n",
    "\\Delta \\nu = \\frac{c}{\\lambda^2} \\Delta \\lambda\n",
    "$$\n",
    "$$\n",
    "E_\\nu = \\frac{h \\times c}{\\lambda}\n",
    "$$\n",
    "\n",
    "where $c$ is the speed of light, $h$ is the Planck constant.\n",
    "\n",
    "> **References**\n",
    "> 1. Allen's Astrophysical Quantities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nb_photons(\n",
    "        λ:u.Quantity = L,\n",
    "        Δλ:u.Quantity = SPECTRAL_WIDTH,\n",
    "        f:u.Quantity = 1050*u.Jy,\n",
    "        a:u.Quantity = 4 * np.pi * (4*u.m)**2,\n",
    "        η:float = OPTICAL_EFFICIENCY,\n",
    "        m:float = STAR_MAGNITUDE.to(u.mag).value,\n",
    "):\n",
    "    h = const.h.to(u.J * u.s)\n",
    "    c = const.c.to(u.m/u.s)\n",
    "    δν = c/(λ**2) * Δλ\n",
    "    e = h*c/λ\n",
    "\n",
    "    return (f * a * δν * η * 10**(-m/2.5) / e).to(1/u.s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ⚙️ Context parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "STAR_FLUX = nb_photons()\n",
    "STAR_SIGNALS = get_input_fields()\n",
    "\n",
    "for i, companion in enumerate(COMPANIONS):\n",
    "    COMPANIONS[i].update(\n",
    "        {'signals' : get_input_fields(\n",
    "            c=companion['contrast'],\n",
    "            θ=companion['angular_separation'],\n",
    "            α=companion['parallactic_angle'],\n",
    "    )})\n",
    "\n",
    "SHIFTS_TOTAL_OPD = bound_phase_njit(SHIFTS_CE_OFFSET.to(L.unit).value + np.random.normal(0, SHIFTS_CE_RMS.to(L.unit).value, size=14), L.value) * L.unit\n",
    "\n",
    "IDEAL_SHIFTS = bound_phase(-SHIFTS_TOTAL_OPD, L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🏮 MMI\n",
    "\n",
    "The nulling operation is made using Multi Mode Interferometer (MMI). It consist in a multimode waveguide taking several monomode fibers as input and output. The multimode waveguide is shaped in order to produce a specific interference operation, such as spreading the light of an input on all the output, or opposite, gathering the light of all the input on a single output.\n",
    "\n",
    "To design a simple nuller, we then need a 2x2 MMI that gather (ie. create a constructive interference) all the input light on a single output. The other output is then a \"nulled\" output, where there is actually all the inputs light but in phase opposition, resulting in a destructive interference.\n",
    "\n",
    "<div align=center>\n",
    "<img src=\"img/mmi.png\" width=400px>\n",
    "\n",
    "*Numerical simulation of a 3x3 gathering MMI, taken from the paper of Cvetojevic et. al., 2022 $^1$*\n",
    "\n",
    "</div>\n",
    "\n",
    "> **Reference**\n",
    "> 1. Cvetojevic, N. et al., 2022. 3-beam self-calibrated Kernel nulling photonic interferometer. arXiv e-prints. https://doi.org/10.48550/arXiv.2206.04977"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🔀 Recombiner\n",
    "\n",
    "The recombiner is also an MMI that will place the signals in phase quadrature. A particularity is that the output of the recombiner contain a symmetry. We will take advantage of this in the Kernel step.\n",
    "\n",
    "<div align=center>\n",
    "<img src=\"img/recombiner.png\" width=500px>\n",
    "\n",
    "*Action of a 2x2 recombiner MMI, taking 2 different combination of 4 nulled signals as input. Taken from the paper of Romain Laugier et al., 2020 $^1$*\n",
    "\n",
    "</div>\n",
    "\n",
    "In a 2 input case, we can express the recombiner operation using the following matrix:\n",
    "\n",
    "$$  \n",
    "R = \\frac{1}{\\sqrt{2}}\\begin{pmatrix}\n",
    "e^{i\\pi/4} & e^{-i\\pi/4} \\\\\n",
    "e^{-i\\pi/4} & e^{i\\pi/4}\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "> **Reference**\n",
    "> 1. Laugier, R., Cvetojevic, N., Martinache, F., 2020. Kernel nullers for an arbitrary number of apertures. A&A 642, A202. https://doi.org/10.1051/0004-6361/202038866\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit()\n",
    "def cross_recombiner_2x2(beams:np.array) -> np.array:\n",
    "    \"\"\"\n",
    "    Simulate a 2x2 cross recombiner MMI\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - beams: Array of 2 input beams complex amplitudes\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of 2 output beams complex amplitudes\n",
    "    \"\"\"\n",
    "\n",
    "    θ:float=np.pi/2\n",
    "\n",
    "    # Cross recombiner matrix\n",
    "    S = 1/np.sqrt(2) * np.array([\n",
    "        [np.exp(1j*θ/2), np.exp(-1j*θ/2)],\n",
    "        [np.exp(-1j*θ/2), np.exp(1j*θ/2)]\n",
    "    ])\n",
    "\n",
    "    # Operation\n",
    "    return S @ beams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💠 Kernel\n",
    "\n",
    "The idea of the kernel is to acquire and substract the pairs of recombined output. As these pairs share symmetrical properties, this substraction will cancel the star light even with first order phase aberations while keeping the planet light!\n",
    "\n",
    "Moreover, it modify the nuller response (cf. \"Transmission maps\" section below) in an asymetric way which is interesting for us as it gives us more information to constrain the planet position.\n",
    "\n",
    "Demonstration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def demonstration():\n",
    "\n",
    "    # Elements definition\n",
    "    I = sp.IndexedBase(\"I\", real=True)  # Kernel intensity\n",
    "    E = sp.IndexedBase(\"E\")  # Electric field\n",
    "    A = sp.IndexedBase(\"A\", real=True)  # Amplitude\n",
    "    P = sp.IndexedBase(\"phi\", real=True)  # Relative phase\n",
    "    T = sp.IndexedBase(\"theta\", real=True)  # Phase perturbation\n",
    "    a = sp.symbols(\"a\", cls=sp.Idx)  # First dark\n",
    "    b = sp.symbols(\"b\", cls=sp.Idx)  # Second dark\n",
    "    s = sp.symbols(\"s\", cls=sp.Idx)  # Star index\n",
    "    p = sp.symbols(\"p\", cls=sp.Idx)  # Planet index\n",
    "\n",
    "    # Intensity in a dark output is the sum of the intensities coming from the star and from the planet\n",
    "    Ia = I[a, s] + I[a, p]\n",
    "    Ib = I[b, s] + I[b, p]\n",
    "    print(\"Input intensities:\")\n",
    "    display(Ia, Ib)\n",
    "\n",
    "    # Developping Intensities as interference of the electrical fields\n",
    "    Ias = abs(E[1, s] + E[2, s] + E[3, s] + E[4, s]) ** 2\n",
    "    Iap = abs(E[1, p] + E[2, p] + E[3, p] + E[4, p]) ** 2\n",
    "    Ibs = abs(E[1, s] + E[2, s] + E[3, s] + E[4, s]) ** 2\n",
    "    Ibp = abs(E[1, p] + E[2, p] + E[3, p] + E[4, p]) ** 2\n",
    "\n",
    "    Ia = Ia.subs(I[a, s], Ias).subs(I[a, p], Iap)\n",
    "    Ib = Ia.subs(I[b, s], Ibs).subs(I[b, p], Ibp)\n",
    "    print(\"Fields contributions:\")\n",
    "    display(Ia, Ib)\n",
    "\n",
    "    # Expressing the electric fields as a function of the amplitudes and the relative phases\n",
    "    E1s = A[s]\n",
    "    E2s = A[s] * (1 + sp.I * T[2])\n",
    "    E3s = A[s] * (1 + sp.I * T[3])\n",
    "    E4s = A[s] * (1 + sp.I * T[4])\n",
    "    E1p = A[p] * sp.exp(sp.I * P[1])\n",
    "    E2p = A[p] * sp.exp(sp.I * P[2]) * (1 + sp.I * T[2])\n",
    "    E3p = A[p] * sp.exp(sp.I * P[3]) * (1 + sp.I * T[3])\n",
    "    E4p = A[p] * sp.exp(sp.I * P[4]) * (1 + sp.I * T[4])\n",
    "\n",
    "    # Relative phase : E1 -> 0, E2 -> pi, E3 -> pi/2, E4 -> -pi/2\n",
    "    Ia = (\n",
    "        Ia.subs(E[1, s], E1s)\n",
    "        .subs(E[2, s], -E2s)\n",
    "        .subs(E[3, s], sp.I * E3s)\n",
    "        .subs(E[4, s], -sp.I * E4s)\n",
    "    )\n",
    "    Ia = (\n",
    "        Ia.subs(E[1, p], E1p)\n",
    "        .subs(E[2, p], -E2p)\n",
    "        .subs(E[3, p], sp.I * E3p)\n",
    "        .subs(E[4, p], -sp.I * E4p)\n",
    "    )\n",
    "    # Relative phase : E1 -> 0, E2 -> pi, E3 -> -pi/2, E4 -> pi/2\n",
    "    Ib = (\n",
    "        Ib.subs(E[1, p], E1p)\n",
    "        .subs(E[2, p], -E2p)\n",
    "        .subs(E[3, p], -sp.I * E3p)\n",
    "        .subs(E[4, p], sp.I * E4p)\n",
    "    )\n",
    "    Ib = (\n",
    "        Ib.subs(E[1, s], E1s)\n",
    "        .subs(E[2, s], -E2s)\n",
    "        .subs(E[3, s], -sp.I * E3s)\n",
    "        .subs(E[4, s], sp.I * E4s)\n",
    "    )\n",
    "    print(\"Decomposition in amplitudes and phases:\")\n",
    "    display(Ia.expand().simplify(), Ib.expand().simplify())\n",
    "\n",
    "    # Kernel intensity\n",
    "    Ik = Ia - Ib\n",
    "    print(\"Difference between the signals\")\n",
    "    display(Ik.expand().simplify())\n",
    "\n",
    "# demonstration()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🌡️ Thermo-optic phase shifter\n",
    "\n",
    "In practice, we are often limited by the fabrication process of the optical components. The imperfections can lead into phase aberations that will degrade the Kernel-Nuller performance. An attempt to correct these aberations consist in using thermo-optic phase shifters. It consist in a waveguide with a heater that will modify the refractive index of the waveguide and thus the phase of the light passing through it.\n",
    "\n",
    "As the size of the waveguide is very small, the thermal inertia is very low and the phase can be modified very quickly, in a milisecond time scale. This is a very interesting solution to correct phase aberations, even in real time if we encounter variable phase aberation sources.\n",
    "\n",
    "<div align=center>\n",
    "<img src=\"img/thermo-optic_phase_shifter.png\" width=500px>\n",
    "</div>\n",
    "\n",
    "In this simulation, one will simply modelize these phase shifter as a phase shift in the signal.\n",
    "\n",
    "$$\n",
    "P = e^{i\\phi} = e^{i\\frac{2\\pi}{\\lambda} \\Delta L}\n",
    "$$\n",
    "\n",
    "Where $\\phi$ and $\\Delta L$ are proportional to the power injected in the heater."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit()\n",
    "def phase_shift_njit(\n",
    "    ψ: complex | np.ndarray[complex],\n",
    "    δφ: float | np.ndarray[float],\n",
    "    λ: float = L.value,\n",
    ") -> complex | np.ndarray[complex]:\n",
    "    \"\"\"\n",
    "    De-phase the input beam by heating the fiber with an electrical current.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - ψ: input beam complex amplitude\n",
    "    - δφ: phase to add (in same unit as wavelenght)\n",
    "    - λ: wavelength\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Output beam complex amplitude\n",
    "    \"\"\"\n",
    "    return ψ * np.exp(1j * 2 * π * δφ / λ)\n",
    "\n",
    "\n",
    "def phase_shift(\n",
    "    ψ: complex | np.ndarray[complex],\n",
    "    δφ: u.Quantity,\n",
    "    λ: u.Quantity = L\n",
    ") -> complex | np.ndarray[complex]:\n",
    "    \"\"\"\n",
    "    De-phase the input beam by heating the fiber with an electrical current.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - ψ: input beam complex amplitude\n",
    "    - δφ: phase to add\n",
    "    - λ: wavelength\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Output beam complex amplitude\n",
    "    \"\"\"\n",
    "    δφ = δφ.to(λ.unit).value\n",
    "    λ = λ.value\n",
    "    return phase_shift_njit(ψ, δφ, λ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<div align=center>\n",
    "\n",
    "# 💡 **Our approach**\n",
    "\n",
    "</div>\n",
    "\n",
    "## 🏗️ Current architecture\n",
    "\n",
    "To implement the 4 telescope tunable Kernel-Nuller, we splitted the 4x4 MMI into series of 2x2 MMI separated by phase shifters.\n",
    "\n",
    "<div align=center>\n",
    "<img src=\"img/scheme.png\" width=1000px>\n",
    "\n",
    "*Architecture of our Kernel-Nuller. N suqares are the 2x2 nullers, S squares are the 2x2 recombiners and P rectangles are the phase shifters*\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kn_fields(\n",
    "    ψ: np.ndarray[complex],\n",
    "    p: u.Quantity = np.zeros(14) * L.unit,\n",
    "    σ: u.Quantity = SHIFTS_TOTAL_OPD,\n",
    "    λ: u.Quantity = L,\n",
    ") -> tuple[np.ndarray[float], np.ndarray[float], np.ndarray[float], float]:\n",
    "    \"\"\"\n",
    "    Simulate a 4 telescope Kernel-Nuller propagation using a numeric approach\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - ψ: Array of 4 input signals complex amplitudes\n",
    "    - p: Array of 14 injected OPD\n",
    "    - σ: Array of 14 intrasic OPD error\n",
    "    - λ: Wavelength of the light\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of 3 null outputs electric fields\n",
    "    - Array of 6 dark outputs electric fields\n",
    "    - Bright output electric fields\n",
    "    \"\"\"\n",
    "    p = p.to(λ.unit).value\n",
    "    σ = σ.to(λ.unit).value\n",
    "    λ = λ.value\n",
    "    return kn_fields_njit(ψ, p, σ, λ)\n",
    "\n",
    "@nb.njit()\n",
    "def kn_fields_njit(\n",
    "    ψ: np.ndarray[complex],\n",
    "    p: np.ndarray[float] = np.zeros(14),\n",
    "    σ: np.ndarray[float] = SHIFTS_TOTAL_OPD.to(L.unit).value,\n",
    "    λ: float = L.value,\n",
    ") -> tuple[np.ndarray[float], np.ndarray[float], np.ndarray[float], float]:\n",
    "    \"\"\"\n",
    "    Simulate a 4 telescope Kernel-Nuller propagation using a numeric approach\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - ψ: Array of 4 input signals complex amplitudes\n",
    "    - p: Array of 14 injected OPD (in wavelenght unit)\n",
    "    - σ: Array of 14 intrasic OPD error (in wavelenght unit)\n",
    "    - λ: Wavelength of the light\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of 3 null outputs electric fields\n",
    "    - Array of 6 dark outputs electric fields\n",
    "    - Bright output electric fields\n",
    "    \"\"\"\n",
    "\n",
    "    p = bound_phase_njit(p + σ, λ)\n",
    "\n",
    "    # First layer of pahse shifters\n",
    "    nuller_inputs = phase_shift_njit(ψ, p[:4], λ)\n",
    "\n",
    "    # First layer of nulling\n",
    "    N1 = nuller_2x2(nuller_inputs[:2])\n",
    "    N2 = nuller_2x2(nuller_inputs[2:])\n",
    "\n",
    "    # Second layer of phase shifters\n",
    "    N1_shifted = phase_shift_njit(N1, p[4:6], λ)\n",
    "    N2_shifted = phase_shift_njit(N2, p[6:8], λ)\n",
    "\n",
    "    # Second layer of nulling\n",
    "    N3 = nuller_2x2(np.array([N1_shifted[0], N2_shifted[0]]))\n",
    "    N4 = nuller_2x2(np.array([N1_shifted[1], N2_shifted[1]]))\n",
    "\n",
    "    nulls = np.array([N3[1], N4[0], N4[1]], dtype=np.complex128)\n",
    "    bright = N3[0]\n",
    "\n",
    "    # Beam splitting\n",
    "    S_inputs = np.array([N3[1], N3[1], N4[0], N4[0], N4[1], N4[1]]) * 1 / np.sqrt(2)\n",
    "\n",
    "    # Last layer of phase shifters\n",
    "    S_inputs = phase_shift_njit(S_inputs, p[8:], λ)\n",
    "\n",
    "    # Beam mixing\n",
    "    S1_output = cross_recombiner_2x2(np.array([S_inputs[0], S_inputs[2]]))\n",
    "    S2_output = cross_recombiner_2x2(np.array([S_inputs[1], S_inputs[4]]))\n",
    "    S3_output = cross_recombiner_2x2(np.array([S_inputs[3], S_inputs[5]]))\n",
    "\n",
    "    darks = np.array(\n",
    "        [\n",
    "            S1_output[0],\n",
    "            S1_output[1],\n",
    "            S2_output[0],\n",
    "            S2_output[1],\n",
    "            S3_output[0],\n",
    "            S3_output[1],\n",
    "        ],\n",
    "        dtype=np.complex128,\n",
    "    )\n",
    "\n",
    "    return nulls, darks, bright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1.36841400e+06, 1.84151700e+06, 4.68415600e+06, 8.07408551e-04,\n",
       "        7.25157926e-04, 5.86332636e-04]),\n",
       " array([-4.7310300e+05,  4.6841560e+06,  1.3882529e-04]),\n",
       " 5772824139.0)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kn(\n",
    "    ψ: np.ndarray[complex],\n",
    "    p: u.Quantity = np.zeros(14) * L.unit,\n",
    "    σ: u.Quantity = SHIFTS_TOTAL_OPD,\n",
    "    λ: u.Quantity = L,\n",
    "    dt:u.Quantity = DT,\n",
    "    f: float = STAR_FLUX,\n",
    ") -> np.ndarray[float]:\n",
    "    \"\"\"\n",
    "    Simulate a 4 telescope Kernel-Nuller propagation using a numeric approach\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - ψ: Array of 4 input beams complex amplitudes\n",
    "    - p: Array of 14 injected OPD\n",
    "    - σ: Array of 14 intrasic OPD\n",
    "    - λ: Wavelength of the light\n",
    "    - dt: Exposure time\n",
    "    - f: Star flux (in photon/s). If set, the output will be a number of photons. If None, the output will correspond to the throughput.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of 6 dark outputs intensities\n",
    "    - Array of 3 kernels output intensities\n",
    "    - Bright output intensity\n",
    "    \"\"\"\n",
    "    p = p.to(λ.unit).value\n",
    "    σ = σ.to(λ.unit).value\n",
    "    dt = dt.to(u.s).value\n",
    "    f = f.to(1/u.s).value\n",
    "    return kn_njit(ψ, p, σ, λ.value, dt, f)\n",
    "\n",
    "@nb.njit()\n",
    "def kn_njit(\n",
    "    ψ: np.ndarray[complex],\n",
    "    p: u.Quantity = np.zeros(14) * L.unit,\n",
    "    σ: u.Quantity = SHIFTS_TOTAL_OPD,\n",
    "    λ: u.Quantity = L,\n",
    "    dt:float = DT.to(u.s).value,\n",
    "    f: float = STAR_FLUX.to(1/u.s).value,\n",
    ") -> np.ndarray[float]:\n",
    "    \"\"\"\n",
    "    Simulate a 4 telescope Kernel-Nuller propagation using a numeric approach\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - ψ: Array of 4 input beams complex amplitudes\n",
    "    - p: Array of 14 injected OPD\n",
    "    - σ: Array of 14 intrasic OPD\n",
    "    - λ: Wavelength of the light\n",
    "    - dt: Exposure time in seconds\n",
    "    - f: Star flux (in photon/s). If set, the output will be a number of photons. If None, the output will correspond to the throughput.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of 6 dark outputs intensities\n",
    "    - Array of 3 kernels outputs intensities\n",
    "    - Bright output intensity\n",
    "    \"\"\"\n",
    "\n",
    "    _, d, b = kn_fields_njit(ψ, p, σ, λ)\n",
    "\n",
    "    # Get intensities\n",
    "    d = np.abs(d) ** 2\n",
    "    b = np.abs(b) ** 2\n",
    "\n",
    "    # Add photon noise\n",
    "    if f is not None:\n",
    "        for i in range(3):\n",
    "            d[i] = np.random.poisson(np.floor(d[i] * f * dt))\n",
    "        b = np.random.poisson(np.floor(b * f * dt))\n",
    "\n",
    "    # Create kernels\n",
    "    k = np.array([d[0]-d[1], d[2]-d[3], d[4]-d[5]])\n",
    "\n",
    "    return d, k, b\n",
    "\n",
    "kn(np.array([0.5, 0.5, 0.5, 0.5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x750 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_kn_phase_effect(\n",
    "        p=np.zeros(14)*L.unit,\n",
    "        ψ=np.array([1+0j, 1+0j, 1+0j, 1+0j]),\n",
    "        plot=True\n",
    "    ):\n",
    "\n",
    "    ψ1 = np.array([ψ[0], 0, 0, 0])\n",
    "    ψ2 = np.array([0, ψ[1], 0, 0])\n",
    "    ψ3 = np.array([0, 0, ψ[2], 0])\n",
    "    ψ4 = np.array([0, 0, 0, ψ[3]])\n",
    "\n",
    "    n1, d1, b1 = kn_fields(ψ1, p)\n",
    "    n2, d2, b2 = kn_fields(ψ2, p)\n",
    "    n3, d3, b3 = kn_fields(ψ3, p)\n",
    "    n4, d4, b4 = kn_fields(ψ4, p)\n",
    "\n",
    "    # Using first signal as reference\n",
    "    n2 = np.abs(n2) * np.exp(1j * (np.angle(n2) - np.angle(n1)))\n",
    "    n3 = np.abs(n3) * np.exp(1j * (np.angle(n3) - np.angle(n1)))\n",
    "    n4 = np.abs(n4) * np.exp(1j * (np.angle(n4) - np.angle(n1)))\n",
    "    d2 = np.abs(d2) * np.exp(1j * (np.angle(d2) - np.angle(d1)))\n",
    "    d3 = np.abs(d3) * np.exp(1j * (np.angle(d3) - np.angle(d1)))\n",
    "    d4 = np.abs(d4) * np.exp(1j * (np.angle(d4) - np.angle(d1)))\n",
    "    b2 = np.abs(b2) * np.exp(1j * (np.angle(b2) - np.angle(b1)))\n",
    "    b3 = np.abs(b3) * np.exp(1j * (np.angle(b3) - np.angle(b1)))\n",
    "    b4 = np.abs(b4) * np.exp(1j * (np.angle(b4) - np.angle(b1)))\n",
    "    n1 = np.abs(n1) * np.exp(1j * 0)\n",
    "    d1 = np.abs(d1) * np.exp(1j * 0)\n",
    "    b1 = np.abs(b1) * np.exp(1j * 0)\n",
    "\n",
    "    _, axs = plt.subplots(2, 6, figsize=(20, 7.5), subplot_kw={'projection': 'polar'})\n",
    "\n",
    "    # Bright output\n",
    "    axs[0,0].scatter(np.angle(b1), np.abs(b1), color=\"yellow\", label='Input 1', alpha=0.5)\n",
    "    axs[0,0].plot([0, np.angle(b1)], [0, np.abs(b1)], color=\"yellow\", alpha=0.5)\n",
    "    axs[0,0].scatter(np.angle(b2), np.abs(b2), color=\"green\", label='Input 2', alpha=0.5)\n",
    "    axs[0,0].plot([0, np.angle(b2)], [0, np.abs(b2)], color=\"green\", alpha=0.5)\n",
    "    axs[0,0].scatter(np.angle(b3), np.abs(b3), color=\"red\", label='Input 3', alpha=0.5)\n",
    "    axs[0,0].plot([0, np.angle(b3)], [0, np.abs(b3)], color=\"red\", alpha=0.5)\n",
    "    axs[0,0].scatter(np.angle(b4), np.abs(b4), color=\"blue\", label='Input 4', alpha=0.5)\n",
    "    axs[0,0].plot([0, np.angle(b4)], [0, np.abs(b4)], color=\"blue\", alpha=0.5)\n",
    "    axs[0,0].set_title('Bright output')\n",
    "\n",
    "    for n in range(3):\n",
    "        axs[0,n+1].scatter(np.angle(n1[n]), np.abs(n1[n]), color=\"yellow\", label='Input 1', alpha=0.5)\n",
    "        axs[0,n+1].plot([0, np.angle(n1[n])], [0, np.abs(n1[n])], color=\"yellow\", alpha=0.5)\n",
    "        axs[0,n+1].scatter(np.angle(n2[n]), np.abs(n2[n]), color=\"green\", label='Input 2', alpha=0.5)\n",
    "        axs[0,n+1].plot([0, np.angle(n2[n])], [0, np.abs(n2[n])], color=\"green\", alpha=0.5)\n",
    "        axs[0,n+1].scatter(np.angle(n3[n]), np.abs(n3[n]), color=\"red\", label='Input 3', alpha=0.5)\n",
    "        axs[0,n+1].plot([0, np.angle(n3[n])], [0, np.abs(n3[n])], color=\"red\", alpha=0.5)\n",
    "        axs[0,n+1].scatter(np.angle(n4[n]), np.abs(n4[n]), color=\"blue\", label='Input 4', alpha=0.5)\n",
    "        axs[0,n+1].plot([0, np.angle(n4[n])], [0, np.abs(n4[n])], color=\"blue\", alpha=0.5)\n",
    "        axs[0,n+1].set_title(f'Null output {n+1}')\n",
    "\n",
    "    for d in range(6):\n",
    "        axs[1,d].scatter(np.angle(d1[d]), np.abs(d1[d]), color=\"yellow\", label='I1', alpha=0.5)\n",
    "        axs[1,d].plot([0, np.angle(d1[d])], [0, np.abs(d1[d])], color=\"yellow\", alpha=0.5)\n",
    "        axs[1,d].scatter(np.angle(d2[d]), np.abs(d2[d]), color=\"green\", label='I2', alpha=0.5)\n",
    "        axs[1,d].plot([0, np.angle(d2[d])], [0, np.abs(d2[d])], color=\"green\", alpha=0.5)\n",
    "        axs[1,d].scatter(np.angle(d3[d]), np.abs(d3[d]), color=\"red\", label='I3', alpha=0.5)\n",
    "        axs[1,d].plot([0, np.angle(d3[d])], [0, np.abs(d3[d])], color=\"red\", alpha=0.5)\n",
    "        axs[1,d].scatter(np.angle(d4[d]), np.abs(d4[d]), color=\"blue\", label='I4', alpha=0.5)\n",
    "        axs[1,d].plot([0, np.angle(d4[d])], [0, np.abs(d4[d])], color=\"blue\", alpha=0.5)\n",
    "        axs[1,d].set_title(f'Dark output {d+1}')\n",
    "\n",
    "    axs[0, 4].axis(\"off\")\n",
    "    axs[0, 5].axis(\"off\")\n",
    "\n",
    "    axs[0,0].legend()\n",
    "\n",
    "    if not plot:\n",
    "        plot = BytesIO()\n",
    "        plt.savefig(plot, format='png')\n",
    "        plt.close()\n",
    "        return plot.getvalue()\n",
    "    plt.show()\n",
    "\n",
    "plot_kn_phase_effect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🗺️ Transmission maps\n",
    "\n",
    "The nulling technic with two telescope show a limitation: if the planet light arrive on the two telescopes with a phase shift of $2n\\pi$, the light will also be cancelled. It result in a comb-shaped transmission map $^1$, perpendicular to the baseline (there is clear bands where it's optimal to detect the planet and black bands where we will mostly destroy the planet light).\n",
    "\n",
    "The idea of Bracewell was to rotate the baseline in order to let the planet pass through the clear bands at some point. After an entire rotation of the baseline, we will have a sinusoidal signal from which the frequency will indicate us the distance of the planet to it's star, and the phase will give us a clue about the angle between the axes star-planet and the axes of the baseline. Thus, as the transmission map is symmetric, we can constrain the planet position to 2 possible locations, on both sides of the star.\n",
    "\n",
    "Here, we are using 4 telescopes, resulting in more complexe transmission maps than simple combs, but the principle is the same.\n",
    "\n",
    "> **Reference**\n",
    "> 1. Bracewell, R.N., MacPhie, R.H., 1979. Searching for nonsolar planets. Icarus 38, 136–147. https://doi.org/10.1016/0019-1035(79)90093-9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit()\n",
    "def get_uv_map_njit(\n",
    "        N:int=100,\n",
    "        fov:float=FOV.to(u.rad).value\n",
    "    ) -> tuple[np.ndarray[float], np.ndarray[float], np.ndarray[float], np.ndarray[float]]:\n",
    "    \"\"\"\n",
    "    Generate a map of theta and alpha values for a given resolution.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - N: Resolution of the map\n",
    "    - fov: Range of field of view values\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Normalized U map (resolution x resolution)\n",
    "    - Normalized V map (resolution x resolution)\n",
    "    - Theta map (resolution x resolution)\n",
    "    - Alpha map (resolution x resolution)\n",
    "    \"\"\"\n",
    "\n",
    "    # Recreate np.meshgrid() compatible with numba\n",
    "    x = np.zeros((N, N))\n",
    "    y = np.zeros((N, N))\n",
    "    for i, v in enumerate(np.linspace(-1, 1, N)):\n",
    "        x[:, i] = v\n",
    "        y[i, :] = v\n",
    "\n",
    "    theta_map = np.sqrt(x**2 + y**2) * fov\n",
    "    alpha_map = np.arctan2(y, x)\n",
    "    alpha_map = alpha_map % (2*np.pi)\n",
    "\n",
    "    return x, y, theta_map, alpha_map\n",
    "\n",
    "def get_uv_map(\n",
    "    resolution: int = 100,\n",
    "    fov: u.Quantity = FOV,\n",
    ") -> tuple[np.ndarray[float], np.ndarray[float], u.Quantity, u.Quantity]:\n",
    "    \"\"\"\n",
    "    Generate a map of theta and alpha values for a given resolution.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - resolution: Resolution of the map\n",
    "    - fov: Range of field of view values\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Normalized U map (resolution x resolution)\n",
    "    - Normalized V map (resolution x resolution)\n",
    "    - Theta map (resolution x resolution)\n",
    "    - Alpha map (resolution x resolution, in radian)\n",
    "    \"\"\"\n",
    "\n",
    "    x, y, theta_map, alpha_map = get_uv_map_njit(resolution=resolution, fov=fov.to(u.rad).value)\n",
    "\n",
    "    theta_map = (theta_map * u.rad).to(fov.unit)\n",
    "    alpha_map = (alpha_map * u.rad).to(u.rad)\n",
    "\n",
    "    return x, y, theta_map, alpha_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_uv_map():\n",
    "    x, y, θ, α = get_uv_map()\n",
    "\n",
    "    _, axs = plt.subplots(2, 2, figsize=(13, 10))\n",
    "    \n",
    "    im = axs[0, 0].imshow(x, extent=EXTENT, cmap='viridis')\n",
    "    axs[0, 0].set_title(\"U map (px)\")\n",
    "    axs[0, 0].set_xlabel(\"U\")\n",
    "    axs[0, 0].set_ylabel(\"V\")\n",
    "    plt.colorbar(im, ax=axs[0, 0])\n",
    "\n",
    "    im = axs[0, 1].imshow(y, extent=EXTENT, cmap='viridis')\n",
    "    axs[0, 1].set_title(\"V map (px)\")\n",
    "    axs[0, 1].set_xlabel(\"U\")\n",
    "    axs[0, 1].set_ylabel(\"V\")\n",
    "    plt.colorbar(im, ax=axs[0, 1])\n",
    "\n",
    "    im = axs[1, 0].imshow(θ.value, extent=EXTENT, cmap='viridis')\n",
    "    axs[1, 0].set_title(f\"Theta map ({θ.unit})\")\n",
    "    axs[1, 0].set_xlabel(\"U\")\n",
    "    axs[1, 0].set_ylabel(\"V\")\n",
    "    plt.colorbar(im, ax=axs[1, 0])\n",
    "\n",
    "    im = axs[1, 1].imshow(α.value, extent=EXTENT, cmap='viridis')\n",
    "    axs[1, 1].set_title(f\"Alpha map ({α.unit})\")\n",
    "    axs[1, 1].set_xlabel(\"U\")\n",
    "    axs[1, 1].set_ylabel(\"V\")\n",
    "    plt.colorbar(im, ax=axs[1, 1])\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "# plot_uv_map()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit()\n",
    "def αθ_to_xy_njit(\n",
    "        α: float,\n",
    "        θ: float,\n",
    "        fov: float = FOV.to(u.rad).value\n",
    "    ) -> tuple[float, float]:\n",
    "    \"\"\"\n",
    "    Convert alpha and theta values to the x and y angle from the center of the field of view.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - α: Parallactic angle (rad)\n",
    "    - θ: Angular separation (rad)\n",
    "    - fov: Field of view (rad)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - U value\n",
    "    - V value\n",
    "    \"\"\"\n",
    "    \n",
    "    x = θ/fov * np.cos(α)\n",
    "    y = θ/fov * np.sin(α)\n",
    "\n",
    "    return x, y\n",
    "\n",
    "def αθ_to_xy(\n",
    "    α: u.Quantity,\n",
    "    θ: u.Quantity,\n",
    "    fov: u.Quantity = FOV,\n",
    ") -> tuple[u.Quantity, u.Quantity]:\n",
    "    \"\"\"\n",
    "    Convert alpha and theta values to the x and y angle from the center of the field of view.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - α: Parallactic angle\n",
    "    - θ: Angular separation\n",
    "    - fov: Field of view\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - U value\n",
    "    - V value\n",
    "    \"\"\"\n",
    "    α = α.to(u.rad).value\n",
    "    θ = θ.to(u.rad).value\n",
    "    fov = fov.to(u.rad).value\n",
    "    return αθ_to_xy_njit(α, θ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit()\n",
    "def get_transmission_map_njit(\n",
    "    N: int = 100,\n",
    "    p: np.ndarray[float] = np.zeros(14),\n",
    "    σ: np.ndarray[float] = np.zeros(14),\n",
    "    r: np.ndarray[float] = PROJECTED_TELESCOPE_POSITIONS.value,\n",
    ") -> tuple[np.ndarray[complex], np.ndarray[complex], np.ndarray[float]]:\n",
    "    \"\"\"\n",
    "    Generate all the kernel-nuller transmission maps for a given resolution\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - N: Resolution of the map\n",
    "    - p: Array of 14 injected OPD (in wavelenght unit)\n",
    "    - σ: Array of 14 intrasic OPD (in wavelenght unit)\n",
    "    - r: Telescope positions (in meter)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Null outputs map (3 x resolution x resolution)\n",
    "    - Dark outputs map (6 x resolution x resolution)\n",
    "    - Kernel outputs map (3 x resolution x resolution)\n",
    "    \"\"\"\n",
    "\n",
    "    _, _, θ_map, α_map = get_uv_map_njit(N=N)\n",
    "\n",
    "    n_maps = np.zeros((3, N, N), dtype=np.complex128)\n",
    "    d_maps = np.zeros((6, N, N), dtype=np.complex128)\n",
    "    k_maps = np.zeros((3, N, N), dtype=float)\n",
    "\n",
    "    for x in range(N):\n",
    "        for y in range(N):\n",
    "\n",
    "            θ = θ_map[x, y]\n",
    "            α = α_map[x, y]\n",
    "\n",
    "            ψ = get_input_fields_njit(θ=θ, α=α, r=r)\n",
    "\n",
    "            n, d, _ = kn_fields_njit(ψ, p, σ)\n",
    "\n",
    "            k = np.array([np.abs(d[2*i])**2 - np.abs(d[2*i+1])**2 for i in range(3)])\n",
    "\n",
    "            for i in range(3):\n",
    "                n_maps[i, x, y] = n[i]\n",
    "\n",
    "            for i in range(6):\n",
    "                d_maps[i, x, y] = d[i]\n",
    "\n",
    "            for i in range(3):\n",
    "                k_maps[i, x, y] = k[i]\n",
    "\n",
    "    return np.abs(n_maps) ** 2, np.abs(d_maps) ** 2, k_maps\n",
    "\n",
    "\n",
    "def get_transmission_map(\n",
    "    N = 100,\n",
    "    p: u.Quantity = np.zeros(14) * L.unit,\n",
    "    σ: u.Quantity = np.zeros(14) * L.unit,\n",
    "    r: u.Quantity = PROJECTED_TELESCOPE_POSITIONS,\n",
    ") -> tuple[np.ndarray[complex], np.ndarray[complex], np.ndarray[float]]:\n",
    "    \"\"\"\n",
    "    Generate all the kernel-nuller transmission maps for a given resolution\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - N: Resolution of the map\n",
    "    - p: Array of 14 injected OPD\n",
    "    - σ: Array of 14 intrasic OPD\n",
    "    - r: Telescope positions\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Null outputs map (3 x resolution x resolution)\n",
    "    - Dark outputs map (6 x resolution x resolution)\n",
    "    - Kernel outputs map (3 x resolution x resolution)\n",
    "    \"\"\"\n",
    "    p = p.to(L.unit).value\n",
    "    σ = σ.to(L.unit).value\n",
    "    r = r.to(u.m).value\n",
    "\n",
    "    return get_transmission_map_njit(N, p, σ, r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "98287b296b154d8bb8098f30861f88d3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(FloatSlider(value=0.0, description='Hour angle:', max=4.0, min=-4.0, step=0.01), FloatSlider(va…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_transmission_maps(\n",
    "    p: u.Quantity = np.zeros(14) * L.unit,\n",
    "    σ: u.Quantity = np.zeros(14) * L.unit,\n",
    "    N: int = 100,\n",
    "    h: float = 0*u.deg,\n",
    "    l: float = LATITUDE,\n",
    "    δ: float = DECLINATION,\n",
    "    companions: list[dict] = COMPANIONS,\n",
    "    return_plot=False\n",
    ") -> None:\n",
    "    \n",
    "    # Get transmission maps\n",
    "    r = project_position(TELESCOPE_POSITIONS, h=h, l=l, δ=δ)\n",
    "    n_maps, d_maps, k_maps = get_transmission_map(N, p, σ, r)\n",
    "\n",
    "    # Get companions position to plot them\n",
    "    companions_pos = []\n",
    "    for companion in companions:\n",
    "        α = companion[\"parallactic_angle\"]\n",
    "        θ = companion[\"angular_separation\"]\n",
    "        x, y = αθ_to_xy(α, θ)\n",
    "        companions_pos.append((x*np.sqrt(N), y*np.sqrt(N)))\n",
    "\n",
    "    _, axs = plt.subplots(2, 6, figsize=(35, 10))\n",
    "\n",
    "    for i in range(3):\n",
    "        im = axs[0, i].imshow(n_maps[i], aspect=\"equal\", cmap=\"hot\", extent=EXTENT)\n",
    "        axs[0, i].set_title(f\"Nuller output {i+1}\")\n",
    "        plt.colorbar(im, ax=axs[0, i])\n",
    "\n",
    "    for i in range(6):\n",
    "        im = axs[1, i].imshow(d_maps[i], aspect=\"equal\", cmap=\"hot\", extent=EXTENT)\n",
    "        axs[1, i].set_title(f\"Dark output {i+1}\")\n",
    "        axs[1, i].set_aspect(\"equal\")\n",
    "        plt.colorbar(im, ax=axs[1, i])\n",
    "\n",
    "    for i in range(3):\n",
    "        im = axs[0, i + 3].imshow(k_maps[i], aspect=\"equal\", cmap=\"bwr\", extent=EXTENT)\n",
    "        axs[0, i + 3].set_title(f\"Kernel {i+1}\")\n",
    "        plt.colorbar(im, ax=axs[0, i + 3])\n",
    "\n",
    "    for ax in axs.flatten():\n",
    "        ax.set_xlabel(r\"$\\theta_x$\" + f\" ({FOV.unit})\")\n",
    "        ax.set_ylabel(r\"$\\theta_y$\" + f\" ({FOV.unit})\")\n",
    "        ax.scatter(0, 0, color=\"yellow\", marker=\"*\", edgecolors=\"black\")\n",
    "        for x, y in companions_pos:\n",
    "            ax.scatter(x, y, color=\"blue\", edgecolors=\"black\")\n",
    "\n",
    "    transmissions = \"\"\n",
    "    for i, companion in enumerate(companions):\n",
    "        α = companion[\"parallactic_angle\"]\n",
    "        θ = companion[\"angular_separation\"]\n",
    "        s = get_input_fields(θ=θ, α=α)\n",
    "\n",
    "        n, d, b = kn_fields(s, σ=np.zeros(14) * L.unit)\n",
    "\n",
    "        k = np.array([np.abs(d[2*i])**2 - np.abs(d[2*i+1])**2 for i in range(3)])\n",
    "\n",
    "        linebreak = '<br>' if return_plot else '\\n   '\n",
    "        transmissions += '<h2>' if return_plot else ''\n",
    "        transmissions += f\"Companion {i+1} throughputs:\"\n",
    "        transmissions += '</h1>' if return_plot else '\\n----------' + linebreak\n",
    "        transmissions += f\"B: {np.abs(b)**2*100:.2f}%\" + linebreak\n",
    "        transmissions += f\"N: {' | '.join([f'{np.abs(i)**2*100:.2f}%' for i in n])}\" + linebreak\n",
    "        transmissions += f\"D: {' | '.join([f'{np.abs(i)**2*100:.2f}%' for i in d])}\" + linebreak\n",
    "        transmissions += f\"K: {' | '.join([f'{i*100:.2f}%' for i in k])}\" + linebreak\n",
    "\n",
    "    if return_plot:\n",
    "        plot = BytesIO()\n",
    "        plt.savefig(plot, format='png')\n",
    "        plt.close()\n",
    "        return plot.getvalue(), transmissions\n",
    "    plt.show()\n",
    "    print(transmissions)\n",
    "\n",
    "# Interactive plot ------------------------------------------------------------\n",
    "    \n",
    "def iplot_transmission_maps(N=100):\n",
    "\n",
    "    # UI elements\n",
    "    h_slider = widgets.FloatSlider(value=0, min=-DH.value/2, max=DH.value/2, step=0.01, description='Hour angle:')\n",
    "    l_slider = widgets.FloatSlider(value=LATITUDE.to(u.deg).value, min=-90, max=90, step=0.01, description='Latitude:')\n",
    "    δ_slider = widgets.FloatSlider(value=DECLINATION.to(u.deg).value, min=-90, max=90, step=0.01, description='Declination:')\n",
    "    reset = widgets.Button(description=\"Reset values\")\n",
    "    run = widgets.Button(description=\"Run\")\n",
    "    plot = widgets.Image()\n",
    "    transmission = widgets.HTML()\n",
    "\n",
    "    def update_plot(*args):\n",
    "        run.button_style = \"warning\"\n",
    "        \n",
    "        img, txt = plot_transmission_maps(\n",
    "            N=N,\n",
    "            h=h_slider.value*u.deg,\n",
    "            l=l_slider.value*u.deg,\n",
    "            δ=δ_slider.value*u.deg,\n",
    "            return_plot=True\n",
    "        )\n",
    "        plot.value = img\n",
    "        transmission.value = txt\n",
    "        \n",
    "        run.button_style = \"\"\n",
    "\n",
    "    def reset_values(*args):\n",
    "        h_slider.value = 0\n",
    "        l_slider.value = LATITUDE.to(u.deg).value\n",
    "        δ_slider.value = DECLINATION.to(u.deg).value\n",
    "        run.color = \"blue\"\n",
    "        enable_run()\n",
    "\n",
    "    def enable_run(*args):\n",
    "        run.button_style = \"success\"\n",
    "    \n",
    "    reset.on_click(reset_values)\n",
    "    h_slider.observe(enable_run)\n",
    "    l_slider.observe(enable_run)\n",
    "    δ_slider.observe(enable_run)\n",
    "    run.on_click(update_plot)\n",
    "    display(widgets.VBox([h_slider, l_slider, δ_slider, widgets.HBox([reset, run]), plot, transmission]))\n",
    "    update_plot()\n",
    "\n",
    "iplot_transmission_maps(N=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<div align=center>\n",
    "\n",
    "# 🪛 **Calibration**\n",
    "\n",
    "</div>\n",
    "\n",
    "## 🫳 Manual shift controls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a4f96cbe198d47ca98bb1956952904f7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HTML(value='<h1>Inputs</h1>'), HTML(value='Amplitude:'), HBox(children=(FloatSlider(value=0.5, …"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def manual_shift_control():\n",
    "    step = 1e-20\n",
    "\n",
    "    # Build sliders -----------------------------------------------------------\n",
    "\n",
    "    # Input amplitude\n",
    "    IA_sliders = [\n",
    "        widgets.FloatSlider(\n",
    "            value=1/np.sqrt(4), min=0, max=1, step=step, description=f\"I{i+1}\",\n",
    "            continuous_update=False,\n",
    "        )\n",
    "        for i in range(4)\n",
    "    ]\n",
    "\n",
    "    # Input phase\n",
    "    IP_sliders = [\n",
    "        widgets.FloatSlider(\n",
    "            value=0, min=0, max=L.value, step=step, description=f\"I{i+1}\",\n",
    "            continuous_update=False,\n",
    "        )\n",
    "        for i in range(4)\n",
    "    ]\n",
    "\n",
    "    # Shifter phase\n",
    "    P_sliders = [\n",
    "        widgets.FloatSlider(\n",
    "            value=0, min=0, max=L.value, step=step, description=f\"P{i+1}\",\n",
    "            continuous_update=False,\n",
    "        )\n",
    "        for i in range(14)\n",
    "    ]\n",
    "\n",
    "    # Build GUI ---------------------------------------------------------------\n",
    "\n",
    "    def beam_repr(beam: complex) -> str:\n",
    "        return f\"<b>{np.abs(beam):.2e}</b> * exp(<b>{np.angle(beam)/np.pi:.2f}</b> pi i)\"\n",
    "\n",
    "    inputs = [widgets.HTML(value=f\" \") for _ in range(4)]\n",
    "    null_outputs = [widgets.HTML(value=f\" \") for _ in range(4)]\n",
    "    dark_outputs = [widgets.HTML(value=f\" \") for _ in range(6)]\n",
    "    kernel_outputs = [widgets.HTML(value=f\" \") for _ in range(3)]\n",
    "\n",
    "    def update_gui(*args):\n",
    "\n",
    "        ψ = np.array([\n",
    "            IA_sliders[i].value * np.exp(1j * IP_sliders[i].value / L.value * 2 * np.pi)\n",
    "            for i in range(4)\n",
    "        ])\n",
    "\n",
    "        n, d, b = kn_fields(ψ=ψ, p=np.array([x.value for x in P_sliders]) * L.unit)\n",
    "\n",
    "        k = np.array([\n",
    "            np.abs(d[2*i])**2 - np.abs(d[2*i+1])**2\n",
    "        for i in range(3)])\n",
    "\n",
    "        for i, beam in enumerate(ψ):\n",
    "            inputs[i].value = (\n",
    "                f\"<b>Input {i+1} -</b> Amplitude: <code>{beam_repr(beam)}</code> Intensity: <code><b>{np.abs(beam)**2*100:.1f}%</b></code>\"\n",
    "            )\n",
    "        null_outputs[0].value = (\n",
    "            f\"<b>N3a -</b> Amplitude: <code>{beam_repr(b)}</code> Intensity: <code><b>{np.abs(b)**2*100:.1f}%</b></code> <b><- Bright channel</b>\"\n",
    "        )\n",
    "        for i, beam in enumerate(n):\n",
    "            null_outputs[i + 1].value = (\n",
    "                f\"<b>N{(i-1)//2+4}{['a','b'][(i+1)%2]} -</b> Amplitude: <code>{beam_repr(beam)}</code> Intensity: <code><b>{np.abs(beam)**2*100:.1f}%</b></code>\"\n",
    "            )\n",
    "        for i, beam in enumerate(d):\n",
    "            dark_outputs[i].value = (\n",
    "                f\"<b>Dark {i+1} -</b> Amplitude: <code>{beam_repr(beam)}</code> Intensity: <code><b>{np.abs(beam)**2*100:.1f}%</b></code>\"\n",
    "            )\n",
    "        for i, beam in enumerate(k):\n",
    "            kernel_outputs[i].value = (\n",
    "                f\"<b>Kernel {i+1} -</b> Value: <code>{beam:.2e}</code>\"\n",
    "            )   \n",
    "            \n",
    "        # fig, ax = plt.subplots(1, 1, figsize=(5, 5))\n",
    "\n",
    "        phases.value = plot_kn_phase_effect(\n",
    "            ψ = ψ,\n",
    "            p = np.array([p.value for p in P_sliders])*L.unit,\n",
    "            plot = False\n",
    "            )\n",
    "\n",
    "        # Plot intensities\n",
    "        for i in range(len(ψ)):\n",
    "            plt.imshow([[np.abs(ψ[i])**2,],], cmap=\"hot\", vmin=0, vmax=np.sum(np.abs(ψ)**2))\n",
    "            plt.savefig(fname=f\"img/tmp.png\", format=\"png\")\n",
    "            plt.close()\n",
    "            with open(\"img/tmp.png\", \"rb\") as file:\n",
    "                image = file.read()\n",
    "                photometric_cameras[i].value = image\n",
    "        for i in range(len(n)+1):\n",
    "            if i == 0:\n",
    "                plt.imshow([[np.abs(b)**2,],], cmap=\"hot\", vmin=0, vmax=np.sum(np.abs(n)**2) + np.abs(b)**2)\n",
    "            else:\n",
    "                plt.imshow([[np.abs(n[i-1])**2,],], cmap=\"hot\", vmin=0, vmax=np.sum(np.abs(n)**2) + np.abs(b)**2)\n",
    "            plt.savefig(fname=f\"img/tmp.png\", format=\"png\")\n",
    "            plt.close()\n",
    "            with open(\"img/tmp.png\", \"rb\") as file:\n",
    "                image = file.read()\n",
    "                null_cameras[i].value = image\n",
    "        for i in range(len(d)):\n",
    "            plt.imshow([[np.abs(d[i])**2,],], cmap=\"hot\", vmin=0, vmax=np.sum(np.abs(d)**2))\n",
    "            plt.savefig(fname=f\"img/tmp.png\", format=\"png\")\n",
    "            plt.close()\n",
    "            with open(\"img/tmp.png\", \"rb\") as file:\n",
    "                image = file.read()\n",
    "                dark_cameras[i].value = image\n",
    "        for i in range(len(k)):\n",
    "            plt.imshow([[k[i],],], cmap=\"bwr\", vmin=-np.max(np.abs(k)), vmax=np.max(np.abs(k)))\n",
    "            plt.savefig(fname=f\"img/tmp.png\", format=\"png\")\n",
    "            plt.close()\n",
    "            with open(\"img/tmp.png\", \"rb\") as file:\n",
    "                image = file.read()\n",
    "                kernel_cameras[i].value = image\n",
    "\n",
    "        os.remove(\"img/tmp.png\")\n",
    "\n",
    "        return b, d\n",
    "    \n",
    "    photometric_cameras = [widgets.Image(width=50,height=50) for _ in range(4)]\n",
    "    null_cameras = [widgets.Image(width=50,height=50) for _ in range(4)]\n",
    "    dark_cameras = [widgets.Image(width=50,height=50) for _ in range(6)]\n",
    "    kernel_cameras = [widgets.Image(width=50,height=50) for _ in range(3)]\n",
    "    phases = widgets.Image()\n",
    "\n",
    "    vbox = widgets.VBox(\n",
    "        [\n",
    "            widgets.HTML(\"<h1>Inputs</h1>\"),\n",
    "            widgets.HTML(\"Amplitude:\"),\n",
    "            widgets.HBox(IA_sliders[:4]),\n",
    "            widgets.HTML(\"Phase:\"),\n",
    "            widgets.HBox(IP_sliders[:4]),\n",
    "            *[widgets.HBox([photometric_cameras[i], x]) for i, x in enumerate(inputs)],\n",
    "            widgets.HTML(\"<h1>Phases</h1>\"),\n",
    "            phases,\n",
    "            widgets.HTML(\"<h1>Nuller</h1>\"),\n",
    "            widgets.HBox(P_sliders[:4]),\n",
    "            widgets.HBox(P_sliders[4:8]),\n",
    "            *[widgets.HBox([null_cameras[i], x]) for i, x in enumerate(null_outputs)],\n",
    "            widgets.HTML(\"<h1>Recombiner</h1>\"),\n",
    "            widgets.HBox(P_sliders[8:11]),\n",
    "            widgets.HBox(P_sliders[11:14]),\n",
    "            *[widgets.HBox([dark_cameras[i], x]) for i, x in enumerate(dark_outputs)],\n",
    "            widgets.HTML(\"<h1>Kernels</h1>\"),\n",
    "            *[widgets.HBox([kernel_cameras[i], x]) for i, x in enumerate(kernel_outputs)],\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    # Link sliders to update function ------------------------------------------\n",
    "\n",
    "    for widget in P_sliders:\n",
    "        widget.observe(update_gui, \"value\")\n",
    "    for widget in IA_sliders:\n",
    "        widget.observe(update_gui, \"value\")\n",
    "    for widget in IP_sliders:\n",
    "        widget.observe(update_gui, \"value\")\n",
    "\n",
    "    update_gui()\n",
    "    return vbox\n",
    "\n",
    "manual_shift_control()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 👁️ Input obstruction\n",
    "\n",
    "En obstruant successivement une paire d'entrées, il est possible de simplifier le problème d'optimisation en ne jouant que sur un seul paramètre et en ne regardant qu'une seule sortie.\n",
    "\n",
    "Il existe différentes façon de procéder. Je ne vais détailler ici que l'une d'entre elles.\n",
    "\n",
    "On commence par obstruer les entrées $I_2$ et $I_3$. Au regard de l'architectue de notre composant, on peut alors décrire la fonction de transfert pour la sortie brillante $B$\n",
    "\n",
    "$$\n",
    "B = \\left|\\left(a_1 e^{i(\\theta_1 + \\sigma_1 + \\phi_1)} + a_2 e^{i(\\theta_2 + \\sigma_2 + \\phi_2)}\\right) e^{i(\\sigma_5 + \\phi_5)}\\right|^2\n",
    "$$\n",
    "\n",
    "Où $a_n$ et $\\theta_n$ représentent respectivement l'amplitude et la phase des signaux d'entrée. $\\sigma_n$ correspond à la perturbation de phase (inconnue) associé au retardateur $n$ et $\\phi_n$ est la phase que l'on inject volontairement via le retardateur pour tenter de compenser cette perturbation.\n",
    "\n",
    "La calibration se faisant en laboatoire, on peut supposer une intensité totale fixée à $1$ (unité arbitraire) et que chaque entrée recçoi le même flux soit $a_1 = a_2 = 1/\\sqrt{2}$, et parfaitement cophasé, soit $\\theta_1 = \\theta_2 = \\theta$. Etant donné que l'on a accès qu'a l'intensité du signal, nous sommes insensible à la phase globale, ce qui permet de simplifier l'équation précédente :\n",
    "\n",
    "$$\n",
    "B = \\frac{1}{2} \\left|e^{i(\\sigma_1 + \\phi_1)} + e^{i(\\sigma_2 + \\phi_2)}\\right|^2\n",
    "$$\n",
    "\n",
    "En maximisant $B$, on devrait alors trouver $1$ ce qui implique que\n",
    "\n",
    "$$\n",
    "\\sigma_1 + \\phi_1 = \\sigma_2 + \\phi_2\n",
    "$$\n",
    "\n",
    "On peut utiliser $\\phi_1$ comme référence (phase globale) et ainsi le fixer à 0, ce qui donne alors\n",
    "\n",
    "$$\n",
    "\\phi_2 = \\sigma_1 - \\sigma_2\n",
    "$$\n",
    "\n",
    "On peut alors soit effectuer différentes mesures de $B$ à $\\phi_2$ fixé et en déduire $\\sigma_1$ et $\\sigma_2$ par résolution d'un système déquation, soit trouver dichotomiquement la valeur de $\\phi_2$ qui maximise $B$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.01733122 0.04101019 0.00711565 0.         0.\n",
      " 0.         1.61683559 0.82032652 0.38629074 0.         0.2457181\n",
      " 0.         0.        ] um\n"
     ]
    }
   ],
   "source": [
    "def input_obstruction(verbose = False):\n",
    "\n",
    "    b_history = []\n",
    "    k_history = []\n",
    "    p_history = []\n",
    "\n",
    "    a = (1+0j) / 4 * np.sqrt(STAR_FLUX)\n",
    "    p = np.zeros(14) * L.unit\n",
    "\n",
    "    def maximize_bright(n, p):\n",
    "        Δφ = L/2\n",
    "        ε = 1e-6 * L\n",
    "\n",
    "        _, k, b_old = kn(ψ, p)\n",
    "\n",
    "        log = \"\"\n",
    "        while Δφ > ε:\n",
    "            s = np.zeros(14) * L.unit\n",
    "            s[n-1] = Δφ\n",
    "            _, _, b_pos = kn(ψ, p+s)\n",
    "            _, _, b_neg = kn(ψ, p-s)\n",
    "            \n",
    "            log += \"Shift \" + color.black(color.on_lightgrey(f\"{p}\")) + \" Bright: \" + color.black(color.on_green(f\"{b_neg:.2e} | {b_old:.2e} | {b_pos:.2e}\")) + \" -> \"\n",
    "\n",
    "            if b_pos > b_old and b_pos > b_neg:\n",
    "                p += s\n",
    "                log += color.black(color.on_green(\" + \"))\n",
    "            elif b_neg > b_old and b_neg > b_pos:\n",
    "                p -= s\n",
    "                log += color.black(color.on_green(\" - \"))\n",
    "            else:\n",
    "                log += color.black(color.on_green(\" = \"))\n",
    "            log += '\\n'\n",
    "\n",
    "            p = bound_phase(p)\n",
    "\n",
    "            _, k, b_old = kn(ψ, p)\n",
    "\n",
    "            p_history.append(np.copy(p))\n",
    "            b_history.append(b_old)\n",
    "            k_history.append(np.sum(np.abs(k)))\n",
    "            Δφ /= 2\n",
    "        \n",
    "        if verbose:\n",
    "            print(log)\n",
    "\n",
    "        return p\n",
    "\n",
    "    def minimize_kernel(n, k, p=p):\n",
    "        Δφ = L/2\n",
    "        ε = 1e-6 * L\n",
    "\n",
    "        _, k, b = kn(ψ, p)\n",
    "        k_old = np.sum(np.abs(k))\n",
    "\n",
    "        log = \"\"\n",
    "        while Δφ > ε:\n",
    "            s = np.zeros(14) * L.unit\n",
    "            s[n-1] = Δφ\n",
    "            _, k_pos, _ = kn(ψ, p+s)\n",
    "            _, k_neg, _ = kn(ψ, p-s)\n",
    "\n",
    "            k_pos = np.sum(np.abs(k_pos))\n",
    "            k_neg = np.sum(np.abs(k_neg))\n",
    "            \n",
    "            log += \"Shift \" + color.black(color.on_lightgrey(f\"{n}\")) + \" Kernel: \" + color.black(color.on_green(f\"{k_neg:.2e} | {k_old:.2e} | {k_pos:.2e}\")) + \" -> \"\n",
    "            if k_pos < k_old and k_pos < k_neg:\n",
    "                p += s\n",
    "                log += color.black(color.on_green(\" + \"))\n",
    "            elif k_neg < k_old and k_neg < k_pos:\n",
    "                p -= s\n",
    "                log += color.black(color.on_green(\" - \"))\n",
    "            else:\n",
    "                log += color.black(color.on_green(\" = \"))\n",
    "            log += '\\n'\n",
    "\n",
    "            p = bound_phase(p)\n",
    "\n",
    "            _, k, b = kn(ψ, p)\n",
    "            k_old = np.sum(np.abs(k))\n",
    "\n",
    "            p_history.append(np.copy(p))\n",
    "            b_history.append(b)\n",
    "            k_history.append(np.sum(np.abs(k)))\n",
    "            Δφ /= 2\n",
    "        \n",
    "        if verbose:\n",
    "            print(log)\n",
    "        \n",
    "        return p\n",
    "\n",
    "    def minimize_darks(n, ds, p=p):\n",
    "        ds = np.array(ds) - 1\n",
    "        Δφ = L/2\n",
    "        ε = 1e-6 * L\n",
    "\n",
    "        d, k, b = kn(ψ, p)\n",
    "        d_old = np.sum(np.abs(d[ds]))\n",
    "\n",
    "        log = \"\"\n",
    "        while Δφ > ε:\n",
    "            s = np.zeros(14) * L.unit\n",
    "            s[n-1] = Δφ\n",
    "            d_pos, k_pos, b_pos = kn(ψ, p+s)\n",
    "            d_neg, k_neg, b_neg = kn(ψ, p-s)\n",
    "\n",
    "            d_pos = np.sum(np.abs(d_pos[ds]))\n",
    "            d_neg = np.sum(np.abs(d_neg[ds]))\n",
    "            \n",
    "            log += \"Shift \" + color.black(color.on_lightgrey(f\"{n}\")) + f\" Dark{ds}: \" + color.black(color.on_green(f\"{d_neg:.2e} | {d_old:.2e} | {d_pos:.2e}\")) + \" -> \"\n",
    "            if d_pos < d_old and d_pos < d_neg:\n",
    "                p += s\n",
    "                log += color.black(color.on_green(\" + \"))\n",
    "            elif d_neg < d_old and d_neg < d_pos:\n",
    "                p -= s\n",
    "                log += color.black(color.on_green(\" - \"))\n",
    "            else:\n",
    "                log += color.black(color.on_green(\" = \"))\n",
    "            log += '\\n'\n",
    "\n",
    "            p = bound_phase(p)\n",
    "\n",
    "            d, k, b = kn(ψ, p)\n",
    "            d_old = np.sum(np.abs(d[ds]))\n",
    "\n",
    "            p_history.append(np.copy(p))\n",
    "            b_history.append(b)\n",
    "            k_history.append(np.sum(np.abs(k)))\n",
    "            Δφ /= 2\n",
    "        \n",
    "        if verbose:\n",
    "            print(log)\n",
    "        \n",
    "        return p\n",
    "\n",
    "    def invert_shifter(n, p=p):\n",
    "        p[n-1] = bound_phase(p[n-1] + L/2)\n",
    "        return p\n",
    "\n",
    "    # Bright maximization\n",
    "    ψ = np.array([a, a, 0, 0])\n",
    "    p = maximize_bright(2, p)\n",
    "\n",
    "\n",
    "    ψ = np.array([0, 0, a, a])\n",
    "    p = maximize_bright(4, p)\n",
    "\n",
    "    ψ = np.array([a, 0, a, 0])\n",
    "    p = maximize_bright(3, p)\n",
    "    p[3] = bound_phase(p[2] + p[3])\n",
    "\n",
    "    # Darks minimization\n",
    "    ψ = np.array([a, 0, a, 0])\n",
    "    p = minimize_darks(8, [3,4], p)\n",
    "\n",
    "    # Kernel minimization\n",
    "    ψ = np.array([a, a, 0, 0])\n",
    "    p = invert_shifter(2, p)\n",
    "    p = minimize_kernel(12, 3, p)\n",
    "    p = invert_shifter(2, p)\n",
    "\n",
    "    ψ = np.array([a, 0, a, 0])\n",
    "    p = invert_shifter(3, p)\n",
    "    p = minimize_kernel(10, 2, p)\n",
    "    p = invert_shifter(3, p)\n",
    "\n",
    "    ψ = np.array([a, 0, 0, a])\n",
    "    p = invert_shifter(4, p)\n",
    "    p = minimize_kernel(9, 1, p)\n",
    "    p = invert_shifter(4, p)\n",
    "\n",
    "    return p, {'bright':np.array(b_history), 'kernel':np.array(k_history), 'shifts':np.array(p_history)}\n",
    "\n",
    "CALIBRATED_SHIFTS_IB, CALIBRATION_HISTORY_IB = input_obstruction(verbose=False)\n",
    "\n",
    "print(CALIBRATED_SHIFTS_IB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_optimization_history_ib():\n",
    "    bright_evol, kernel_evol, shifts_evol = CALIBRATION_HISTORY_IB[\"bright\"], CALIBRATION_HISTORY_IB[\"kernel\"], CALIBRATION_HISTORY_IB[\"shifts\"]\n",
    "\n",
    "    _, axs = plt.subplots(3, 1, figsize=(15,15))\n",
    "\n",
    "    axs[0].plot(bright_evol)\n",
    "    axs[0].set_xlabel(\"Number of iterations\")\n",
    "    axs[0].set_ylabel(\"Bright throughput (%)\")\n",
    "    axs[0].set_yscale(\"log\")\n",
    "    axs[0].set_title(\"Optimization of the bright output\")\n",
    "\n",
    "    axs[1].plot(kernel_evol)\n",
    "    axs[1].set_xlabel(\"Number of iterations\")\n",
    "    axs[1].set_ylabel(\"Kernels throughput (%)\")\n",
    "    axs[1].set_yscale(\"log\")\n",
    "    axs[1].set_title(\"Optimization of the kernels\")\n",
    "\n",
    "    for i in range(shifts_evol.shape[1]):\n",
    "        axs[2].plot(shifts_evol[:,i], label=f\"Shifter {i+1}\")\n",
    "    axs[2].set_xlabel(\"Number of iterations\")\n",
    "    axs[2].set_ylabel(\"Phase shift\")\n",
    "    axs[2].set_yscale(\"linear\")\n",
    "    axs[2].set_title(\"Convergeance of the phase shifters\")\n",
    "    axs[2].legend(loc='upper right')\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "plot_optimization_history_ib()\n",
    "plot_kn_phase_effect(shifts=CALIBRATED_SHIFTS_IB)\n",
    "plot_transmission_maps(shifts=CALIBRATED_SHIFTS_IB, shifts_total_opd=SHIFTS_TOTAL_OPD)\n",
    "\n",
    "kn(STAR_SIGNALS, CALIBRATED_SHIFTS_IB, reference_flux=STAR_FLUX)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🧬 Genetic algorithm\n",
    "\n",
    "### Algorithm\n",
    "\n",
    "in order to get the best shifts to inject to optimize the component performances, I made a genetic algorithme that iteratively mutate a shifter and keep the mutation if it minimize the associated metric. All the shifters that act on the bright channel are associated with the bright metric that must be maximized\n",
    "\n",
    "$$\n",
    "M_B = |B|^2\n",
    "$$\n",
    "\n",
    "While the other shifters are associated with the kernel metric that must be minimized.\n",
    "\n",
    "$$\n",
    "M_K = |K_1|^2 + |K_2|^2 + |K_3|^2\n",
    "$$\n",
    "\n",
    "Merging these two metrics can induce local minimum since improving the bright metric can deterior the kernel metric. This separation is then necessary to ensure reaching a global minimum (empirically demonstrated)\n",
    "\n",
    "> **Acknowledgment**\n",
    "> - Romain Laugier for the idea of merging the metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calibrate(verbose: bool = False) -> tuple[u.Quantity, dict[str, np.ndarray[float]]]:\n",
    "    \"\"\"\n",
    "    Optimize the phase shifters offsets to maximize the nulling performance\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - kn: Kernel-Nuller object\n",
    "    - beams: List of input beams complex amplitudes\n",
    "    - verbose: Boolean, if True, print the optimization process\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of optimized phase shifters offsets\n",
    "    - Dict containing the history of the optimization\n",
    "    \"\"\"\n",
    "\n",
    "    shifts = np.zeros(14) * L.unit\n",
    "    signals = get_input_fields(norm=STAR_FLUX, angular_separation=0*u.mas)\n",
    "\n",
    "    treshold = 1e-6 * L.unit # Minimum shift step size\n",
    "    decay = 1.01  # Decay factor for the step size (delta /= decay)\n",
    "\n",
    "    # Shifters that contribute to redirecting light to the bright output\n",
    "    # p1 = [2,3,4,5,7]\n",
    "    p1 = [1, 2, 3, 4, 5, 7]\n",
    "    # p1 = [2, 4, 7]\n",
    "    # p1 = [2, 3, 4]\n",
    "\n",
    "    # Shifters that contribute to the symmetry of the dark outputs\n",
    "    # p2 = [6,8,11,13,14]\n",
    "    p2 = [6, 8, 9, 10, 11, 12, 13, 14]\n",
    "    # p2 = [8, 11, 13, 14]\n",
    "    # p2 = [6, 9, 10, 12]\n",
    "\n",
    "    # History of the optimization\n",
    "    bright_history = []\n",
    "    asymmetry_history = []\n",
    "    metric_history = []\n",
    "    shifters_history = []\n",
    "\n",
    "    delta = L / 4\n",
    "    while delta > treshold:\n",
    "\n",
    "        if verbose:\n",
    "            print(color.black(color.on_red(f\"--- New iteration ---\")), f\"Delta={delta:.2e}\")\n",
    "\n",
    "        for p in p1 + p2:\n",
    "            log = \"\"\n",
    "\n",
    "            # Step vector\n",
    "            step = np.zeros(14) * L.unit\n",
    "            step[p - 1] = delta\n",
    "\n",
    "            # Apply the step\n",
    "            _, kernels_old, bright_old = kn(beams=signals, shifts=shifts)\n",
    "            _, kernels_pos, bright_pos = kn(beams=signals, shifts=shifts + step)\n",
    "            _, kernels_neg, bright_neg = kn(beams=signals, shifts=shifts - step)\n",
    "\n",
    "            # Total Kernels relative intensity\n",
    "            kernels_neg = np.sum(np.abs(kernels_neg)) / (STAR_FLUX * DT)\n",
    "            kernels_old = np.sum(np.abs(kernels_old)) / (STAR_FLUX * DT)\n",
    "            kernels_pos = np.sum(np.abs(kernels_pos)) / (STAR_FLUX * DT)\n",
    "\n",
    "            # Birght relative intensity\n",
    "            bright_neg /= STAR_FLUX * DT\n",
    "            bright_old /= STAR_FLUX * DT\n",
    "            bright_pos /= STAR_FLUX * DT\n",
    "\n",
    "            metric_neg =  kernels_neg / bright_neg\n",
    "            metric_old =  kernels_old / bright_old\n",
    "            metric_pos =  kernels_pos / bright_pos\n",
    "\n",
    "            # Save the history\n",
    "            bright_history.append(bright_old)\n",
    "            asymmetry_history.append(kernels_old)\n",
    "            metric_history.append(metric_old)\n",
    "            shifters_history.append(np.copy(shifts))\n",
    "\n",
    "            metric = False\n",
    "\n",
    "            if not metric:\n",
    "                # Maximize the bright metric for group 1 shifters\n",
    "                if p in p1:\n",
    "                    log += \"Shift \" + color.black(color.on_lightgrey(f\"{p}\")) + \" Bright: \" + color.black(color.on_green(f\"{bright_neg:.2e} | {bright_old:.2e} | {bright_pos:.2e}\")) + \" -> \"\n",
    "\n",
    "                    if bright_pos > bright_old and bright_pos > bright_neg:\n",
    "                        log += color.black(color.on_green(\" + \"))\n",
    "                        shifts += step\n",
    "                    elif bright_neg > bright_old and bright_neg > bright_pos:\n",
    "                        log += color.black(color.on_green(\" - \"))\n",
    "                        shifts -= step\n",
    "                    else:\n",
    "                        log += color.black(color.on_green(\" = \"))\n",
    "\n",
    "                # Minimize the asymmetry metric for group 2 shifters\n",
    "                else:\n",
    "                    log += \"Shift \" + color.black(color.on_lightgrey(f\"{p}\")) + \" Asymmetry:  \" + color.black(color.on_blue(f\"{kernels_neg:.2e} | {kernels_old:.2e} | {kernels_pos:.2e}\")) + \" -> \"\n",
    "\n",
    "                    if kernels_pos < kernels_old and kernels_pos < kernels_neg:\n",
    "                        shifts += step\n",
    "                        log += color.black(color.on_blue(\" + \"))\n",
    "                    elif kernels_neg < kernels_old and kernels_neg < kernels_pos:\n",
    "                        shifts -= step\n",
    "                        log += color.black(color.on_blue(\" - \"))\n",
    "                    else:\n",
    "                        log += color.black(color.on_blue(\" = \"))\n",
    "\n",
    "            else: \n",
    "                log += \"Shift \" + color.black(color.on_lightgrey(f\"{p}\")) + \" Metric:  \" + color.black(color.on_purple(f\"{metric_neg:.2e} | {metric_old:.2e} | {metric_pos:.2e}\")) + \" -> \"\n",
    "\n",
    "                if metric_pos < metric_old and metric_pos < metric_neg:\n",
    "                    shifts += step\n",
    "                    log += color.black(color.on_purple(\" + \"))\n",
    "                elif metric_neg < metric_old and metric_neg < metric_pos:\n",
    "                    shifts -= step\n",
    "                    log += color.black(color.on_purple(\" - \"))\n",
    "                else:\n",
    "                    log += color.black(color.on_purple(\" = \"))\n",
    "            \n",
    "            if verbose:\n",
    "                print(log)\n",
    "\n",
    "        delta /= decay\n",
    "\n",
    "    return bound_phase(shifts), {\n",
    "        \"bright\": np.array(bright_history),\n",
    "        \"asymmetry\": np.array(asymmetry_history),\n",
    "        \"shifters\": np.array(shifters_history),\n",
    "    }\n",
    "\n",
    "CALIBRATED_SHIFTS, CALIBRATION_HISTORY = calibrate(verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_optimization_history():\n",
    "    bright_evol, dark_asymmetry_evol, shifts_evol = CALIBRATION_HISTORY[\"bright\"], CALIBRATION_HISTORY[\"asymmetry\"], CALIBRATION_HISTORY[\"shifters\"]\n",
    "\n",
    "    _, axs = plt.subplots(3,1, figsize=(15,15))\n",
    "\n",
    "    axs[0].plot(bright_evol)\n",
    "    axs[0].set_xlabel(\"Number of iterations\")\n",
    "    axs[0].set_ylabel(\"Bright throughput (%)\")\n",
    "    axs[0].set_yscale(\"log\")\n",
    "    axs[0].set_title(\"Optimization of the bright output\")\n",
    "\n",
    "    axs[1].plot(dark_asymmetry_evol)\n",
    "    axs[1].set_xlabel(\"Number of iterations\")\n",
    "    axs[1].set_ylabel(\"Kernels throughput (%)\")\n",
    "    axs[1].set_yscale(\"log\")\n",
    "    axs[1].set_title(\"Optimization of the kernels\")\n",
    "\n",
    "    print(np.mean(dark_asymmetry_evol[-2000:]))\n",
    "\n",
    "    for i in range(shifts_evol.shape[1]):\n",
    "        axs[2].plot(shifts_evol[:,i], label=f\"Shifter {i+1}\")\n",
    "    axs[2].set_xlabel(\"Number of iterations\")\n",
    "    axs[2].set_ylabel(\"Phase shift\")\n",
    "    axs[2].set_yscale(\"linear\")\n",
    "    axs[2].set_title(\"Convergeance of the phase shifters\")\n",
    "    axs[2].legend(loc='upper right')\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "plot_optimization_history()\n",
    "plot_kn_phase_effect(shifts=CALIBRATED_SHIFTS)\n",
    "plot_transmission_maps(shifts=CALIBRATED_SHIFTS, shifts_total_opd=SHIFTS_TOTAL_OPD)\n",
    "\n",
    "kn(STAR_SIGNALS, CALIBRATED_SHIFTS, reference_flux=STAR_FLUX)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reliability (WIP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimization_emprical_proof():\n",
    "\n",
    "    _, axs = plt.subplots(2, 7, figsize=(20, 5))\n",
    "    axs = axs.flatten()\n",
    "\n",
    "    _, axs2 = plt.subplots(2, 7, figsize=(20, 5))\n",
    "    axs2 = axs2.flatten()\n",
    "\n",
    "    for _ in range(100):\n",
    "        shifts_total_opd = np.array(np.random.uniform(0, L.value, 14)) * L.unit\n",
    "        calibrated_shifts, _ = calibrate(shifts_total_opd=shifts_total_opd)\n",
    "\n",
    "        E = bound_phase(shifts_total_opd)\n",
    "        P = bound_phase(calibrated_shifts)\n",
    "\n",
    "        for i in range(14):\n",
    "            axs[i].scatter(E[i], P[i], color='blue', s=1)\n",
    "            axs[i].set_xlabel(\"Introduced error\")\n",
    "            axs[i].set_ylabel(\"Optimized shift\")\n",
    "            axs[i].set_title(f\"P{i+1}\")\n",
    "\n",
    "        def bound(p):\n",
    "            return bound_phase(p)\n",
    "\n",
    "        axs2[0].scatter(bound(E[0] - E[1]), bound(P[0] - P[1]), color='blue', s=1)\n",
    "        axs2[0].set_title(\"P1-P2\")\n",
    "        axs2[1].scatter(bound(E[2] - E[3]), bound(P[2] - P[3]), color='blue', s=1)\n",
    "        axs2[1].set_title(\"P3-P4\")\n",
    "        axs2[2].scatter(bound(E[4] - E[6]), bound(P[4] - P[6]), color='blue', s=1)\n",
    "        axs2[2].set_title(\"P5 - P7\")\n",
    "        axs2[3].scatter(bound(E[5] - E[7]), bound(P[5] - P[7]), color='blue', s=1)\n",
    "        axs2[3].set_title(\"P6 - P8\")\n",
    "        axs2[4].scatter(bound(E[8] - E[10]), bound(P[8] - P[10]), color='blue', s=1)\n",
    "        axs2[4].set_title(\"P9 - P11\")\n",
    "        axs2[5].scatter(bound(E[9] - E[12]), bound(P[9] - P[12]), color='blue', s=1)\n",
    "        axs2[5].set_title(\"P10 - P13\")\n",
    "        axs2[6].scatter(bound(E[11] - E[13]), bound(P[11] - P[13]), color='blue', s=1)\n",
    "        axs2[6].set_title(\"P12 - P14\")\n",
    "\n",
    "        axs2[7].scatter(bound((E[0] + E[1]) - (E[2] + E[3])), bound((P[0] + P[1]) - (P[2] + P[3])), color='blue', s=1)\n",
    "        axs2[7].set_title(\"(P1-P2)*P5 - (P3-P4)*P7\")\n",
    "\n",
    "        axs2[8].scatter((E[0] + E[1])/2 * E[4] - ((E[2] + E[3])/2 * E[6]), ((P[0] + P[1])/2 * P[4]) - ((P[2] + P[3])/2 * P[6]), color='blue', s=1)\n",
    "        axs2[8].set_title(\"(P1+P2)/2*P5 - (P3+P4)/2*P7\")\n",
    "\n",
    "        for i in range(14):\n",
    "            axs2[i].set_xlabel(\"Introduced error\")\n",
    "            axs2[i].set_ylabel(\"Optimized shift\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "# optimization_emprical_proof()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🤖 Machine Learning\n",
    "\n",
    "Another approach to retrieve the correct shifts inject is to use machine learning techniques. There is several ways to do so. Here we will focus a supervised dense neural network. To do so, we will have to build a dataset.\n",
    "\n",
    "As the solutions are degenerated, we will not ask the network to predict the best shift to inject, but we will ask it to predict the shfit aberrations instead. From these aberation, we are able to determine a solution for the shifts to inject.\n",
    "\n",
    "As input of the network, we need to give enough information to caracterize the parameter space. The most straightforward approach would be to create a grid in the parameter space and give the kenrel outputs for each of the point in these grid.\n",
    "\n",
    "Unfortunately, we work in a parameter space of 14 dimensions which is too large to be covered by a grid. A solution is to consider only the vectors that form the cardinal basis of this parameter space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_grid(N, D, a, b):\n",
    "    \"\"\"\n",
    "    Generate a list of points forming a grid in a parameter space.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - N: Resolution of the grid (point per axes)\n",
    "    - D: Dimension of the space parameter\n",
    "    - a: Minimum value of the space parameter\n",
    "    - b: Maximum value of the space parameter\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - An array of vectors describing a point in the parameter space\n",
    "    \"\"\"\n",
    "    return np.array([a + (b-a) * (((x // N**np.arange(D,dtype=float)) % N)/N) for x in range(N**D)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_basis(D, b=1):\n",
    "    \"\"\"\n",
    "    Return the basis vectors of the parameter space (+ the null vector)\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - D: Dimension of the space parameter\n",
    "    - b: Norm of the basis vector (default=1)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - An array of vectors describing a point in the parameter space\n",
    "    \"\"\"\n",
    "\n",
    "    vectors = np.zeros((D+1,D))\n",
    "    for i in range(D):\n",
    "        vectors[i+1,i] = b\n",
    "    return vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_basis_2p(D, b=1):\n",
    "    \"\"\"\n",
    "    Return the basis vectors of the parameter space (+ the null vector)\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - D: Dimension of the space parameter\n",
    "    - b: Norm of the basis vector (default=1)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - An array of vectors describing a point in the parameter space\n",
    "    \"\"\"\n",
    "\n",
    "    vectors = np.zeros((2*D+1,D))\n",
    "    for i in range(D):\n",
    "        vectors[2*i+1,i] = b\n",
    "        vectors[2*i+2,i] = 2*b\n",
    "    return vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dataset(size=1000):\n",
    "    # grid_points = parameter_grid(2, 14, 0, 1.65)\n",
    "    # grid_points = parameter_basis(14, 1.65/2)\n",
    "    grid_points = parameter_basis_2p(14, 1.65/3)\n",
    "    vector_len = len(grid_points)*7 + 14\n",
    "    dataset = np.empty((size, vector_len))\n",
    "\n",
    "    for v in range(size):\n",
    "\n",
    "        shifts_total_opd = np.random.uniform(0, 1, 14) * L/10\n",
    "        vector = np.empty(vector_len)\n",
    "\n",
    "        for p, point in enumerate(grid_points):\n",
    "            _, darks, bright = kn_fields_njit(beams=STAR_SIGNALS, shifts=point, shifts_total_opd=shifts_total_opd)\n",
    "\n",
    "            vector[p*7:p*7+6] = np.abs(darks)**2\n",
    "            vector[p*7+6] = np.abs(bright)**2\n",
    "\n",
    "        vector[-14:] = shifts_total_opd\n",
    "        dataset[v] = vector\n",
    "\n",
    "    return dataset\n",
    "\n",
    "DATASET = get_dataset(10_000)\n",
    "print(DATASET.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_random_dataset(size=1000):\n",
    "\n",
    "    nb_points = 100\n",
    "\n",
    "    i_len = (7+14)\n",
    "    o_len = 14\n",
    "\n",
    "    vector_len = nb_points*i_len + o_len\n",
    "    dataset = np.empty((size, vector_len))\n",
    "\n",
    "    pv=0\n",
    "    for v in range(size):\n",
    "\n",
    "        if (nv := v*100//size) > pv:\n",
    "            print(nv, \"%\", end='\\r')\n",
    "            pv = nv\n",
    "\n",
    "        shifts_total_opd = np.random.uniform(0, 1, 14) * L/10\n",
    "        vector = np.empty(vector_len)\n",
    "\n",
    "        for p in range(nb_points):\n",
    "            shifts = np.random.uniform(0, L.value, size=14)\n",
    "            _, darks, bright = kn_fields_njit(beams=STAR_SIGNALS, shifts=shifts, shifts_total_opd=shifts_total_opd)\n",
    "\n",
    "            vector[p*i_len:(p+1)*i_len] = np.concatenate([shifts, np.abs(darks)**2, [np.abs(bright)**2]])\n",
    "\n",
    "        vector[-14:] = shifts_total_opd\n",
    "        dataset[v] = vector\n",
    "\n",
    "    return dataset\n",
    "\n",
    "# DATASET = get_random_dataset(10_000)\n",
    "# print(DATASET.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATASET[:,-14:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model definition (WIP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_model(input_shape):\n",
    "    i = tf.keras.Input(shape=(input_shape,), name='Input')\n",
    "    # x = tf.keras.layers.Normalization(axis=None, mean=np.mean(DATASET[:,:-14]), variance=np.std(DATASET[:,:-14]), invert=False, name=\"Normalization\")(i)\n",
    "    x = tf.keras.layers.Dense(128, activation='relu', name='Dense_1')(i)\n",
    "    x = tf.keras.layers.Dense(64, activation='relu', name='Dense_2')(x)\n",
    "    x = tf.keras.layers.Dense(32, activation='relu', name='Dense_3')(x)\n",
    "    o = tf.keras.layers.Dense(14, activation='relu', name='Output')(x)\n",
    "    # o = tf.keras.layers.Normalization(axis=None, mean=np.mean(DATASET[:,-14:]), variance=np.std(DATASET[:,-14:]), invert=True, name=\"Denormalization\")(x)\n",
    "    return tf.keras.Model(inputs=i, outputs=o)\n",
    "\n",
    "MODEL = get_model(input_shape=DATASET.shape[1]-14)\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=0.00001)\n",
    "MODEL.compile(optimizer=optimizer, loss='mse')\n",
    "MODEL.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model():\n",
    "    X = DATASET[:, :-14]\n",
    "    Y = DATASET[:, -14:]\n",
    "\n",
    "    print(DATASET.shape, X.shape, Y.shape)\n",
    "\n",
    "    return MODEL.fit(X, Y, epochs=10, batch_size=5, validation_split=0.2, )\n",
    "\n",
    "history = train_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(history.history['loss'], label='loss') \n",
    "plt.plot(history.history['val_loss'], label='val_loss')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEST_SET = get_dataset(size=10)\n",
    "X = TEST_SET[:, :-14]\n",
    "Y = TEST_SET[:, -14:]\n",
    "\n",
    "PREDICTIONS = MODEL.predict(X)\n",
    "print(X)\n",
    "print(PREDICTIONS)\n",
    "\n",
    "# print(Y)\n",
    "# print(PREDICTIONS)\n",
    "\n",
    "cpt = 0\n",
    "for i in range(10):\n",
    "    for j in range(len(Y[i])):\n",
    "        # print(f\"Shifter {j}: E = {Y[i][j]:.2f}\", f\"P = {PREDICTIONS[i][j]:.2f}\")\n",
    "        plt.scatter(Y[i][j], PREDICTIONS[i][j])\n",
    "        cpt += 1\n",
    "    #     if cpt > 1:break\n",
    "    # if cpt > 1:break\n",
    "\n",
    "plt.xlabel(\"Expectations\")\n",
    "plt.ylabel(\"Preditions\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TEST_SET = get_random_dataset(size=10)\n",
    "# X = TEST_SET[:, :-14]\n",
    "# Y = TEST_SET[:, -14:]\n",
    "\n",
    "# PREDICTIONS = MODEL.predict(X)\n",
    "# print(X)\n",
    "# print(PREDICTIONS)\n",
    "\n",
    "# # print(Y)\n",
    "# # print(PREDICTIONS)\n",
    "\n",
    "# cpt = 0\n",
    "# for i in range(10):\n",
    "#     for j in range(len(Y[i])):\n",
    "#         # print(f\"Shifter {j}: E = {Y[i][j]:.2f}\", f\"P = {PREDICTIONS[i][j]:.2f}\")\n",
    "#         plt.scatter(Y[i][j], PREDICTIONS[i][j])\n",
    "#         cpt += 1\n",
    "#     #     if cpt > 1:break\n",
    "#     # if cpt > 1:break\n",
    "\n",
    "# plt.xlabel(\"Expectations\")\n",
    "# plt.ylabel(\"Preditions\")\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🎭 Shifters correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scan(\n",
    "    scan_on,\n",
    "    restricted: bool = False,\n",
    "):\n",
    "    \"\"\"\n",
    "    Scan the parameter space and plot the null depths for each parameter\n",
    "    combination.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - kn: An instance of the KernelNuller class.\n",
    "    - beams: A list of 2D arrays, each representing a beam.\n",
    "    - optimized_parameters: A list of 14 floats, the optimized parameters.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - None\n",
    "    \"\"\"\n",
    "\n",
    "    # Scan shift power parameter space\n",
    "    scan = np.linspace(0, L.value, 101, endpoint=True) * L.unit\n",
    "\n",
    "    # Initialize the maps\n",
    "    nulls_map = np.zeros((3, len(scan), len(scan)))\n",
    "    darks_map = np.zeros((6, len(scan), len(scan)))\n",
    "    kernels_map = np.zeros((3, len(scan), len(scan)))\n",
    "    bright_map = np.zeros((len(scan), len(scan)))\n",
    "\n",
    "    # Create the figure\n",
    "    _, axs = plt.subplots(3, 5, figsize=(30, 15))\n",
    "\n",
    "    # Consider only errors & correction on the shifter that are being scanned\n",
    "    if restricted:\n",
    "        shifts = np.zeros(14) * L.unit\n",
    "        shifts_total_opd = np.zeros(14) * L.unit\n",
    "        shifts_total_opd[scan_on[0] - 1] = SHIFTS_TOTAL_OPD[scan_on[0] - 1]\n",
    "        shifts_total_opd[scan_on[1] - 1] = SHIFTS_TOTAL_OPD[scan_on[1] - 1]\n",
    "\n",
    "    # Consider all shifter errors & corrections\n",
    "    else:\n",
    "        shifts = CALIBRATED_SHIFTS.copy()\n",
    "        shifts_total_opd = SHIFTS_TOTAL_OPD.copy()\n",
    "\n",
    "    signals = get_input_fields(angular_separation=0*u.mas)\n",
    "\n",
    "    for i, scan1 in enumerate(scan):\n",
    "        for j, scan2 in enumerate(scan):\n",
    "            shifts[scan_on[0] - 1] = scan1\n",
    "            shifts[scan_on[1] - 1] = scan2\n",
    "\n",
    "            nulls, darks, bright = kn_fields(beams=signals, shifts=shifts, shifts_total_opd=shifts_total_opd)\n",
    "            \n",
    "            kernels = np.array([\n",
    "                    np.abs(darks[2*i])**2 - np.abs(darks[2*i+1])**2\n",
    "                for i in range(3)])\n",
    "\n",
    "            for k, null in enumerate(nulls):\n",
    "                nulls_map[k, i, j] = np.abs(null)**2\n",
    "            for k, dark in enumerate(darks):\n",
    "                darks_map[k, i, j] = np.abs(dark)**2\n",
    "            for k, kernel in enumerate(kernels):\n",
    "                kernels_map[k, i, j] = kernel\n",
    "            bright_map[i, j] = np.abs(bright)**2\n",
    "\n",
    "    for k in range(3):\n",
    "        p = axs[k, 0]\n",
    "        p.set_title(f\"Null {k+1}\")\n",
    "        im = p.imshow(\n",
    "            nulls_map[k],\n",
    "            extent=[0, L.value, 0, L.value],\n",
    "            vmin=np.min(nulls_map),\n",
    "            vmax=np.max(nulls_map),\n",
    "        )\n",
    "        p.scatter(\n",
    "            CALIBRATED_SHIFTS[scan_on[1] - 1],\n",
    "            CALIBRATED_SHIFTS[scan_on[0] - 1],\n",
    "            color=\"red\",\n",
    "            edgecolors=\"white\",\n",
    "            s=100,\n",
    "        )\n",
    "        p.scatter(\n",
    "            IDEAL_SHIFTS[scan_on[1] - 1],\n",
    "            IDEAL_SHIFTS[scan_on[0] - 1],\n",
    "            color=\"green\",\n",
    "            edgecolors=\"white\",\n",
    "            s=100,\n",
    "        )\n",
    "        p.set_xlabel(f\"Parameter {scan_on[1]}\")\n",
    "        p.set_ylabel(f\"Parameter {scan_on[0]}\")\n",
    "        plt.colorbar(im)\n",
    "\n",
    "    for k in range(6):\n",
    "        p = axs[k // 2, k % 2 + 1]\n",
    "        p.set_title(f\"Dark {k+1}\")\n",
    "        im = p.imshow(\n",
    "            darks_map[k],\n",
    "            extent=[0, L.value, 0, L.value],\n",
    "            vmin=np.min(darks_map),\n",
    "            vmax=np.max(darks_map),\n",
    "            cmap=\"hot\",\n",
    "        )\n",
    "        p.scatter(\n",
    "            CALIBRATED_SHIFTS[scan_on[1] - 1],\n",
    "            CALIBRATED_SHIFTS[scan_on[0] - 1],\n",
    "            color=\"red\",\n",
    "            edgecolors=\"white\",\n",
    "            s=100,\n",
    "        )\n",
    "        p.scatter(\n",
    "            IDEAL_SHIFTS[scan_on[1] - 1],\n",
    "            IDEAL_SHIFTS[scan_on[0] - 1],\n",
    "            color=\"green\",\n",
    "            edgecolors=\"white\",\n",
    "            s=100,\n",
    "        )\n",
    "        p.set_xlabel(f\"Parameter {scan_on[1]}\")\n",
    "        p.set_ylabel(f\"Parameter {scan_on[0]}\")\n",
    "        plt.colorbar(im)\n",
    "\n",
    "    for k in range(3):\n",
    "        p = axs[k, 3]\n",
    "        p.set_title(f\"Kernel {k+1}\")\n",
    "        im = p.imshow(\n",
    "            kernels_map[k],\n",
    "            extent=[0, L.value, 0, L.value],\n",
    "            vmin=np.min(kernels_map),\n",
    "            vmax=np.max(kernels_map),\n",
    "            cmap=\"bwr\",\n",
    "        )\n",
    "        p.scatter(\n",
    "            CALIBRATED_SHIFTS[scan_on[1] - 1],\n",
    "            CALIBRATED_SHIFTS[scan_on[0] - 1],\n",
    "            color=\"red\",\n",
    "            edgecolors=\"white\",\n",
    "            s=100,\n",
    "        )\n",
    "        p.scatter(\n",
    "            IDEAL_SHIFTS[scan_on[1] - 1],\n",
    "            IDEAL_SHIFTS[scan_on[0] - 1],\n",
    "            color=\"green\",\n",
    "            edgecolors=\"white\",\n",
    "            s=100,\n",
    "        )\n",
    "        p.set_xlabel(f\"Parameter {scan_on[1]}\")\n",
    "        p.set_ylabel(f\"Parameter {scan_on[0]}\")\n",
    "        plt.colorbar(im)\n",
    "\n",
    "    p = axs[1, 4]\n",
    "    p.set_title(f\"Bright\")\n",
    "    im = p.imshow(bright_map, extent=[0, L.value, 0, L.value], cmap=\"gray\")\n",
    "    p.scatter(\n",
    "        CALIBRATED_SHIFTS[scan_on[1] - 1],\n",
    "        CALIBRATED_SHIFTS[scan_on[0] - 1],\n",
    "        color=\"red\",\n",
    "        edgecolors=\"white\",\n",
    "        s=100,\n",
    "    )\n",
    "    p.scatter(\n",
    "        IDEAL_SHIFTS[scan_on[1] - 1],\n",
    "        IDEAL_SHIFTS[scan_on[0] - 1],\n",
    "        color=\"green\",\n",
    "        edgecolors=\"white\",\n",
    "        s=100,\n",
    "    )\n",
    "    p.set_xlabel(f\"Parameter {scan_on[1]}\")\n",
    "    p.set_ylabel(f\"Parameter {scan_on[0]}\")\n",
    "    plt.colorbar(im)\n",
    "\n",
    "    axs[0, 4].axis(\"off\")\n",
    "    axs[2, 4].axis(\"off\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "scan_on = (1, 2)\n",
    "scan(scan_on=scan_on, restricted=True)\n",
    "scan(scan_on=scan_on, restricted=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<div align=center>\n",
    "\n",
    "# ⚙️ **Data generation**\n",
    "\n",
    "</div>\n",
    "\n",
    "## 🟨 Single observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit()\n",
    "def generate_one_distrib_njit(\n",
    "    N: int = 1000,  # Number of observations\n",
    "    star_signals: np.array = STAR_SIGNALS,  # Star signals\n",
    "    planet_signals: np.array = PLANET_SIGNALS,  # Planet signals\n",
    "    shifts: np.array = CALIBRATED_SHIFTS.to(L.unit).value,  # Shifts to apply\n",
    "    shifts_total_opd: np.array = SHIFTS_TOTAL_OPD.to(L.unit).value,  # Shifts error\n",
    "    input_ce_rms: float = INPUT_CE_RMS.to(L.unit).value,  # Input OPD RMS\n",
    "    wavelength: float = L.value,  # Wavelength\n",
    "):\n",
    "    \"\"\"\n",
    "    Simulate several observation of the Kernel-Nuller in the same conditions.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - N: Number of observations\n",
    "    - star_signals: Star signals\n",
    "    - planet_signals: Planet signals\n",
    "    - shifts: Shifts to apply\n",
    "    - shifts_total_opd: Shifts error\n",
    "    - input_ce_rms: Input OPD RMS\n",
    "    - wavelength: Wavelength\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Darks outputs without planet (6 x N)\n",
    "    - Darks outputs with planet (6 x N)\n",
    "    - Kernels outputs without planet (3 x N)\n",
    "    - Kernels outputs with planet (3 x N)\n",
    "    \"\"\"\n",
    "\n",
    "    darks_dist_so = np.empty((6, N))\n",
    "    darks_dist_wp = np.empty((6, N))\n",
    "    kernels_dist_so = np.empty((3, N))\n",
    "    kernels_dist_wp = np.empty((3, N))\n",
    "\n",
    "    for i in range(N):\n",
    "\n",
    "        noise = np.random.normal(0, input_ce_rms, 4)\n",
    "\n",
    "        noised_star_signals = phase_shift_njit(star_signals, noise, wavelength)\n",
    "        noised_planet_signals = phase_shift_njit(planet_signals, noise, wavelength)\n",
    "\n",
    "        darks_so, kernels_so, _ = kn_njit(noised_star_signals, shifts, shifts_total_opd, wavelength)\n",
    "        darks_wp, kernels_wp, _ = kn_njit(noised_planet_signals, shifts, shifts_total_opd, wavelength)\n",
    "\n",
    "        darks_dist_so[:, i] = darks_so\n",
    "        darks_dist_wp[:, i] = darks_wp + darks_so\n",
    "        kernels_dist_so[:, i] = kernels_so\n",
    "        kernels_dist_wp[:, i] = kernels_wp + kernels_so\n",
    "\n",
    "    return (\n",
    "        darks_dist_so,\n",
    "        darks_dist_wp,\n",
    "        kernels_dist_so,\n",
    "        kernels_dist_wp,\n",
    "    )\n",
    "\n",
    "# User-friendly interface (Numba can't manage dicts with unconsistent data)\n",
    "def generate_one_distrib(\n",
    "    N: int = 1000,\n",
    "    star_signals: np.ndarray[complex] = STAR_SIGNALS,\n",
    "    planet_signals: np.ndarray[complex] = PLANET_SIGNALS,\n",
    "    shifts: u.Quantity = CALIBRATED_SHIFTS,\n",
    "    shifts_total_opd: u.Quantity = SHIFTS_TOTAL_OPD,\n",
    "    input_ce_rms: u.Quantity = INPUT_CE_RMS,\n",
    "    wavelength: u.Quantity = L,\n",
    "):\n",
    "    \"\"\"\n",
    "    Simulate several observation of the Kernel-Nuller in the same conditions.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - N: Number of observations\n",
    "    - star_signals: Star signals\n",
    "    - planet_signals: Planet signals\n",
    "    - shifts: Shifts to apply\n",
    "    - shifts_total_opd: Shifts error\n",
    "    - input_ce_rms: Input OPD RMS\n",
    "    - wavelength: Wavelength\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Dictionary containing:\n",
    "        - \"darks_so\" dark outpus with star only (6 x N)\n",
    "        - \"darks_wp\" dark outpus with star and planet (6 x N)\n",
    "        - \"kernels_so\" kernel outpus with star only (3 x N) (with photon noise)\n",
    "        - \"kernels_wp\" kernel outpus with star and planet (3 x N) (with photon noise)\n",
    "    \"\"\"\n",
    "\n",
    "    outputs = generate_one_distrib_njit(\n",
    "        N,\n",
    "        star_signals,\n",
    "        planet_signals,\n",
    "        shifts.to(wavelength.unit).value,\n",
    "        shifts_total_opd.to(wavelength.unit).value,\n",
    "        input_ce_rms.to(wavelength.unit).value,\n",
    "        wavelength.value,\n",
    "    )\n",
    "    return {\n",
    "        \"darks_so\": outputs[0],\n",
    "        \"darks_wp\": outputs[1],\n",
    "        \"kernels_so\": outputs[2],\n",
    "        \"kernels_wp\": outputs[3],\n",
    "    }\n",
    "\n",
    "IDEAL_DISTS = generate_one_distrib(\n",
    "    shifts=np.zeros(14)*L.unit,\n",
    "    shifts_total_opd=np.zeros(14)*L.unit\n",
    ")\n",
    "\n",
    "CALIBRATED_DISTS = generate_one_distrib()\n",
    "\n",
    "PERTURBED_DISTS = generate_one_distrib(\n",
    "    shifts=np.zeros(14)*L.unit\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🟡 Parallactic diversity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_hour_diversity_data(h_range=H_RANGE):\n",
    "    \"\"\"\n",
    "    Generate the data for the hour diversity study.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - h_range: Range of hour angles\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - Array of data for each kernel (3 x len(h_range))\n",
    "    \"\"\"\n",
    "\n",
    "    data = np.zeros((3, len(h_range)))\n",
    "    for i, h in enumerate(h_range):\n",
    "\n",
    "        dists = generate_one_distrib()\n",
    "\n",
    "        for k in range(3):\n",
    "            data[k, i] = np.median(dists['kernels_wp'][k])\n",
    "\n",
    "    return data\n",
    "\n",
    "HOUR_DIVERSITY_DATA = generate_hour_diversity_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<div align=center>\n",
    "\n",
    "# 🔎 **Data analysis**\n",
    "\n",
    "</div>\n",
    "\n",
    "## 📊 Output distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_distributions(calibrated_dists=CALIBRATED_DISTS, ideal_dists=IDEAL_DISTS, perturbed_dists=PERTURBED_DISTS):\n",
    "\n",
    "    null_outputs = ['N3b', 'N4a', 'N4b']\n",
    "\n",
    "    bins = 300\n",
    "\n",
    "    # Dark ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "        \n",
    "    fig, axs = plt.subplots(6, 1, figsize=(15, 30))\n",
    "    for i in range(6):\n",
    "        ax = axs[i]\n",
    "\n",
    "        ax.hist(calibrated_dists['darks_so'][i], bins=bins, color='red', label=f\"Star only (calibrated)\", alpha=0.5, log=True)\n",
    "        ax.hist(calibrated_dists['darks_wp'][i], bins=bins, color='blue', label=f\"With planet (calibrated)\", alpha=0.5, log=True)\n",
    "        ax.hist(ideal_dists['darks_so'][i], bins=bins, histtype='step', color='red', label=f\"Star only (ideal)\", linewidth=1, log=True)\n",
    "        ax.hist(ideal_dists['darks_wp'][i], bins=bins, histtype='step', color='blue', label=f\"With planet (ideal)\", linewidth=1, log=True)\n",
    "        if perturbed_dists is not None:\n",
    "            ax.hist(perturbed_dists['darks_so'][i], bins=bins, histtype='step', color='orange', linestyle=\"dashed\", label=f\"Star only (perturbed)\", linewidth=1, log=True)\n",
    "            ax.hist(perturbed_dists['darks_wp'][i], bins=bins, histtype='step', color='purple', linestyle=\"dashed\", label=f\"With planet (perturbed)\", linewidth=1, log=True)\n",
    "\n",
    "        ax.set_xlabel(\"Intensity (photons)\")\n",
    "        ax.set_ylabel(\"Number of occurences\")\n",
    "        ax.set_title(f\"Dark {i+1}\")\n",
    "        ax.legend()\n",
    "\n",
    "    # Kernel ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "\n",
    "    fig, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "    for i in range(3):\n",
    "        ax = axs[i]\n",
    "\n",
    "        ax.hist(calibrated_dists['kernels_so'][i], bins=bins, color='red', label=f\"Star only (ideal)\", density=True, alpha=0.5, log=True)\n",
    "        ax.hist(calibrated_dists['kernels_wp'][i], bins=bins, color='blue', label=f\"With planet (ideal)\", density=True, alpha=0.5, log=True)\n",
    "        ax.hist(ideal_dists['kernels_so'][i], bins=bins, histtype='step', color='red', label=f\"Star only (real)\", linewidth=1, density=True, log=True)\n",
    "        ax.hist(ideal_dists['kernels_wp'][i], bins=bins, histtype='step', color='blue', label=f\"With planet (real)\", linewidth=1, density=True, log=True)\n",
    "        if perturbed_dists is not None:\n",
    "            ax.hist(perturbed_dists['kernels_so'][i], bins=bins, histtype='step', color='black', linestyle=\"dashed\", label=f\"Star only (perturbed)\", linewidth=1, density=True, log=True)\n",
    "            ax.hist(perturbed_dists['kernels_wp'][i], bins=bins, histtype='step', color='purple', linestyle=\"dashed\", label=f\"With planet (perturbed)\", linewidth=1, density=True, log=True)\n",
    "\n",
    "        ax.set_xlabel(\"Intensity (photons)\")\n",
    "        ax.set_ylabel(\"Number of occurences\")\n",
    "        ax.set_title(f\"Theoretical Kernel {i+1} (perfect cameras)\")\n",
    "        ax.legend()       \n",
    "\n",
    "    plt.show()\n",
    "\n",
    "plot_distributions()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📢 Noise sensitivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_sensitivity_to_noise(shifts=CALIBRATED_SHIFTS, shifts_total_opd=SHIFTS_TOTAL_OPD):\n",
    "\n",
    "    input_ce_rms_range, step = np.linspace(0, 3*SHIFTS_CE_RMS.to(u.nm).value, 25, retstep=True)\n",
    "    input_ce_rms_range *= u.nm\n",
    "    step *= u.nm\n",
    "    stds = []\n",
    "\n",
    "    _, ax = plt.subplots(1, 1, figsize=(15, 5))\n",
    "\n",
    "    for i, input_ce_rms in enumerate(input_ce_rms_range):\n",
    "\n",
    "        dists_perturbated = generate_one_distrib(1000, STAR_SIGNALS, np.zeros(4, dtype=np.complex128)*L.unit, np.zeros(14)*L.unit, shifts_total_opd, input_ce_rms, L)\n",
    "        dists_calibrated = generate_one_distrib(1000, STAR_SIGNALS, np.zeros(4, dtype=np.complex128)*L.unit, shifts, shifts_total_opd, input_ce_rms, L)\n",
    "        dists_ideal = generate_one_distrib(1000, STAR_SIGNALS, np.zeros(4, dtype=np.complex128)*L.unit, np.zeros(14)*L.unit, np.zeros(14)*L.unit, input_ce_rms, L)\n",
    "\n",
    "        kernel_dist_perturbated = np.concatenate([*dists_perturbated['kernels_so']])\n",
    "        kernel_dist_calibrated = np.concatenate([*dists_calibrated['kernels_so']])\n",
    "        kernel_dist_ideal = np.concatenate([*dists_ideal['kernels_so']])\n",
    "\n",
    "        kernel_dist_perturbated = dists_perturbated['kernels_so'][0]\n",
    "        kernel_dist_calibrated = dists_calibrated['kernels_so'][0]\n",
    "        kernel_dist_ideal = dists_ideal['kernels_so'][0]\n",
    "\n",
    "        stds.append(np.std(kernel_dist_perturbated))\n",
    "        stds.append(np.std(kernel_dist_calibrated))\n",
    "        stds.append(np.std(kernel_dist_ideal))\n",
    "\n",
    "        ax.scatter(np.random.normal(input_ce_rms.value - step.value/5, step.value/20, len(kernel_dist_perturbated)), kernel_dist_perturbated, color='tab:red', s=5 if i == 0 else 0.1, alpha=1 if i==0 else 1, label=\"Perturbated\" if i == 0 else None)\n",
    "        ax.scatter(np.random.normal(input_ce_rms.value, step.value/20, len(kernel_dist_calibrated)), kernel_dist_calibrated, color='tab:green', s=5 if i == 0 else 0.1, alpha=1 if i==0 else 1, label=\"Calibrated\" if i == 0 else None)\n",
    "        ax.scatter(np.random.normal(input_ce_rms.value + step.value/5, step.value/20, len(kernel_dist_ideal)), kernel_dist_ideal, color='tab:blue', s=5 if i == 0 else 0.1, alpha=1 if i==0 else 1, label=\"Ideal\" if i == 0 else None)\n",
    "        \n",
    "        ax.boxplot(kernel_dist_perturbated, vert=True, positions=[input_ce_rms.value - step.value/5],widths=step.value/5, showfliers=False, manage_ticks=False)\n",
    "        ax.boxplot(kernel_dist_calibrated, vert=True, positions=[input_ce_rms.value],widths=step.value/5, showfliers=False, manage_ticks=False)\n",
    "        ax.boxplot(kernel_dist_ideal, vert=True, positions=[input_ce_rms.value + step.value/5],widths=step.value/5, showfliers=False, manage_ticks=False)\n",
    "\n",
    "    ax.set_ylim(-max(stds), max(stds))\n",
    "    ax.set_xlabel(f\"Input OPD RMS ({input_ce_rms_range.unit})\")\n",
    "    ax.set_ylabel(\"Kernel intensity (photons)\")\n",
    "    ax.set_title(\"Sensitivity to noise\")\n",
    "    ax.legend()\n",
    "\n",
    "plot_sensitivity_to_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ☑️ Model fitting (WIP)\n",
    "\n",
    "Distributions are cool, but in order to make deeper analysis, we want to find a model that describe these distribution using few parameters. Unfortunately, there is no straightforward way to get such model as these distribution are very particular.\n",
    "\n",
    "The next block try most of the common distribution models and show the best ones... but unfortunately, none of them seems to match 😞"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit(data):\n",
    "    f = fitter.Fitter(data,\n",
    "           distributions=fitter.get_distributions())\n",
    "    f.fit()\n",
    "    f.summary()\n",
    "\n",
    "# fit(IDEAL_DISTS['kernels_so'][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📈 Test statistics\n",
    "\n",
    "A test statistic is a way of reducing the data we have to an unique number and compare this number to a threshold value. If the number is below the treshold, then the null hypothesis is favored. If it is above, the alternative hypothesis is favored. The goal is to find the best test statistic that allow to distinguish both hypothesis in a correct way\n",
    "\n",
    "- $H0$: the null hypothesis -> there is no planet\n",
    "- $H1$: the alternative hypothesis -> there is a planet\n",
    "\n",
    "- $T0$: vector of distributions obtained with H0\n",
    "- $T1$: vector of distributions obtained with H1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit()\n",
    "def get_distrib_vectors(Nmc, size):\n",
    "    T0 = np.zeros((3, Nmc,size))\n",
    "    T1 = np.zeros((3, Nmc,size))\n",
    "    for i in range(Nmc):\n",
    "        dists = generate_one_distrib_njit(size)\n",
    "        for k in range(3):\n",
    "            T0[k,i] = dists[2][k]\n",
    "            T1[k,i] = dists[3][k]\n",
    "    return T0, T1\n",
    "\n",
    "T0, T1 = get_distrib_vectors(1000, 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean\n",
    "\n",
    "**Principle:** We take the average of the distribution and we compare it to a treshold.\n",
    "\n",
    "$$\n",
    "\\left|\\frac{1}{N}\\sum_i x_i \\right| \\stackrel{H_1}{\\underset{H_0}{\\gtrless}} \\xi\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ts_mean(data):\n",
    "    return np.abs(np.mean(data, axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Median\n",
    "\n",
    "**Principle:** We take the median of the distribution and we compare it to a treshold.\n",
    "\n",
    "$$\n",
    "\\begin{cases}\n",
    "\\left| x_{\\frac{N+1}{2}} \\right| & \\text{if }N\\text{ is odd} \\\\\n",
    "\n",
    "\\left| \\frac{x_{\\frac{N}{2}} + x_{\\frac{N+1}{2}}}{2} \\right|  & \\text{if }N\\text{ is odd}\n",
    "\\end{cases}\n",
    "\\quad\\stackrel{H_1}{\\underset{H_0}{\\gtrless}} \\xi\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ts_median(data):\n",
    "    return np.abs(np.median(data, axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Argmax\n",
    "\n",
    "**Principle:** We pack our data in bins and we consider the position of the bin with the highest number of occurences. We compare it to a treshold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ts_argmax(data, bins=100):\n",
    "    maxs = np.zeros(data.shape[0])\n",
    "    for i, dist in enumerate(data):\n",
    "        hist = np.histogram(dist, bins=bins)\n",
    "        maxs[i] = hist[1][np.argmax(hist[0])]\n",
    "    return np.abs(maxs)\n",
    "\n",
    "def ts_argmax50(data):\n",
    "    return ts_argmax(data, 50)\n",
    "\n",
    "def ts_argmax100(data):\n",
    "    return ts_argmax(data, 100)\n",
    "\n",
    "def ts_argmax500(data):\n",
    "    return ts_argmax(data, 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kolmogorov-Smirnov\n",
    "\n",
    "**Principle:** We compare the maximum distance on the cumulative distribution functions of the two distributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ts_kolmogorov_smirnov(data):\n",
    "\n",
    "    distances = np.zeros(data.shape[0])\n",
    "\n",
    "    for d, dist in enumerate(data):\n",
    "\n",
    "        ref_dist = CALIBRATED_DISTS['kernels_so'][0]\n",
    "\n",
    "        dist = np.sort(dist)\n",
    "        ref_dist = np.sort(ref_dist)\n",
    "\n",
    "        v = np.min(np.concatenate([dist, ref_dist]))\n",
    "\n",
    "        i_ref = 0\n",
    "        i_dist = 0\n",
    "\n",
    "        count_ref = 0\n",
    "        count_dist = 0\n",
    "\n",
    "        while i_ref < len(ref_dist) and i_dist < len(dist):\n",
    "\n",
    "            if ref_dist[i_ref] < dist[i_dist]:\n",
    "                count_ref += 1\n",
    "                i_ref += 1\n",
    "            else:\n",
    "                count_dist += 1\n",
    "                i_dist += 1\n",
    "            \n",
    "            distances[d] = max(distances[d], np.abs(count_dist - count_ref) )#/ len(reference))\n",
    "\n",
    "    return distances"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cramèr-von Mises\n",
    "\n",
    "**Principle:** We compare the total quadratique distance on the cumulative distribution functions of the two distributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ts_cramer_von_mises(data):\n",
    "\n",
    "    distances = np.zeros(data.shape[0])\n",
    "\n",
    "    for d, dist in enumerate(data):\n",
    "\n",
    "        ref_dist = CALIBRATED_DISTS['kernels_so'][0]\n",
    "\n",
    "        dist = np.sort(dist)\n",
    "        ref_dist = np.sort(ref_dist)\n",
    "\n",
    "        v = np.min(np.concatenate([dist, ref_dist]))\n",
    "\n",
    "        i_ref = 0\n",
    "        i_dist = 0\n",
    "\n",
    "        count_ref = 0\n",
    "        count_dist = 0\n",
    "\n",
    "        while i_ref < len(ref_dist) and i_dist < len(dist):\n",
    "\n",
    "            if ref_dist[i_ref] < dist[i_dist]:\n",
    "                count_ref += 1\n",
    "                i_ref += 1\n",
    "            else:\n",
    "                count_dist += 1\n",
    "                i_dist += 1\n",
    "            \n",
    "            distances[d] += np.abs(count_dist - count_ref) ** 2\n",
    "\n",
    "    return distances\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wilcoxon-Mann-Whitney (WIP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ts_wilcoxon_mann_whitney(data):\n",
    "\n",
    "    res = np.empty(len(data))\n",
    "\n",
    "    ref_dist = CALIBRATED_DISTS['kernels_so'][0]\n",
    "\n",
    "    for d, dist in enumerate(data):\n",
    "\n",
    "        sorted_comb = np.unique(np.sort(np.concatenate([dist, ref_dist])))\n",
    "\n",
    "        r1 = np.sum(np.searchsorted(sorted_comb, dist) + 1)\n",
    "        r2 = np.sum(np.searchsorted(sorted_comb, ref_dist) + 1)\n",
    "\n",
    "        n1 = len(dist)\n",
    "        n2 = len(ref_dist)\n",
    "\n",
    "        u1 = n1*n2 + n1*(n1+1)/2 - r1\n",
    "        u2 = n1*n2 + n2*(n2+1)/2 - r2\n",
    "\n",
    "        res[d] = min(u1, u2)\n",
    "    \n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CDF diff area (Aurélie's idea)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ts_cdf_diff_area(data):\n",
    "    \"\"\"\n",
    "    Compute the area between the 2 CDF \n",
    "    \"\"\"\n",
    "    #data\n",
    "    num_simulations = data.shape[0]\n",
    "    distances = np.zeros(num_simulations)\n",
    "    \n",
    "    ref_dist = CALIBRATED_DISTS['kernels_so'][0]\n",
    "    ref_dist_sorted = np.sort(ref_dist)\n",
    "    m = len(ref_dist_sorted)\n",
    "    cdf_ref_dist = np.arange(1, m + 1) / m\n",
    "\n",
    "    for d in range(num_simulations):\n",
    "        dist = data[d, :]\n",
    "        dist = np.sort(dist)\n",
    "        n = len(dist)\n",
    "        cdf_dist = np.arange(1, n + 1) / n\n",
    "\n",
    "        #interpolation \n",
    "        cdf_ref_dist_interp = np.interp(dist, ref_dist_sorted, cdf_ref_dist)\n",
    "\n",
    "        #test \n",
    "        cdf_diff = cdf_dist - cdf_ref_dist_interp\n",
    "        area = np.trapz(cdf_diff, dist)\n",
    "        distances[d] = area\n",
    "    \n",
    "    return distances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEST_STATISTICS = {\n",
    "    'Mean': ts_mean,\n",
    "    'Median': ts_median,\n",
    "    # 'argmax50': ts_argmax50,\n",
    "    # 'argmax100': ts_argmax100,\n",
    "    'Argmax500': ts_argmax500,\n",
    "    'Kolmogorov-Smirnov': ts_kolmogorov_smirnov,\n",
    "    'Cramer Von Mises': ts_cramer_von_mises,\n",
    "    'Wilcoxon Mann Whitney': ts_wilcoxon_mann_whitney,\n",
    "    'CDF Diff. Area': ts_cdf_diff_area\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ❓ ROC curves\n",
    "\n",
    "ROC curves allow to compare the power of different test statistics. It show the proportion of true detection in function of the probability of false alarm. The more the curve climb fast, the better it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "def roc(T0, T1, test_statistic, multiple_source=False):\n",
    "\n",
    "    N = len(T0)\n",
    "\n",
    "    # Computing test statistic of all the distributions\n",
    "    if not multiple_source: \n",
    "        T0_values = test_statistic(T0)\n",
    "        T1_values = test_statistic(T1)\n",
    "    else:\n",
    "        T0_values = np.zeros(T0.shape[1])\n",
    "        T1_values = np.zeros(T0.shape[1])\n",
    "        for i in range(len(T0)):\n",
    "            T0_values += test_statistic(T0[i])\n",
    "            T1_values += test_statistic(T1[i])\n",
    "\n",
    "    # Computng the maximum treshold value\n",
    "    sup = np.max(np.concatenate([T0_values, T1_values]))\n",
    "\n",
    "    thresholds = np.linspace(0, sup, 1000)\n",
    "    \n",
    "    Pfa = np.zeros(len(thresholds))\n",
    "    Pdet = np.zeros(len(thresholds))\n",
    "    for i, threshold in enumerate(thresholds):\n",
    "        Pfa[i] = np.sum(T0_values > threshold) / N\n",
    "        Pdet[i] = np.sum(T1_values > threshold) / N\n",
    "\n",
    "    return Pfa, Pdet, thresholds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_roc(test_statistics = TEST_STATISTICS):\n",
    "\n",
    "    _, axs = plt.subplots(1, 4, figsize=(25, 5))\n",
    "\n",
    "    for k in range(4):\n",
    "        for ts_name, ts in test_statistics.items():\n",
    "            if k < 3:\n",
    "                Pfa, Pdet, _ = roc(T0[k], T1[k], ts)\n",
    "                axs[k].set_title(f\"Kernel {k+1}\")\n",
    "            else:\n",
    "                Pfa, Pdet, _ = roc(T0, T1, ts, multiple_source=True)\n",
    "                axs[k].set_title(f\"All kernels\")\n",
    "            axs[k].plot(Pfa, Pdet, label=ts_name)\n",
    "            axs[k].set_xlabel(\"Pfa\")\n",
    "            axs[k].set_ylabel(\"Pdet\")\n",
    "            axs[k].legend()\n",
    "\n",
    "    plt.suptitle(f\"ROC curves - C={CONTRAST:.1e}, Aberration RMS={INPUT_CE_RMS:.2e}\")\n",
    "    plt.show()\n",
    "\n",
    "plot_roc()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💪 P-values\n",
    "\n",
    "The P-value is an indicator of the confidence we have to reject the null hypothesis.\n",
    "\n",
    "The principle consist in comparing the test statistic obtain on the data we want to test with a large bunch of data that we know to be under the null hypothesis. We then compute the proportion of test statistic that are above the one we obtained. This proportion is the P-value.\n",
    "\n",
    "Thus, the lower the P-value, the more confident we are to reject the null hypothesis. A P-value below 0.05 is commonly considered as a good indicator to reject the null hypothesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_p_values(test_statistics = TEST_STATISTICS):\n",
    "\n",
    "    col = min(2, len(test_statistics))\n",
    "    row = int(np.ceil(len(test_statistics) / col))\n",
    "\n",
    "    _, axs = plt.subplots(row, col, figsize=(5*col, 5*row))\n",
    "    axs = axs.flatten()\n",
    "    \n",
    "    t = 0\n",
    "    for ts_name, ts in test_statistics.items():\n",
    "        cumulated_values = np.zeros(T0.shape[1])\n",
    "        sup = 0\n",
    "        for k in range(4):\n",
    "            if k < 3:\n",
    "                values = ts(T0[k])\n",
    "                cumulated_values += values / 3\n",
    "                label = f\"Kernel {k+1}\"\n",
    "            elif k == 3:\n",
    "                values = cumulated_values\n",
    "                label = \"Cumulated\"\n",
    "            sup = max(sup, np.max(values))\n",
    "            thresholds = np.linspace(0, sup, 1000)\n",
    "            p_values = np.zeros(len(thresholds))\n",
    "            for i, threshold in enumerate(thresholds):\n",
    "                p_values[i] = np.sum(values > threshold) / len(values)\n",
    "            axs[t].plot(thresholds, p_values, label=label)\n",
    "        axs[t].hlines(0.05, 0, sup, color='red', linestyle='dashed')\n",
    "        axs[t].set_xlabel(\"Threshold\")\n",
    "        axs[t].set_ylabel(\"P-value\")\n",
    "        axs[t].set_title(f\"P-values for {ts_name}\")\n",
    "        axs[t].legend()\n",
    "        t+=1\n",
    "    plt.show()\n",
    "\n",
    "plot_p_values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<div align=center>\n",
    "\n",
    "# 🪐 **Characterization**\n",
    "\n",
    "</div>\n",
    "\n",
    "## 🔄️ Angular diversity\n",
    "\n",
    "In order to determine the planet position, we need to rotate the interferometer baseline in order to rotate the transmission map. Thus, the planet signal will be modulated. By analysis this modulation (trying to fit the parametrized modulation function to the data points), it is possible to retrieve the planet position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit()\n",
    "def kernels_modulation_njit(\n",
    "    h_range:np.ndarray[float]=H_RANGE.to(u.rad).value,\n",
    "    alpha:float=PARALLACTIC_ANGLE.to(u.rad).value,\n",
    "    theta:float=ANGULAR_SEPARATION.to(u.rad).value,\n",
    "    # contrast:float=CONTRAST\n",
    ") -> np.ndarray[float]:\n",
    "    \"\"\"\n",
    "    Compute the modulation of the kernels with respect to the hour angle\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    - h_range: The range of hour angles to consider (in radian)\n",
    "    - alpha: Parallactic angle (in radian)\n",
    "    - theta: Angular separation (in radian)\n",
    "    - contrast: The contrast value\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - The modulation of the kernels.\n",
    "    \"\"\"\n",
    "\n",
    "    kernels_mod = np.zeros((3, len(h_range)))\n",
    "    for h, dh in enumerate(h_range):\n",
    "\n",
    "        projected_telescope_position = project_position_njit(h=dh)\n",
    "\n",
    "        signals = get_input_fields_njit(\n",
    "            norm=PLANET_FLUX,\n",
    "            projected_telescope_positions=projected_telescope_position,\n",
    "            parallactic_angle=alpha,\n",
    "            angular_separation=theta,\n",
    "        )\n",
    "\n",
    "        _, kernels, _ = kn_njit(\n",
    "            signals,\n",
    "            shifts=np.zeros(14),\n",
    "            shifts_total_opd=np.zeros(14),\n",
    "        )\n",
    "\n",
    "        for i in range(3):\n",
    "            kernels_mod[i, h] = kernels[i] * CONTRAST * OPTICAL_EFFICIENCY\n",
    "\n",
    "    return kernels_mod\n",
    "\n",
    "def kernels_modulation(\n",
    "    h_range:u.Quantity=H_RANGE,\n",
    "    alpha:u.Quantity=PARALLACTIC_ANGLE,\n",
    "    theta:u.Quantity=ANGULAR_SEPARATION,\n",
    "    # contrast:float=CONTRAST\n",
    "):\n",
    "    return kernels_modulation_njit(h_range.to(u.rad).value, alpha.to(u.rad).value, theta.to(u.rad).value) # , contrast)\n",
    "\n",
    "kernel_modulation = [lambda h,a,t: kernels_modulation(h,a,t)[i] for i in range(3)]\n",
    "kernel_modulation_njit = [lambda h,a,t: kernels_modulation_njit(h,a,t)[i] for i in range(3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def iplot_kernels_modulation():\n",
    "    alpha_slider = widgets.FloatSlider(value=PARALLACTIC_ANGLE.value, min=0, max=2*np.pi, step=2*np.pi/1000, description=f'Alpha (rad)')\n",
    "    theta_slider = widgets.FloatSlider(value=ANGULAR_SEPARATION.value, min=0, max=FOV.value, step=FOV.value/1000, description=f'Theta ({FOV.unit})')\n",
    "    contrast_slider = widgets.FloatSlider(value=int(np.log10(CONTRAST)), min=-10, max=0, step=1, description=f'Contrast')\n",
    "    plot = widgets.Image()\n",
    "    reset = widgets.Button(description=\"Reset\")\n",
    "\n",
    "    def update_plot(*args):\n",
    "        kms = kernels_modulation(H_RANGE, alpha_slider.value*u.rad, (theta_slider.value*FOV.unit).to(u.rad)) # , 10**contrast_slider.value\n",
    "\n",
    "        fig, axs = plt.subplots(1, 3, figsize=(20, 3))\n",
    "\n",
    "        for i in range(3):\n",
    "            ax = axs[i]\n",
    "            ax.plot(H_RANGE, kms[i])\n",
    "            ax.set_title(f\"Kernel {i+1}\")\n",
    "            ax.set_xlabel(\"Hour angle (rad)\")\n",
    "            ax.set_ylabel(\"Intensity\")  \n",
    "\n",
    "        buffer = BytesIO()\n",
    "        plt.savefig(buffer, format='png')\n",
    "        plot.value = buffer.getvalue()\n",
    "        plt.close()\n",
    "\n",
    "    def reset_values(*args):\n",
    "        alpha_slider.value = PARALLACTIC_ANGLE.value\n",
    "        theta_slider.value = ANGULAR_SEPARATION.value\n",
    "        contrast_slider.value = int(np.log10(CONTRAST))\n",
    "\n",
    "    alpha_slider.observe(update_plot)\n",
    "    theta_slider.observe(update_plot)\n",
    "    contrast_slider.observe(update_plot)\n",
    "    reset.on_click(reset_values)\n",
    "\n",
    "    update_plot()\n",
    "    display(widgets.VBox([alpha_slider, theta_slider, contrast_slider, plot, reset]))\n",
    "\n",
    "iplot_kernels_modulation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_hour_diversity(\n",
    "        data=HOUR_DIVERSITY_DATA,\n",
    "        h_range=H_RANGE,\n",
    "    ):\n",
    "\n",
    "    fits = np.zeros((3, len(h_range)))\n",
    "\n",
    "    print(\"Param    = Ideal | First guess | Found\")\n",
    "    print(\"======================================\")\n",
    "\n",
    "    popts = []\n",
    "    for i in range(3):\n",
    "        # Fit data to kernels modulations\n",
    "        p0 = [PARALLACTIC_ANGLE.value + np.random.normal(0,0.1*np.pi), (ANGULAR_SEPARATION + np.random.normal(0,0.2)*u.mas).to(u.rad).value] # , CONTRAST * np.random.normal(1,0.1)\n",
    "\n",
    "        popt, pcov = curve_fit(\n",
    "            kernel_modulation_njit[i],\n",
    "            h_range.value,\n",
    "            data[i],\n",
    "            p0=p0,\n",
    "            maxfev=10000\n",
    "        )\n",
    "\n",
    "        print(f\"Alpha    = {PARALLACTIC_ANGLE.to(u.deg):.2f} | {(p0[0]*u.rad).to(u.deg):.2f} | {(popt[0]*u.rad).to(u.deg):.2f}\")\n",
    "        print(f\"Theta    = {ANGULAR_SEPARATION.to(u.mas):.2f} | {(p0[1]*u.rad).to(u.mas):.2f} | {(popt[1]*u.rad).to(u.mas):.2f}\")\n",
    "        # print(f\"Contrast = {CONTRAST:.2e} | {p0[2]:.2e} | {popt[2]:.2e}\")\n",
    "        print(\"---\")\n",
    "        popts.append(popt)\n",
    "    popt = np.mean(popts, axis=0)\n",
    "\n",
    "    _, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "    for i in range(3):\n",
    "        fits[i] = kernels_modulation_njit(h_range.to(u.rad).value, *popt)[i]\n",
    "\n",
    "        ax = axs[i]\n",
    "\n",
    "        ax.scatter(h_range, data[i], label=\"Data\",alpha=0.5)\n",
    "        ax.plot(h_range, kernels_modulation_njit(h_range.to(u.rad).value)[i], \"--\", label=\"Expected signal\")\n",
    "        ax.plot(h_range, kernels_modulation_njit(h_range.to(u.rad).value, *popts[i])[i], label=\"Specific fit\")\n",
    "        ax.plot(h_range, fits[i], label=\"Global fit\")\n",
    "\n",
    "        ax.set_xlabel(\"Observation time (hour)\")\n",
    "        ax.set_ylabel(\"Kernel intensity\")\n",
    "        ax.set_title(f\"Kernel {i+1}\")\n",
    "        ax.legend()\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "    print(\"Param    = Ideal | Found\")\n",
    "    print(\"========================\")\n",
    "    print(f\"Alpha    = {PARALLACTIC_ANGLE.to(u.deg):.2f} | {(popt[0]*u.rad).to(u.deg):.2f}\")\n",
    "    print(f\"Theta    = {ANGULAR_SEPARATION.to(u.mas):.2f} | {(popt[1]*u.rad).to(u.mas):.2f}\")\n",
    "    # print(f\"Contrast = {CONTRAST:.2e} | {popt[2]:.2e}\")\n",
    "\n",
    "plot_hour_diversity()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🌌 On-sky contribution\n",
    "\n",
    "From the obtained data, it is possible to build a 2D distribution of the perceived sky contribution zones. This distribution provides insights into the possible locations of objects, enabling accurate initial estimations to fit the data points obtained based on the parallactic angle.\n",
    "\n",
    "This method involves stacking the transmission maps rotated by the baseline rotation and weighting each map by the corresponding data obtained for that baseline rotation.\n",
    "\n",
    "The base idea was already explored as \"image reconstruction\" technic using classical nulling interferometry $^1$. However, the method here is based on Kernel-Nulls which makes it more complex but less sensitive to phase aberations and by considerig the different Kernels, we can reduce the degeneracy of the solutions.\n",
    "\n",
    "Considering:\n",
    "- $T_{n}$ represents the n-th kernel's normalized transmission map.\n",
    "- $d_{n,\\beta}$ denotes the data point obtained for kernel $n$ with baseline rotation $\\beta$.\n",
    "- $\\alpha$ is the parallactic angle.\n",
    "- $\\theta$ is the angular separation.\n",
    "\n",
    "$$\n",
    "r_n(\\theta, \\alpha) = \\sum_a T_{n,h}(\\theta,\\alpha) d_{n,h}\n",
    "$$\n",
    "\n",
    "\n",
    "As the kernel outputs are antisymetric, we can filter the negative contributions:\n",
    "$$\n",
    "r'_n = \\frac{1}{2}(r_n+|r_n|)\n",
    "$$\n",
    "\n",
    "\n",
    "Finally, we can compute the product over all the kernels to get the final contribution zones:\n",
    "$$\n",
    "C(\\theta, \\alpha) = \\prod_n r'_n(\\theta, \\alpha)\n",
    "$$\n",
    "\n",
    "**References:**\n",
    "1. Angel, J. R. P., et N. J. Woolf. \"An Imaging Nulling Interferometer to Study Extrasolar Planets\". *The Astrophysical Journal* 475, no 1 (1997): 373‑79. https://doi.org/10.1086/303529."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_contribution_zones(\n",
    "    data: np.ndarray[float] = HOUR_DIVERSITY_DATA,\n",
    "    fov: u.Quantity = FOV,\n",
    "    resolution: int = 100,\n",
    "):\n",
    "\n",
    "    images = np.zeros((3, resolution, resolution))\n",
    "    integrated_kernels = np.zeros((3, resolution, resolution))\n",
    "\n",
    "    _, _, theta_map, _ = get_uv_map(resolution=resolution, fov=fov)\n",
    "    _, _, kernel_maps = get_transmission_map(resolution=resolution)\n",
    "    theta_map = theta_map.value / np.max(theta_map.value)\n",
    "\n",
    "    for i, h in enumerate(H_RANGE):\n",
    "\n",
    "        for j in range(3):\n",
    "            projected_telescope_position = project_position(h=h)\n",
    "            tm = get_transmission_map(projected_telescope_positions=projected_telescope_position)[2][j]\n",
    "            integrated_kernels[j] += np.abs(tm) #* theta_map\n",
    "            images[j] += tm * data[j, i] #* theta_map\n",
    "\n",
    "    for i in range(3):\n",
    "        integrated_kernel_intensity = np.sum(integrated_kernels[i])\n",
    "        kernel_intensity = np.sum(np.abs(kernel_maps[i]))\n",
    "\n",
    "        normalization_factor = integrated_kernel_intensity / kernel_intensity\n",
    "\n",
    "        print(f\"Kernel {i+1} : {integrated_kernel_intensity:.2e} / {kernel_intensity:.2e} = {normalization_factor:.2e}\")\n",
    "\n",
    "        images[i] /= normalization_factor\n",
    "\n",
    "    max_im = np.max(images)\n",
    "\n",
    "    _, axs = plt.subplots(1, 4, figsize=(25, 5))\n",
    "\n",
    "    planet_x, planet_y = αθ_to_xy()\n",
    "\n",
    "    for i in range(3):\n",
    "        img = images[i]\n",
    "        img[img < 0] = 0\n",
    "        im = axs[i].imshow(img, cmap=\"hot\", vmax=max_im, extent=EXTENT)\n",
    "        axs[i].set_title(f\"Kernel {i+1}\")\n",
    "        plt.colorbar(im, ax=axs[i])\n",
    "        axs[i].scatter(planet_x, planet_y, marker=\"+\", color=\"white\")\n",
    "\n",
    "    # Take mean of probable input flux\n",
    "    img = np.mean(images, axis=0)\n",
    "\n",
    "    # Filter where a probability of flux is null on one of the kernels\n",
    "    images[images < 0] = 0\n",
    "    mask = np.prod(images, axis=0)\n",
    "    img = img * mask / np.max(mask)\n",
    "\n",
    "    # Plot reconstructed image\n",
    "    im = axs[3].imshow(img, cmap=\"hot\", extent=EXTENT)\n",
    "    axs[3].set_title(\"Contribution zones\")\n",
    "    plt.colorbar(im, ax=axs[3])\n",
    "    axs[3].scatter(planet_x, planet_y, marker=\"+\", color=\"white\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "plot_contribution_zones()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ♒ Correlation map (WIP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def correlation_map(\n",
    "        data=HOUR_DIVERSITY_DATA,\n",
    "        h_range=H_RANGE,\n",
    "    ):\n",
    "\n",
    "    resolution = 20\n",
    "    \n",
    "    _, _, alpha_map, theta_map = get_uv_map(resolution=resolution)\n",
    "\n",
    "    correl_map = np.zeros((resolution, resolution))\n",
    "\n",
    "    for x in range(resolution):\n",
    "        for y in range(resolution):\n",
    "\n",
    "            alpha = alpha_map[x, y]\n",
    "            theta = theta_map[x, y]\n",
    "\n",
    "            km = kernels_modulation(h_range, alpha=alpha, theta=theta)[0]\n",
    "\n",
    "            correl_map[x, y] = np.sum(np.corrcoef(data[0], km))\n",
    "\n",
    "\n",
    "    _, ax = plt.subplots(1, 1, figsize=(15, 15))\n",
    "    im = ax.imshow(correl_map)\n",
    "    plt.colorbar(im, ax=ax)\n",
    "    ax.set_title(\"Correlation map\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "correlation_map()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}