main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transmit and Receive Sensor Selection Using the Multiplicity in the Virtual Array\n",
    "\n",
    "## Paper Abstract\n",
    "\n",
    "> The main focus of this paper is an active sensing application that involves selecting transmit and receive sensors to optimize the Cramér-Rao bound (CRB) on target parameters. Although the CRB is non-convex in the transmit and receive selection, we demonstrate that it is convex in the virtual array weight vector, which describes the multiplicity of the virtual array elements. Based on this finding, we propose a novel algorithm that optimizes the virtual array weight vector first and then finds a matching transceiver array. This greatly enhances the efficiency of the transmit and receive sensor selection problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preamble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Bad value in file '/home/costasak/projects/tudelft/eusipco2024/ieee-conf.mplstyle', line 22 ('savefig.pad_inches: layout'): Key savefig.pad_inches: Could not convert 'layout' to float\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from functions import *\n",
    "from using_multiplicity import *\n",
    "from solveDirectly import *\n",
    "import plot\n",
    "from tqdm.contrib.itertools import product\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "import statistics\n",
    "\n",
    "# Seaborn Set-up\n",
    "sns.set_theme(style=\"darkgrid\")\n",
    "\n",
    "figsize = plot.style(\"ieee-conf\")\n",
    "\n",
    "np.set_printoptions(precision=2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiplicity Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_tx = np.array([1, 0, 1])\n",
    "p_rx = np.array([1, 0, 1, 0, 1, 1])\n",
    "\n",
    "tx_indices = np.squeeze(np.nonzero(p_tx))\n",
    "tx_blank_indices = np.squeeze(np.nonzero(1 - p_tx))\n",
    "rx_indices = np.squeeze(np.nonzero(p_rx))\n",
    "rx_blank_indices = np.squeeze(np.nonzero(1 - p_rx))\n",
    "\n",
    "multiplicity_example = np.convolve(p_tx, p_rx)\n",
    "mult_indices = np.squeeze(np.nonzero(multiplicity_example))\n",
    "mult_blank_indices = np.squeeze(np.where(multiplicity_example == 0))\n",
    "sum_array_length = len(multiplicity_example)\n",
    "\n",
    "number_of_tx = np.sum(p_tx)\n",
    "number_of_rx = np.sum(p_rx)\n",
    "\n",
    "maximum_multiplicity = min(number_of_tx, number_of_rx)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fig. 2a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAABlCAYAAABUdbijAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAASZElEQVR4nO3dXWwbV3YH8D+HlGTZ1ZCS669sJsg2sb0bCdsmkRN7hBYILCS0+1BYD6F2nyw0ih8KKChgA20BEagStEVkoOsA++AIhfIQbDV50G5fqHHghYEWGiXxOouuOE68dpqsRtnIXxI5WkeWRc70gZ4RSVEyJQ459zLn9yLzU8dH5OHlnXvPBGzbtkEIIYQ7gt8BEEII2Roq4IQQwikq4IQQwikq4IQQwikq4IQQwikq4IQQwikq4IQQwikq4IQQwikq4IQQwqmQ3wGsx7ZtWNbWNokKQmDLj60VHmIEKE4v8RAjQHF6aasxCkIAgUDgkfdjtoBblo35+XubflwoJKC1dQdM81tkMlYVIqscDzECFKeXeIgRoDi9VEmMbW07EAxyXMC3wrJsfPbVPFa+XEBDwMZTj4UhCI9OQi2sZCwEAkAouHbWKpO1YNtAQ4idGS2Wc0kIySm7gKuqikQiga6uLui6Dk3T0N/fD9M0oWkaRkdHqxnnI125dgs/v3gdC4vL7nWtLU34Sfd+PH9wt4+R5Yr3lD6HoBDAi8/sQSivUGeyFj6+ehNZy8aR9r1MFHGWc0kIWVV2AU+n03jnnXcAAJqmwTAMxGKxqgW2GVeu3cLPfpFcc/3C4jJ+9osk/u5Eh6+FJxAAgkIAt1NL+PjqTXT9aB+A1eJ9O7WEXZFmlDHlVXWs55IQsqrs4Z4kSeve1t7e7kkwW2FZNn5+8fqG9/nPi9d9PdgRCgp48Zk92BVpxu3UEqaSc7j/IIOp5JxbvF98Zk/J6ZVa4iGXhJBVZY/AZVne8DZN0xCPx3H69GnIsoyenh6cPn0a0Wh068GVMZ3w2VfzBV/1S5lfXMYXf0jjh0+2bTmWSoVCArp+tA9TyTncNe9j/NINLC+vYE/bdhzp2Ot78Qb4yWWx4MPcBRnI4Xp4iBGgOL1Uixg9O4gpyzJGR0cRj8cBAOPj4xBFccvPJwgBtLbueOT9Vr5cKOv5Vuzynq/aXpabMX7pBgCgqakBL8vfx7ZGNo4l85bLYqLY7HcIj8RDjADF6aVqxuhp5ZAkCbIsI5FIVDTyBnJf503z20feryFQ3tf5hoCNhYXNL0v0UiZrYSo5h+XlFTQ1NWB5eQUfal8yMwLnKZf5gkEBotgM01xCNsvmkjIeYgQoTi9VEqMoNpc1cve0gBuGAUmSkEqloKpqxUW8nLWTTz0WRmtL04Zf/dtamvDUY2Ff14vmH7Dc07YdL8vfx4fal7g5/y0mf/sNE3PgvORyPdmsxWRc+XiIEaA4vVTNGDddMTRNg6qqMAwDqqrCNE0AgKIo6OvrgyzL6O3txeDgIBRF8TzgYoIQwE+69294nx937/d1DXPxapMjHXuxrTGEIx173QObH1+9iYzPIwkeckkIWRVg9aTG2ay1qZ2YpdYut7U04ccMrF0uXge+rSmE1tYdWFi4h/vLGS7WgbOSy1KcHW8LC/eYHY3xECNAcXqpkhhzOzFrPIXip+cP7saz+3fhiz+ksWIHmNo92BAScKR9b8mdmM4SQ5Z2YrKcS0LIqrop4EBuCuCHT7Yx+cm8UXH2e+67FJZzSQjJYa9yEEIIKQsVcEII4VRdTKFY6TnYK/dzF4IClu83I7O4uvYy0LANQnivjxECdnYFCAQQENam3LYygG0jEGzwIbJCPOQS4COfvOSSlzjJWmUXcF3Xcf78eczOziIWi8E0TaRSKRw/ftzfXijpOdxT/qHgusUS99sR+zffXoR2dgUr1zUEhCBCTx8G0Lh6m5VB5sZHsK0sGvbLvhYdHnIJ8JFPXnLJS5yktLILeHt7O44fPw5N09wuhKZp4ujRo7h8+XLVAnwUd+Tg0f2qIhBAQAjCMm8jc+MjhA7m+srY2VyxsczbEMRd8LsdIRe5BLjIJy+55CVOUlrFc+DORh6yvoAQQujpwxDEXbDM23hwfQrWynLu58NiE3r6cMnpALIW5ZOQnE2/wg3DcPuBz8zMYHx83L3N646E5XQjRJlL8IJBobznq5pGhA7KeHB9CvYf7yA19UvYyysIRXajcf8RBIIMFBtucgkwn09ecslLnEWoG2HOpl/lTsMqZyt9b2+ve5uXHQnL7Ua4fL+55JxdMbGlGU0MdNCzwi8hNfVLALluhJHOlyA0NPkb1EO85RJgN5+85JKXONdD3Qi3yCnkIyMjGBoaWnN9pR0Jy+1GmFlcKuv5zMUlhLb520HPzmZyI8a8boS3fn2JjREj+MolwHY+ecklL3EWo26EORW9ykVRRDKZO/2W04nQy46E5ez+Kzcx2awF+Lib0FkdYZm3EYrsRqTzJdz69SVkUrdgXdOYmLPlJZcA+/nkJZe8xLke6kZYJsMwkEgkkEwmoWkaACAWiyEcDkNRFBiG4VtHQtblFxtB3IXG/UcgNDTlfj48EJdb+pbxO1QuUD4JySl7iCJJkntS43zFZ6N3lhiKoliT5YWBhm2e3q8qbBu2lV1dHfHw630gmFtN4axbhs+NIbnIJcBFPnnJJS9xktLqop1s/k6yYFCA2NIMk7GdZPk7B4vbTLKycxDgI5cAH/nkJZe8xJmP2sk+/B1bDY4l+S+uUEhAU+uO3AEXhv6wGxUTv+e+8/GQS4CPfPKSS17iJGuxu4iSEELIhqiAE0IIp+qugNu2Df3W78Da1P6KlUHWypa8LWtlscLgiglWcwnwl0+Wc5mP4vROLWKsuwKu3/kc/3zp36HfveZ3KK4VK4NP5q7g8s3frCk6WSuLyzd/g0/mrjBXdFjMJcBnPlnNZTGK0zu1iLHiAm4YBg4ePIiRkRGoqgpFUdz14MPDw17EuCmf3prO/bz525r/7vUICCAYCOLu0nxB0XGKzd2leQQDQQhg65yTLOYS4DOfrOayGMXpnVrEWPHhekmS8Nprr0HTtII14bFYrCYF3LIt/M/XH2Epk9sSfGXufwHkktbW1AoAaA414y+/dxhCwJ8vHEEhiEN7nnWLyyfffIqjYRmffPMp7i7NY2dzGw7teRZBIehLfA4ecgnwkU9ecklx8h2jZ+vAe3p6EIvF3I08QK47oSzLW3q+bNaCaT66T8P9zH3843//C77N5PqmCAEBlm25PwFge2g7/vWv/gnbQv5uRsha2VyRWV5we3fsbGrFC/ue8714A3zlEmA7n7zkkuJkM8Zye6F4VsANw0B3dzcuXrwISZIqfj7bthEosyH/nXvz+OnUf+B3d/9vzW0Hd/4Z3pD/Fn+6va3imLywnHmA//r8Q/fy3/zgZTSFGjd4RG3xlEuA7XzykkuK0zu1jtHTnZjxeBz9/f2eFPByR+COjJXB31+K40H2gXtdY7ARP33pTd9HYw6WR4z5eMglwEc+ecklxekdL2KsSTfCfM6p1vKLdyVTKEB53QgdN1K/L0gYADzIPsCN+d/jqciTW47BK/kH2Hbv2ImjP5Dxq8813Lp3F1NfX/F9zjYf67kE+MknD7kEKE4v1TJGT2bSdV0HgDUnN56cnPTi6cuSvPMZAOAvdnXgnb8ewp/vysUyfedqzWJYT36x2dnchhf2PYemUCNe2Pccdja3rVlN4TeWcwnwlU/Wc+mgOL1TyxgrnkIxTRNvvPFGwUg7lUrhwoULeOWVV3DmzJktPe9mmlkBwBeprzB/fwGHv/cc2tr+BPPzf8RHX3+Ktm2tvn8yO+uWg4Hc6ommxga3yc3yg5VcsbGzeGHv82hgoI8Hy7kE+Mon67l0UJze8SLGcptZ1UU3wnysdilbsTK59ctCcE2MWSsLC7bvxaYYq7kE+Msny7nMR3F6h7oR1pGNiklQCML/2Vq+UD4JYXgEbts2LGtroQWDArPnyXPwECNAcXqJhxgBitNLW41REAJlLaNmtoATQgjZWN01syKEkO8KKuCEEMIpKuCEEMIpKuCEEMIpKuCEEMIpKuCEEMIpKuCEEMIpKuCEEMIpKuCEEMIpKuCEEMIpKuCEEMIpKuCEEMKpumonq6oqACCdTkOSpIpO51YNpmlCURQAQH9/v8/RbExVVaTTaei6jmg0ylwuHaqqQpIkJJNJAEAsFvM5ovWpqgpRFJnN5cDAAE6dOgUASCQSWz4ZSy2MjIy4p2+MRqM+R7PWwMAA3nrrLYiiWN1fZNeJmZkZe3Bw0L188uRJH6MpbWJiwn777bftd9991+9QNpRMJu2JiQnbtm07nU7bnZ2dPkdUWjqdtk+cOOH++8CBAz5HtD4nVievLDpx4oTd2dlpnzx50k6n036Hs678+Jy/P0tmZmbsAwcO2J2dnXZnZ6d94MCBqr3n62YErmkaWlpa3MstLS0Vn1TZa9FoFOl0GqZp+h3KhtLpNDRNQzQahSiKCIfD0HV9zTlP/SaKIsbHxwEAhmEw9bcuNjExgWPHjvkdxoZef/11Jkez+XRdd9/nuq67f3+WGIaBy5cvu6NvRVGq9s2wbgr4zMwMIpGIezkSiTBfKFkly3JBMUyn08wV73yKomBychLnzp3zO5SSdF2HLMvuFB+rpqenAeT+3gCb01HJZBKzs7MwDAMAEI/HMTQ05HNUhfLfO4qiVPWDu24KeCnOC5FsXTwex5tvvul3GBuKxWKQJAlnz55l7s0M5EZkrI9sARTMeXd3d+PYsWPVn8PdJNM0EQ6H3QFFMplk8tshkPu7m6ZZ1RzWzSqUJ554ouByKpVyD3KQrVFVFbIsM118nG9ZsixjYmICmqb5HFGhkZERALlcTk9PQ9M06Lruc1RrqaqK4eFh97Ioiu4olyWSJBW8r8PhMJNxAsDY2FjVP1jqpoDLsux+BQSA2dlZpudEWadpGkRRRDQaha7rTL5JFEXB+fPn3cvhcBjhcNjHiNbq7+9HNBpFNBp1V0axOFqUJAldXV3uZdM0mYxTluWC1yLLxz4uXLhQ9UFkXZ0TM38ZYTgcZm7kqGkaxsbGsLi4iFgsxlx8DsMw0NPT4142TRPXrl3zMaLSTNN0P2gmJycRiUSYXZ6paRrOnj2Lxx9/HGfOnGHy26Hz/pmenkZvby+TMQKrS1xN04QkScy+j3p6evDee+9VdQqlrgo4IYR8l9TNFAohhHzXUAEnhBBOUQEnhBBOUQEnhBBOUQEnhBBOUQEnnhoYGKj57zQMAwMDA+jp6YGqqlBVFSMjI+ju7gaQ28re3d3NZGsFXdfd2DezCclZ6snaxiVSW3W9lZ7UlqqqmJqagmEYNV1D7GxCcVrfOtrb22EYBtrb231b0/yoRkbt7e1u7JvZkCJJEo4cOeJFiIRjNAInnkmn03j11VcxNjbmaxymaboF0e9Rt9P/nZBqoAJOPOHsiuvt7cUHH3xQcJumaeju7oamaejr63N3UBZfBwDDw8PQNA3Dw8N4//33cejQIXeaYGBgoKBfRzHDMKCqKs6ePes2Miu1HXx4eNidZtF1Hbquu79HVVUMDAxA13VomoZ4PF7Qu6Scx+b/v52TeJQ71bHR8wG53iqKokBVVVy9enXD/5eTY1VVYZqm+29SP2gKhXjC6R8O5L7e5/dil2XZ7St+7tw596w0xdcBuTbAzuNUVS1oxdnV1bXhdEQ526oVRUEkEnHv19fXh9HRUXR0dCAcDru9NjRNQ39/P8LhMBRFwdDQUNmPVVXVPYuRKIqbasva3t6+7vOpqgrDMNyOi/kfCuvFNjo6ing8DgAYHx9nrrsgqQwVcOKJ/EZiHR0dGBsbWzOnW2o0XOo6RVFgmiZSqRROnTqF8+fPQ5blshtVRaNRd0TvFD+Hc0IAp/idPn3avS2/uJUqdOU+1gulnk/TtIJ85Z/AZL3YnAZaiUSC2Z4hZOtoCoVUTNd19Pb2ul33hoaGMDU1tennURQFqVQKsVisoPjPzs5CUZRNHeRz2qEW94R3CmDxSSsAFHxAlPqwKPexxUzT3PTURannk2UZMzMz7uXFxcVHxuYcUJYkiaZP6hAVcFIRTdMwODhY8HXemTOOx+MwDMNtR5t/QK/UdR0dHVhcXISmaW7hNQwDx44dg67r645yDcPA5OQkkslkwTLCvr4+dHR0FPyuWCyGSCTiziMXx+LMzycSCZimiUQigWQyCcMwNv1YIHeyCUVR1o1d13U3dqdX+HrPF41GEYlE3P+jYRjuAeNSsSmKgr6+PsiyjN7eXgwODtJB1TpD3QgJ83RdRzqdZrbvMyF+oRE4YZYzkkwmk1S8CSmBCjhhlrMCo6Ojw+9QCGESTaEQQginaAROCCGcogJOCCGcogJOCCGcogJOCCGcogJOCCGcogJOCCGcogJOCCGcogJOCCGcogJOCCGc+n/LZ3T3e0mk1AAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 348.761x81.397 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, axs = plt.subplots(1, 1, figsize=figsize * [1, 0.35])\n",
    "\n",
    "x = np.arange(sum_array_length)\n",
    "\n",
    "axs.scatter(tx_indices, np.ones(number_of_tx) * 2, marker=\"o\", color=\"C0\")\n",
    "axs.scatter(\n",
    "    tx_blank_indices,\n",
    "    np.ones(len(p_tx) - number_of_tx) * 2,\n",
    "    marker=\"x\",\n",
    "    color=\"C0\",\n",
    "    alpha=0.5,\n",
    ")\n",
    "axs.scatter(rx_indices, np.ones(number_of_rx), marker=\"s\", color=\"C1\")\n",
    "axs.scatter(\n",
    "    rx_blank_indices,\n",
    "    np.ones(len(p_rx) - number_of_rx),\n",
    "    marker=\"x\",\n",
    "    color=\"C1\",\n",
    "    alpha=0.5,\n",
    ")\n",
    "axs.scatter(mult_indices, np.zeros(len(mult_indices)), marker=\"*\", color=\"C2\")\n",
    "axs.scatter(\n",
    "    mult_blank_indices,\n",
    "    np.zeros(sum_array_length - len(mult_indices)),\n",
    "    marker=\"x\",\n",
    "    color=\"C2\",\n",
    "    alpha=0.5,\n",
    ")\n",
    "axs.set_xticks(range(sum_array_length))\n",
    "axs.set_xlabel(\"Array Element Index\")\n",
    "axs.set_ylim([-0.5, 2.5])\n",
    "axs.set_yticks([0, 1, 2], [\"$\\Sigma$\", \"Rx\", \"Tx\"])\n",
    "\n",
    "plot.savefig(\"figures/sum_array_example.pdf\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fig. 2b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 348.761x139.538 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, axs = plt.subplots(1, 1, figsize=figsize * np.array([1, 0.6]))\n",
    "\n",
    "axs.plot(\n",
    "    x,\n",
    "    np.concatenate(\n",
    "        [\n",
    "            np.arange(1, maximum_multiplicity),\n",
    "            maximum_multiplicity\n",
    "            * np.ones(sum_array_length + 2 - 2 * maximum_multiplicity),\n",
    "            np.flip(np.arange(1, maximum_multiplicity)),\n",
    "        ]\n",
    "    ),\n",
    "    \"C0-\",\n",
    "    label=\"Upper Bound\",\n",
    ")\n",
    "axs.stem(\n",
    "    x,\n",
    "    multiplicity_example,\n",
    "    linefmt=\"C2:\",\n",
    "    markerfmt=\"*\",\n",
    "    basefmt=\" \",\n",
    "    label=\"VAW\",\n",
    ")\n",
    "axs.set_xticks(range(sum_array_length))\n",
    "axs.set_xlabel(\"Sum Array Virtual Element Index\")\n",
    "axs.set_ylim([-0.2, 3])\n",
    "axs.set_yticks(range(maximum_multiplicity + 1))\n",
    "axs.set_ylabel(\"VAW\")\n",
    "axs.legend(ncol=2)\n",
    "\n",
    "plot.savefig(\"figures/multiplicity_example.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monte Carlo Simulations\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CRB Histogram Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load / Generate Dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_trials = 100\n",
    "number_of_targets_list = [28]\n",
    "number_of_positions_list = [32]\n",
    "\n",
    "angle_noise_std = 0\n",
    "\n",
    "element_spacing = 0.5\n",
    "\n",
    "dataframe_name = \"histogram\"\n",
    "target_angles = []\n",
    "\n",
    "try:\n",
    "    monte_carlo_results_df = pd.read_pickle(\"dataframes/\" + dataframe_name + \".xz\")\n",
    "except:\n",
    "    monte_carlo_results_list = []\n",
    "    for number_of_positions, number_of_targets, trial in product(\n",
    "        number_of_positions_list, number_of_targets_list, range(number_of_trials)\n",
    "    ):\n",
    "        number_of_transmit_positions = number_of_positions\n",
    "        number_of_receive_positions = number_of_positions\n",
    "        number_of_transmitters = int(np.floor(number_of_positions / 2))\n",
    "        number_of_receivers = int(np.ceil(number_of_positions / 2))\n",
    "\n",
    "        target_angles = uniform_target_angles(\n",
    "            number_of_targets,\n",
    "            aperture=number_of_transmit_positions + number_of_receive_positions - 1,\n",
    "            noise_std=angle_noise_std,\n",
    "        )\n",
    "\n",
    "        sum_array_response = generateSumArrayResponse(\n",
    "            target_angles,\n",
    "            number_of_transmit_positions,\n",
    "            number_of_receive_positions,\n",
    "            element_spacing,\n",
    "        )\n",
    "\n",
    "        initialization = {\n",
    "            \"tx\": randomized_rounding(\n",
    "                np.ones(number_of_transmit_positions), number_of_transmitters\n",
    "            ),\n",
    "            \"rx\": randomized_rounding(\n",
    "                np.ones(number_of_receive_positions), number_of_receivers\n",
    "            ),\n",
    "        }\n",
    "\n",
    "        tx, rx, stats = solveTxRxDirectly(\n",
    "            sum_array_response,\n",
    "            number_of_transmitters,\n",
    "            number_of_receivers,\n",
    "            number_of_transmit_positions,\n",
    "            number_of_receive_positions,\n",
    "            roundIntermediates=False,\n",
    "            initialization=initialization,\n",
    "        )\n",
    "\n",
    "        monte_carlo_results_list.append(\n",
    "            {\n",
    "                \"Method\": \"Alg. 1\",\n",
    "                \"Tx\": tx,\n",
    "                \"Rx\": rx,\n",
    "                \"Target Angles\": target_angles,\n",
    "                \"Number of Transmit Positions\": number_of_transmit_positions,\n",
    "                \"Number of Receive Positions\": number_of_receive_positions,\n",
    "                \"Number of Transmitters\": number_of_transmitters,\n",
    "                \"Number of Receivers\": number_of_receivers,\n",
    "                \"Element Spacing\": element_spacing,\n",
    "                \"Initialization\": initialization,\n",
    "                \"Stats\": stats,\n",
    "            }\n",
    "        )\n",
    "\n",
    "        tx, rx, stats = solve_tx_and_rx_using_multiplicity(\n",
    "            sum_array_response,\n",
    "            number_of_transmitters,\n",
    "            number_of_receivers,\n",
    "            number_of_transmit_positions,\n",
    "            number_of_receive_positions,\n",
    "            weighted=False,\n",
    "            round_intermediates=False,\n",
    "            initialization=initialization,\n",
    "        )\n",
    "\n",
    "        monte_carlo_results_list.append(\n",
    "            {\n",
    "                \"Method\": \"Alg. 2\",\n",
    "                \"Weighted\": \"No\",\n",
    "                \"Tx\": tx,\n",
    "                \"Rx\": rx,\n",
    "                \"Target Angles\": target_angles,\n",
    "                \"Number of Transmit Positions\": number_of_transmit_positions,\n",
    "                \"Number of Receive Positions\": number_of_receive_positions,\n",
    "                \"Number of Transmitters\": number_of_transmitters,\n",
    "                \"Number of Receivers\": number_of_receivers,\n",
    "                \"Element Spacing\": element_spacing,\n",
    "                \"Initialization\": initialization,\n",
    "                \"Stats\": stats,\n",
    "            }\n",
    "        )\n",
    "\n",
    "    monte_carlo_results_df = pd.DataFrame(monte_carlo_results_list)\n",
    "    monte_carlo_results_df.to_pickle(\"dataframes/\" + dataframe_name + \".xz\", compression=\"xz\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculate CRB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "monte_carlo_results_df[\"Worst CRB\"] = monte_carlo_results_df.apply(worst_crb_df, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fig. 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 348.761x174.422 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, axs = plt.subplots(1, 1, figsize=figsize * np.array([1, 0.75]))\n",
    "\n",
    "sns.histplot(\n",
    "    data=monte_carlo_results_df,\n",
    "    x=\"Worst CRB\",\n",
    "    bins=12,\n",
    "    hue=\"Method\",\n",
    "    multiple=\"dodge\",\n",
    "    shrink=0.875,\n",
    "    ax=axs,\n",
    ")\n",
    "\n",
    "axs.ticklabel_format(scilimits=[-1, 3])\n",
    "\n",
    "plot.savefig(\"figures/histplot_targets.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solve Time Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_trials = 20\n",
    "number_of_targets_list = np.round(np.linspace(63, 8, 20, endpoint=True)).astype(\"int\")\n",
    "number_of_positions_list = [32]\n",
    "\n",
    "angle_noise_std = 0\n",
    "\n",
    "element_spacing = 0.5\n",
    "\n",
    "dataframe_name = \"solvetime\"\n",
    "target_angles = []\n",
    "\n",
    "try:\n",
    "    monte_carlo_results_df = pd.read_pickle(\"dataframes/\" + dataframe_name + \".xz\")\n",
    "except:\n",
    "    monte_carlo_results_list = []\n",
    "    for number_of_positions, number_of_targets, trial in product(\n",
    "        number_of_positions_list, number_of_targets_list, range(number_of_trials)\n",
    "    ):\n",
    "        number_of_transmit_positions = number_of_positions\n",
    "        number_of_receive_positions = number_of_positions\n",
    "        number_of_transmitters = int(np.floor(number_of_positions / 2))\n",
    "        number_of_receivers = int(np.ceil(number_of_positions / 2))\n",
    "\n",
    "        target_angles = uniform_target_angles(\n",
    "            number_of_targets,\n",
    "            aperture=number_of_transmit_positions + number_of_receive_positions - 1,\n",
    "            noise_std=angle_noise_std,\n",
    "        )\n",
    "\n",
    "        sum_array_response = generateSumArrayResponse(\n",
    "            target_angles,\n",
    "            number_of_transmit_positions,\n",
    "            number_of_receive_positions,\n",
    "            element_spacing,\n",
    "        )\n",
    "\n",
    "        initialization = {\n",
    "            \"tx\": randomized_rounding(\n",
    "                np.ones(number_of_transmit_positions), number_of_transmitters\n",
    "            ),\n",
    "            \"rx\": randomized_rounding(\n",
    "                np.ones(number_of_receive_positions), number_of_receivers\n",
    "            ),\n",
    "        }\n",
    "\n",
    "        tx, rx, stats = solveTxRxDirectly(\n",
    "            sum_array_response,\n",
    "            number_of_transmitters,\n",
    "            number_of_receivers,\n",
    "            number_of_transmit_positions,\n",
    "            number_of_receive_positions,\n",
    "            roundIntermediates=False,\n",
    "            initialization=initialization,\n",
    "        )\n",
    "\n",
    "        monte_carlo_results_list.append(\n",
    "            {\n",
    "                \"Method\": \"Alg. 1\",\n",
    "                \"Tx\": tx,\n",
    "                \"Rx\": rx,\n",
    "                \"Target Angles\": target_angles,\n",
    "                \"Number of Transmit Positions\": number_of_transmit_positions,\n",
    "                \"Number of Receive Positions\": number_of_receive_positions,\n",
    "                \"Number of Transmitters\": number_of_transmitters,\n",
    "                \"Number of Receivers\": number_of_receivers,\n",
    "                \"Element Spacing\": element_spacing,\n",
    "                \"Initialization\": initialization,\n",
    "                \"Stats\": stats,\n",
    "            }\n",
    "        )\n",
    "\n",
    "        tx, rx, stats = solve_tx_and_rx_using_multiplicity(\n",
    "            sum_array_response,\n",
    "            number_of_transmitters,\n",
    "            number_of_receivers,\n",
    "            number_of_transmit_positions,\n",
    "            number_of_receive_positions,\n",
    "            weighted=False,\n",
    "            round_intermediates=False,\n",
    "            initialization=initialization,\n",
    "        )\n",
    "\n",
    "        monte_carlo_results_list.append(\n",
    "            {\n",
    "                \"Method\": \"Alg. 2\",\n",
    "                \"Weighted\": \"No\",\n",
    "                \"Tx\": tx,\n",
    "                \"Rx\": rx,\n",
    "                \"Target Angles\": target_angles,\n",
    "                \"Number of Transmit Positions\": number_of_transmit_positions,\n",
    "                \"Number of Receive Positions\": number_of_receive_positions,\n",
    "                \"Number of Transmitters\": number_of_transmitters,\n",
    "                \"Number of Receivers\": number_of_receivers,\n",
    "                \"Element Spacing\": element_spacing,\n",
    "                \"Initialization\": initialization,\n",
    "                \"Stats\": stats,\n",
    "            }\n",
    "        )\n",
    "\n",
    "    monte_carlo_results_df = pd.DataFrame(monte_carlo_results_list)\n",
    "    monte_carlo_results_df.to_pickle(\"dataframes/\" + dataframe_name + \".xz\", compression=\"xz\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculate Solve Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "monte_carlo_results_df[\"Number of Targets\"] = monte_carlo_results_df[\n",
    "    \"Target Angles\"\n",
    "].apply(lambda x: len(x))\n",
    "\n",
    "monte_carlo_results_df[\"Solve Time\"] = monte_carlo_results_df[\"Stats\"].apply(\n",
    "    lambda x: x[\"total\"][\"solveTime\"]\n",
    ")\n",
    "\n",
    "monte_carlo_results_df[\"Iterations of Alternating Optimization\"] = (\n",
    "    monte_carlo_results_df[\"Stats\"].apply(\n",
    "        lambda x: x[\"total\"][\"alternatingDescentIterations\"]\n",
    "    )\n",
    ")\n",
    "\n",
    "monte_carlo_results_df[\"Average Time per Iteration\"] = monte_carlo_results_df[\n",
    "    \"Stats\"\n",
    "].apply(\n",
    "    lambda stats: statistics.fmean(\n",
    "        [\n",
    "            (\n",
    "                x[\"txStats\"][\"solverStats\"].solve_time\n",
    "                + x[\"rxStats\"][\"solverStats\"].solve_time\n",
    "            )\n",
    "            / 2\n",
    "            for x in stats[\"alternatingDescent\"]\n",
    "        ]\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fig. 4a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 223.207x206.981 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, axs = plt.subplots(1, 1, figsize=figsize * np.array([0.64, 0.89]))\n",
    "\n",
    "sns.lineplot(\n",
    "    data=monte_carlo_results_df,\n",
    "    x=\"Number of Targets\",\n",
    "    y=\"Solve Time\",\n",
    "    hue=\"Method\",\n",
    "    style=\"Method\",\n",
    "    ax=axs,\n",
    ")\n",
    "\n",
    "axs.set_yscale(\"log\")\n",
    "\n",
    "h, _ = axs.get_legend_handles_labels()\n",
    "axs.legend(h, [\"Previously\", \"Proposed\"])\n",
    "\n",
    "plot.savefig(\"figures/solvetime_vs_number_of_targets.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fig. 4b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 223.207x206.981 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, axs = plt.subplots(1, 1, figsize=figsize * np.array([0.64, 0.89]))\n",
    "\n",
    "sns.lineplot(\n",
    "    data=monte_carlo_results_df,\n",
    "    x=\"Number of Targets\",\n",
    "    y=\"Iterations of Alternating Optimization\",\n",
    "    hue=\"Method\",\n",
    "    style=\"Method\",\n",
    "    ax=axs,\n",
    ")\n",
    "axs.set_ylim(bottom=0)\n",
    "axs.set_ylabel(\"Iterations\")\n",
    "\n",
    "h, _ = axs.get_legend_handles_labels()\n",
    "axs.legend(h, [\"Alg. 1\", \"Alg. 2\"])\n",
    "\n",
    "plot.savefig(\"figures/iterations_vs_number_of_targets.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solve Time Per Iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 223.207x206.981 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, axs = plt.subplots(1, 1, figsize=figsize * np.array([0.64, 0.89]))\n",
    "\n",
    "sns.lineplot(\n",
    "    data=monte_carlo_results_df,\n",
    "    x=\"Number of Targets\",\n",
    "    y=\"Average Time per Iteration\",\n",
    "    hue=\"Method\",\n",
    "    style=\"Method\",\n",
    "    ax=axs,\n",
    ")\n",
    "axs.set_yscale(\"log\")\n",
    "\n",
    "h, _ = axs.get_legend_handles_labels()\n",
    "axs.legend(h, [\"Alg. 1\", \"Alg. 2\"])\n",
    "\n",
    "plot.savefig(\"figures/average_time_per_iteration_vs_number_of_targets.pdf\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}