notebooks/Transmission_with_Rayleigh_and_AWGN_channels.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulating transmission with Rayleigh and AWGN channels and different constellation sizes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook illustrates how to perform a simulation of a transmission through Rayleigh channel using different modulations. \n",
    "Furthermore, it describe how smulations can be run in parallel.\n",
    "\n",
    "This is a modification of the [Transmission_with_AWGN_channel](Transmission_with_AWGN_channel.ipynb) notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import math\n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from pyphysim.modulators.fundamental import BPSK, QAM, Modulator\n",
    "from pyphysim.simulations import Result, SimulationResults, SimulationRunner\n",
    "from pyphysim.util.conversion import dB2Linear, linear2dB\n",
    "from pyphysim.util.misc import pretty_time, randn_c, count_bit_errors\n",
    "\n",
    "np.set_printoptions(precision=2, linewidth=120)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualize the constellation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First let's visualize the different constellations that will be employed.\n",
    "\n",
    "For $M=2$, BPSK modulation will be used, with symbols being $-1$ and $1$. For other sizes QAM modulation will be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARMAAAEICAYAAAB8uBDgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAR8ElEQVR4nO3df6xkZX3H8fenUlipQRZ2IysqC4UUsLagV2tro60ggk0X/FEFbQQDoVSxtUYjhjam+KOoTTC2Vt0ookYR3dZ2jVoKAhoT17JE5GeBBfzBdvkhC7SGH8ry7R9zrh0ud+696zx35s7l/UomM/M8zzn3ORfmw5xzLs83VYUkDetXxj0BScuDYSKpCcNEUhOGiaQmDBNJTRgmkpowTCQ1YZjol5LkB0keSPLTJPck+WqSp3d95yX5Wde3PclFSQ7u+vZMcm6S25P8b5Ibk5zRt99KcmDf+7cl2ZbkmaM/Su0Mw0TD+OOqehKwBrgD+Ie+vg90fU8D7gTO69rPAZ4EHAI8GVgHbJlt50n+GngL8KKqunYR5q+GDBMNraoeBDYAh87Sdz/weeA3u6bnAp+vqnuq6pGq+q+q2jBzuyTvAU4BXlhVNy7e7NXKLuOegCZfkt2B1wCbZul7EvA64Htd0ybgvUlWAt+uqptm2eXZwG/TC5IfLc6s1ZrfTDSMf01yL3Af8BLgg319b+v6ttA7rTmpa38z8DngdOC6JFuSHDNjv0cB/26QTBbDRMM4rqr2BFbQC4dvJtmn6/v7qtqzqvapqnVVdTNAVT1QVe+rqucAewNfBL6UZK++/R4PvCrJ347uUDQsw0RDq6odVfUvwA7g93diu/8B3gf8GrB/X9eNwJHAG/vv9GhpM0w0tPQcC6wErp9n7N8keW6SXZOsAP4SuBe4oX9cd/fmSODtSd6yKBNXU16A1TC+kmQHUMAPgROr6tokc21TwKeAZwAPA1cBf1RVP33MwKrvJ3kpcFGSB6vqY82PQM3ExZEkteBpjqQmDBNJTRgmkpowTCQ1MZF3c1atWlVr164d9zSkx50rrrjiJ1W1era+iQyTtWvXsnnz5nFPQ3rcSfLDQX2e5khqwjCR1ESTMOlWzrozyTUD+pPkw93/IXpVkmf39Z2Y5KbucWKL+UgavVbfTM4Djp6j/xjgoO5xKvBRgO7/FH0X8DvA84B3detcSJowTcKkqr4FbJ9jyLHAZ6pnE7BnkjXAS4GLqmp7Vd0DXMTcoSRpiRrVNZN9gR/3vb+taxvULmnCTMwF2CSnJtmcZPNdd9017ulImmFUYbIVeHrf+6d1bYPaH6Oq1lfVVFVNrV4969/MSBqjUYXJRuD13V2d5wP3VdU24ELgqCQruwuvR3VtkiZMk7+ATXI+8AfAqiS30btD86sA3YI2XwNeRm9x4fuBN3R925O8G7i829VZVTXXhVxJS1STMKmqE+bpL+BNA/rOBc5tMQ9J4zMxF2AlLW2GiaQmDBNJTRgmkpowTCQ1YZhIasIwkdSEYSKpCcNEUhOGiaQmDBNJTRgmkpowTCQ1YZhIasIwkdSEYSKpCcNEUhOtKvodneSGrmLfGbP0n5Pkyu5xY5J7+/p29PVtbDEfSaM39LKNSZ4AfAR4Cb26N5cn2VhV102Pqaq/6hv/ZuDwvl08UFWHDTsPSePV4pvJ84AtVXVLVf0M+AK9Cn6DnACc3+DnSlpCWoTJgqvyJdkP2B+4pK95RVdca1OS4wb9EItwSUvbqC/AHg9sqKodfW37VdUU8FrgQ0l+fbYNLcIlLW0twmTBVfnohcmjTnGqamv3fAtwGY++niJpQrQIk8uBg5Lsn2RXeoHxmLsySQ4GVgLf6WtbmWS37vUq4AXAdTO3lbT0DX03p6oeTnI6vbKeTwDOraprk5wFbK6q6WA5HvhCV5Br2iHAx5M8Qi/Yzu6/CyRpcuTRn+3JMDU1VZs3bx73NKTHnSRXdNc4H8O/gJXUhGEiqQnDRFIThomkJgwTSU0YJpKaMEwkNWGYSGrCMJHUhGEiqQnDRFIThomkJgwTSU0YJpKaMEwkNWGYSGpiVEW4TkpyV1+xrVP6+k5MclP3OLHFfCSN3kiKcHUuqKrTZ2y7F/AuYAoo4Ipu23uGnZek0RpHEa5+LwUuqqrtXYBcBBzdYE6SRmyURbhemeSqJBuSTJfG2JkCXhbhkpawUV2A/Qqwtqp+i963j0/v7A4swiUtbSMpwlVVd1fVQ93bTwDPWei2kibDSIpwJVnT93YdcH33+kLgqK4Y10rgqK5N0oQZVRGuv0iyDngY2A6c1G27Pcm76QUSwFlVtX3YOUkaPYtwSVowi3BJWnSGiaQmDBNJTRgmkpowTCQ1YZhIasIwkdSEYSKpCcNEUhOGiaQmDBNJTRgmkpowTCQ1YZhIasIwkdSEYSKpCcNEUhOjquj31iTXdaUuvpFkv76+HX2V/jbO3FbSZBhVRb/vAVNVdX+SPwc+ALym63ugqg4bdh6SxmskFf2q6tKqur97u4leSQtJy8goK/pNOxn4et/7FV2lvk1Jjhu0kRX9pKVt6NOcnZHkT+kVKX9RX/N+VbU1yQHAJUmurqqbZ25bVeuB9dBbnX4kE5a0YCOp6AeQ5EjgTGBdX3U/qmpr93wLcBlweIM5SRqxUVX0Oxz4OL0gubOvfWWS3brXq4AXAP0XbiVNiFFV9Psg8CTgS0kAflRV64BDgI8neYResJ094y6QpAlhRT9JC2ZFP0mLzjCR1IRhIqkJw0RSE4aJpCYME0lNGCaSmjBMJDVhmEhqwjCR1IRhIqkJw0RSE4aJpCYME0lNGCaSmjBMJDUxqiJcuyW5oOv/bpK1fX3v7NpvSPLSFvMBYNs2eNGL4Pbbm+1SWpYafVaGDpO+IlzHAIcCJyQ5dMawk4F7qupA4Bzg/d22h9JbM/aZwNHAP3X7G9673w3f/jacdVaT3UnLVqPPykiKcHXvP9293gAckd5isMcCX6iqh6rqVmBLt79f3hOfCAl89KPwyCO956TXLun/Nf6sjKoI1y/GVNXDwH3A3gvcFtiJIly33AKvfS3svnvv/e67w+teB7feuhOHJD0ONP6sTMwF2KpaX1VTVTW1evXqwQPXrIE99oAHH4QVK3rPe+wB++wzuslKk6DxZ2VURbh+MSbJLsCTgbsXuO3Ou+MOOO002LSp9+xFWGl2DT8rQ5e66MLhRuAIekFwOfDaqrq2b8ybgGdV1WlJjgdeUVWvTvJM4PP0rpM8FfgGcFBV7ZjrZ1rqQhqPuUpdjKoI1yeBzybZAmyndweHbtwX6VXxexh403xBImlpsgiXpAWzCJekRWeYSGrCMJHUhGEiqQnDRFIThomkJgwTSU0YJpKaMEwkNWGYSGrCMJHUhGEiqQnDRFIThomkJgwTSU0YJpKaGCpMkuyV5KIkN3XPK2cZc1iS7yS5NslVSV7T13dekluTXNk9DhtmPpLGZ9hvJmcA36iqg+it3/qYan7A/cDrq2q60NaHkuzZ1//2qjqse1w55HwkjcmwYdJfXOvTwHEzB1TVjVV1U/f6v4E7gTlqVUiaRMOGyVOqalv3+nbgKXMNTvI8YFfg5r7m93anP+ck2W2ObRdWhEvSWMwbJkkuTnLNLI9HlQCt3srUA1enTrIG+Czwhqp6pGt+J3Aw8FxgL+Adg7ZfcBEuSWMxb6mLqjpyUF+SO5KsqaptXVjcOWDcHsBXgTOralPfvqe/1TyU5FPA23Zq9pKWjGFPczYCJ3avTwT+beaAJLsCXwY+U1UbZvSt6Z5D73rLNUPOR9KYDBsmZwMvSXITcGT3niRTST7RjXk18ELgpFluAX8uydXA1cAq4D1DzkfSmFiES9KCWYRL0qIzTCQ1YZhIasIwkdSEYSKpCcNEUhOGiaQmDBNJTRgmkpowTCQ1YZhIasIwkdSEYSKpCcNEUhOGiaQmDBNJTRgmkppY9Ip+3bgdfUs2buxr3z/Jd5NsSXJBt16spAk0iop+AA/0Ve1b19f+fuCcqjoQuAc4ecj5SBqTRa/oN0i3Iv2LgekV63dqe0lLy6gq+q3oqvFtSnJc17Y3cG9VPdy9vw3Yd9APsqKftLTNW4QrycXAPrN0ndn/pqoqyaCl7verqq1JDgAu6cpb3LczE62q9cB66K1OvzPbSlp8I6noV1Vbu+dbklwGHA78M7Bnkl26bydPA7b+EscgaQkYRUW/ldMFyZOsAl4AXNfVJr4UeNVc20uaDKOo6HcIsDnJ9+mFx9lVdV3X9w7grUm20LuG8skh5yNpTKzoJ2nBrOgnadEZJpKaMEwkNWGYSGrCMJHUhGEiqQnDRFIThomkJgwTSU0YJpKaMEwkNWGYSGrCMJHUhGEiqQnDRFIThomkJha9CFeSP+wrwHVlkgenV6hPcl6SW/v6DhtmPpLGZ9GLcFXVpdMFuOjVybkf+I++IW/vK9B15ZDzkTQmoy7C9Srg61V1/5A/V9ISM6oiXNOOB86f0fbeJFclOWd6FfvZWIRLWtrmDZMkFye5ZpbHsf3jutIVA1en7urqPAu4sK/5ncDBwHOBveitVj+rqlpfVVNVNbV69er5pi1pxEZShKvzauDLVfXzvn1Pf6t5KMmngLctcN6SlphFL8LV5wRmnOJ0ATRdxPw44Joh5yNpTEZRhIska4GnA9+csf3nurrDVwOrgPcMOR9JYzLvac5cqupu4IhZ2jcDp/S9/wGw7yzjXjzMz5e0dPgXsJKaMEwkNWGYSGrCMJHUhGEiqQnDRFIThomkJgwTSU0YJpKaMEwkNWGYSGrCMJHUhGEiqQnDRFIThomkJgwTSU0MW4TrT5Jcm+SRJFNzjDs6yQ1JtiQ5o699/yTf7dovSLLrMPORND7DfjO5BngF8K1BA5I8AfgIcAxwKHBCkkO77vcD51TVgcA9wMlDzkfSmAwVJlV1fVXdMM+w5wFbquqWqvoZ8AXg2G4R6RcDG7pxCyniJWmJGsU1k32BH/e9v61r2xu4t6oentEuaQLNu6B0kouBfWbpOrOq5ipt0VSSU4FTAZ7xjGeM6sdKWqChinAt0FZ6ZS6mPa1ruxvYM8ku3beT6fZB81gPrAeYmpoaWDlQ0niM4jTncuCg7s7NrvTqDW/syoleSq+YOcxfxEvSEjbsreGXJ7kN+F3gq0ku7NqfmuRrAN23jtPp1Ri+HvhiVV3b7eIdwFuTbKF3DeWTw8xH0vik9wVhskxNTdXmzZvHPQ3pcSfJFVU169+U+RewkpowTCQ1MZGnOUnuAn64gKGrgJ8s8nRGZbkcy3I5Dnh8Hst+VbV6to6JDJOFSrJ50PndpFkux7JcjgM8lpk8zZHUhGEiqYnlHibrxz2BhpbLsSyX4wCP5VGW9TUTSaOz3L+ZSBoRw0RSE8sqTIZdRnIpSbJXkouS3NQ9rxwwbkeSK7vHxlHPc5D5fsdJduuW6tzSLd25dgzTXJAFHMtJSe7q++dwyjjmOZ8k5ya5M8k1A/qT5MPdcV6V5Nk79QOqatk8gEOA3wAuA6YGjHkCcDNwALAr8H3g0HHPfZZ5fgA4o3t9BvD+AeN+Ou65/jK/Y+CNwMe618cDF4x73kMcy0nAP457rgs4lhcCzwauGdD/MuDrQIDnA9/dmf0vq28mNcQykos/u512LL2lLGHylrRcyO+4//g2AEd0S3kuNZPy78u8qupbwPY5hhwLfKZ6NtFbb2jNQve/rMJkgQYtI7nUPKWqtnWvbweeMmDciiSbk2xKctxopjavhfyOfzGmestU3EdvGYqlZqH/vryyOzXYkOTps/RPgqE+G/OutLbULJVlJFuY61j631RVJRl0D3+/qtqa5ADgkiRXV9XNreeqOX0FOL+qHkryZ/S+cb14zHMauYkLk1q8ZSRHbq5jSXJHkjVVta37qnnngH1s7Z5vSXIZcDi9c/xxWsjveHrMbUl2AZ5MbynPpWbeY6mq/nl/gt71rkk01Gfj8XiaM+sykmOe02w20lvKEgYsaZlkZZLdutergBcA141shoMt5Hfcf3yvAi6p7irgEjPvscy4rrCO3oqCk2gj8Prurs7zgfv6TrXnN+4rzI2vVr+c3nneQ8AdwIVd+1OBr824an0jvf+CnznueQ84lr2BbwA3ARcDe3XtU8Anute/B1xN7w7D1cDJ4573XL9j4CxgXfd6BfAlYAvwn8AB457zEMfyd8C13T+HS4GDxz3nAcdxPrAN+Hn3OTkZOA04resPvYJ5N3f/Ps16R3TQwz+nl9TE4/E0R9IiMEwkNWGYSGrCMJHUhGEiqQnDRFIThomkJv4Pbvy0ShGqFt0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe8AAAHiCAYAAADBF0QTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/fUlEQVR4nO3dfbxcZX3v/c/XRNhJbeQhKUQgBNrUgtqi7oOoVayCAncPgYI2hJbggTumlravetsjHHpbm9SKep+jVamaIgJqBaQ+RIulPEgtp4ayaSOPBUIQSUhg8yB3kScDv/PHWhsmk5k9a8/DmnWt+b5fr3nNzJprrd/vmuwrv5m11lxLEYGZmZml40XDTsDMzMxmxsXbzMwsMS7eZmZmiXHxNjMzS4yLt5mZWWJcvM3MzBLj4m1mZpYYF28zM7PEuHiPEElLJD0l6csd2h0saZ2kxyT9p6RrJB3Wot1LJD0u6bstXvuRpGckzW9a/u+SQtLinjtkNgIknSFpQtLTki5oem2upL+W9FA+Xr9fYHu/KelfJf1U0sOSvixpnxbt3pKP1Q80LV+cL//3puXz8zH/o+56ajPh4j1azgVumK6BpF8E/jdwM3AA8DLgm8CVkg5tan4C8DRwpKS9W2zuHuCkhm2/CpjbbfJmI+p+4C+A81u8thbYAzgov//j6TYk6UTgb4FPAvOBVwDPAP8sabem5iuAR4BT2mxurqRXNjxfTjbmrQQu3iNC0jLgJ8DVHZp+CPhBRJwdEY9ExH9GxKeALwMfbWq7AvgccBPwOy229SV2HPgrgItmnr3Z6IqIr0fEN4GHG5dL+hXgWGBlRExGxLMRcWO77UgS8D+Bv4iIv42IJyNiG3A68ATwRw1tfw44Efh9YImk8Rab/BLZmJ5yCh7fpXHxHgGS5gGrgfcVaH4k8LUWyy8F3iRpLN/m/sBbgK/kt1afztcD8yQdJGkWsIzsQ4CZ9e5Q4F7gz/Pd5jdLOmGa9i8HFtE0viPiOeDvgLc3LP4t4PG87RXsWKSnfBlYJmmWpIOBlwDXd9sZmxkX79GwBvhCRGwu0HY+sLXF8q3ALLJdcwC/C9wUEbcBFwOvkPTqFutNffs+Ergd2DLD3M2stX2BVwKPkR3eOgO4UNJBbdpPnX/SbnwvaHi+ArgkIp4l282+TNKLm9bZDNwBHEE2xr/UTSesOy7eNSfpELLB9YkWr92an3D2uKQ35YsfAha22NRCIHhh190pZN+4iYgtwD/R+tP5l8iOhZ2Kd6mZ9dOTwM/IdoM/ExH/BHwPeLukRQ1j+/G8/UP5fbvx/RCApP2A3yAf38C3gDHg/2qx3kVkY/skXLxL5eJdf28BFgM/lrQNeD9wgqR/i4hXRMRL8ts/5+2vAt7ZYjvvAtZHxNOS3gAsAc6StC3f7uuA5ZJmN64UEfeSncRyDPD1AfTPbFTd1GJZAETEjxvG9kvy1+4g+7a8w/iW9CKyk0+vzRf9Lllt+HY+tjeRFe9WH87/jqyob4qIH/fWHZuJ2Z2bWOLWku3WnvJ+smL+e23a/zlwg6QPk53c8jOyT9bvBn4zb7MCuJIdj3PPIfvP5Gjg203bPA3YPSJ+2lzczWx6+ZiZTXbYalZ+3sl24PvAj8k+RH+E7AP0bwD/vdV2IiIkvR/4G0mbyT5M7wb8Jdku9U/nTVeQ/T/wuYbVDwW+JmnPpm3+VNJbgUf70FWbAf9HWnMR8QTZmaQA5LvQnoqIyTbt75L068A5wI+AnwP+Ezg+Iq7K/+N4F3BKfqbq8yRNnX367aZt3t2/HpmNnD8F/qzh+e8Afx4RH5K0FDgPOJPs5LVTIuI/2m0oIi6R9FS+zfPIPnTfDBweEVvz+Rz2B85t+j9inaSNZLvHv9O0zYmee2gzpogYdg5WYZL2JTtr/M8i4gvDzsfM+kfS28lOSDsiIjYMOR2bAR/ztmnlZ6gfDSyU9JJO7c0sHRHxj2SHxHaaQdGqzd+8zczMEuNv3mYjSNL5kh6UdEub1yXpU5I2SrpJ0msaXlsh6a781uoMZDMbMBdvs9F0AXDUNK8fTfZzwCXASuCzAJL2IDt56nVkZyD/maTdB5qpme2ksmebz58/PxYvXjzsNMwq78Ybb3woIhZ0bvmCiPh+hyu7LQUuiuy42npJu0laSDZvwJUR8QiApCvJPgR8dbp4Hs9mxRQdz5Ut3osXL2Ziwr9AMOtE0r0D2Ow+wH0Nzzfny9otn5bHs1kxRcezd5ub2UBIWplfh3picrLltAJm1iUXbzNrZQuwX8PzffNl7ZbvJCLWRsR4RIwvWDCjvfpm1kHaxXvrVjj8cNi2rXNbs9QM9+97HXBKftb5YcBjEbGV7PKQb5e0e36i2tvzZb0Z1bE8iv0exT5D3/uddvFeswauuw5Wrx52Jmb9N8C/b0lfBX4AvFzSZkmnSVolaVXe5HKyC1JsBP4GeC9AfqLaGuCG/LZ66uS1nozqWB7Ffo9in6Hv/a7sJC3j4+PR9gSXOXPgqad2Xj42Bk8+OdjEzAZthn/fkm6MiPESMuta2/E8qmN5FPs9in2GgY3nNL95b9oEy5fD3LnZ87lz4eST4Z57hpuXWT+M0t/3KPW10Sj2exT7DAPrd5rFe+FCmDcv+zQzNpbdz5sHe+897MzMejdKf9+j1NdGo9jvUewzDKzfaRZvgAcegFWrYP367H7UTn6wehulv+9R6mujUez3KPYZBtLvNI95m9nzkj7mbWY7qPcxbzMzsxHm4m1mZpYYF28zM7PEuHibmZklxsXbzMwsMS7eZmZmielL8ZZ0lKQ7JG2UdGabNu+SdJukWyX9bT/impmZjaLZvW5A0izgXOBIYDNwg6R1EXFbQ5slwFnAGyPiUUm/0GtcMzOzUdWPb96HAhsjYlNEPANcDCxtavN/A+dGxKMAEfFgH+KamZmNpH4U732A+xqeb86XNfpl4Jcl/W9J6yUd1WpDklZKmpA0MTk52YfUzMzM6qesE9ZmA0uAtwAnAX8jabfmRhGxNiLGI2J8wYIFJaVmZmaWln4U7y3Afg3P982XNdoMrIuIn0XEPcCdZMXczIag00mmkj4haUN+u1PSTxpee7bhtXWlJm5mQB9OWANuAJZIOoCsaC8Dlje1+SbZN+4vSppPtht9Ux9im9kMFTnJNCL+uKH9HwCvbtjEkxFxSEnpmlkLPX/zjojtwBnAFcDtwKURcauk1ZKOzZtdATws6Tbge8CfRMTDvcY2s64UOcm00UnAV0vJzMwK6cc3byLicuDypmUfbHgcwPvym5kNV6uTTF/XqqGk/YEDgGsaFo9JmgC2A+dExDcHlKeZtdGX4m1mtbUMuCwinm1Ytn9EbJF0IHCNpJsj4u7mFSWtBFYCLFq0qJxszUaEp0c1Gz1FTjKdsoymXeYRsSW/3wRcy47Hwxvb+dcjZgPi4m02ep4/yVTSLmQFeqezxiX9CrA78IOGZbtL2jV/PB94I3Bb87pmNljebW42YiJiu6Spk0xnAedPnWQKTETEVCFfBlycn7My5SDg85KeI/vwf07jWepmVg4Xb7MR1Okk0/z5h1qs9y/AqwaanJl15N3mZmZmiXHxNjMzS4yLt5mZWWJcvM3MzBLj4m1mZpYYF28zM7PEuHibmZklxsXbzMwsMS7eZmZmiXHxNjMzS4yLt5mZWWJcvM3MzBLTl+It6ShJd0jaKOnMadqdICkkjfcjrpmZ2SjquXhLmgWcCxwNHAycJOngFu1+Hvgj4PpeY5qZmY2yfnzzPhTYGBGbIuIZ4GJgaYt2a4CPAk/1IaaZmdnI6kfx3ge4r+H55nzZ8yS9BtgvIv6+D/HMrEedDnVJOlXSpKQN+e30htdWSLorv60oN3MzA5g96ACSXgT8L+DUAm1XAisBFi1aNNjEzEZUw6GuI8k+bN8gaV1E3NbU9JKIOKNp3T2APwPGgQBuzNd9tITUzSzXj2/eW4D9Gp7vmy+b8vPAK4FrJf0IOAxY1+qktYhYGxHjETG+YMGCPqRmZi0UPdTVyjuAKyPikbxgXwkcNaA8zayNfhTvG4Alkg6QtAuwDFg39WJEPBYR8yNicUQsBtYDx0bERB9im9nMdTzUlTtB0k2SLpM09QG96LpmNkA9F++I2A6cAVwB3A5cGhG3Slot6dhet29mQ/FtYHFE/CrZt+sLZ7oBSSslTUiamJyc7HuCZqOsL8e8I+Jy4PKmZR9s0/Yt/YhpZl3rdKiLiHi44el5wMca1n1L07rXtgoSEWuBtQDj4+PRS8JmtiPPsGY2eqY91AUgaWHD02PJ9qpBtoft7ZJ2l7Q78PZ8mZmVaOBnm5tZtUTEdklTh7pmAedPHeoCJiJiHfCH+WGv7cAj5L8WiYhHJK0h+wAAsDoiHim9E2YjzsXbbAR1OtQVEWcBZ7VZ93zg/IEmaGbT8m5zMzOzxLh4m5mZJcbF28zMLDEu3mZmZolx8TYzM0uMi7eZmVliXLzNzMwS4+JtZmaWGBdvMzOzxLh4m5mZJcbF28yGb+tWOPxw2LZt2JmUaxT7PYp9hr7328XbzIZvzRq47jpYvXrYmZRrFPs9in2GvvdbEdW8zO74+HhMTEwMOw2zypN0Y0SMDzuP6bQdz3PmwFNP7bx8bAyefHLwiQ3LKPZ7FPsMM+530fHsb95mNjybNsHy5TB3bvZ87lw4+WS4557h5jVoo9jvUewzDKzffSneko6SdIekjZLObPH6+yTdJukmSVdL2r8fcc0scQsXwrx52TeTsbHsft482HvvYWc2WKPY71HsMwys3z0Xb0mzgHOBo4GDgZMkHdzU7N+B8Yj4VeAy4GO9xjWzmnjgAVi1Ctavz+5H5USmUez3KPYZBtLvno95S3o98KGIeEf+/CyAiPhIm/avBj4TEW+cbrs+5m1WTDfHvCUdBfwVMAs4LyLOaXr9fcDpwHZgEvhvEXFv/tqzwM150x9HxLGd4nk8mxVTdDzP7kOsfYD7Gp5vBl43TfvTgO/2Ia6ZdaFhb9mRZOP1BknrIuK2hmZTe8uekPR7ZHvLfjt/7cmIOKTMnM1sR6WesCbpd4Bx4ONtXl8paULSxOTkZJmpmY2SQ4GNEbEpIp4BLgaWNjaIiO9FxBP50/XAviXnaGbT6Efx3gLs1/B833zZDiQdAZwNHBsRT7faUESsjYjxiBhfsGBBH1IzsxZa7S3bZ5r2zXvLxvIP2eslHdduJX8YNxucfuw2vwFYIukAsqK9DFje2CA/zv154KiIeLAPMc2sBA17yw5vWLx/RGyRdCBwjaSbI+Lu5nUjYi2wFrJj3qUkbDYiev7mHRHbgTOAK4DbgUsj4lZJqyVNncjyceAlwNckbZC0rte4Zta1nvaWRcSW/H4TcC3w6kEma2Y768c3byLicuDypmUfbHh8RD/imFlfdL23TNLuwBMR8bSk+cAb8U8/zUrXl+JtZumIiO2SpvaWzQLOn9pbBkxExDp23FsGL/wk7CDg85KeI9tzd07TWepmVgIXb7MR1O3esoj4F+BVg83OzDrx3OZmZmaJcfE2MzNLjIu3mZlZYly8zczMEuPibWZmlhgXbzMzs8S4eJuZmSXGxdvMzCwxLt5mZmaJcfE2MzNLjIu3mZlZYly8zczMEuPibWZmlhgXbzMzs8S4eJuZmSWmL8Vb0lGS7pC0UdKZLV7fVdIl+evXS1rcj7hm1r1exq2ks/Lld0h6R6mJm1nvxVvSLOBc4GjgYOAkSQc3NTsNeDQifgn4BPDRXuOaWfd6Gbd5u2XAK4CjgL/Ot2dmJenHN+9DgY0RsSkingEuBpY2tVkKXJg/vgx4myT1IbaZdaeXcbsUuDgino6Ie4CN+fbMrCT9KN77APc1PN+cL2vZJiK2A48Be/Yhtpl1p5dxW2RdMxugSp2wJmmlpAlJE5OTk8NOx8x64PFsNjj9KN5bgP0anu+bL2vZRtJs4KXAw80bioi1ETEeEeMLFizoQ2pm1kYv47bIuh7PZgPUj+J9A7BE0gGSdiE7kWVdU5t1wIr88YnANRERfYhtZt3pZdyuA5blZ6MfACwB/rWkvM0MmN3rBiJiu6QzgCuAWcD5EXGrpNXARESsA74AfEnSRuARsv8ozGxIehm3ebtLgduA7cDvR8SzQ+mI2YhSVb8Aj4+Px8TExLDTMKs8STdGxPiw85iOx7NZMUXHc6VOWDMzM7POXLzNzMwS4+JtZmaWGBdvMzOzxLh4m5mZJcbF28zMLDEu3mZmZolx8TYzM0uMi7eZmVliXLzNzMwS4+JtZmaWGBdvMzOzxLh4m5mZJcbF28zMLDEu3mZmZolx8TYbIZL2kHSlpLvy+91btDlE0g8k3SrpJkm/3fDaBZLukbQhvx1SagfMDHDxNhs1ZwJXR8QS4Or8ebMngFMi4hXAUcAnJe3W8PqfRMQh+W3DoBM2s531VLx7/RRvZqVbClyYP74QOK65QUTcGRF35Y/vBx4EFpSVoJl11us37358ijez8uwVEVvzx9uAvaZrLOlQYBfg7obFH84/iH9C0q4DytPMptFr8faneLOKkXSVpFta3JY2touIAGKa7SwEvgS8OyKeyxefBfwK8F+APYAPTLP+SkkTkiYmJyd77ZaZNZjd4/r9+BRvZn0UEUe0e03SA5IWRsTWvDg/2KbdPODvgbMjYn3DtqfG+9OSvgi8f5o81gJrAcbHx9t+SDCzmetYvCVdBezd4qWzG59EREgq8il+RcOn+OY2K4GVAIsWLeqUmpnN3DpgBXBOfv+t5gaSdgG+AVwUEZc1vTZV+EW2p+2WgWdsZjvpWLwH+Sm+RSx/UjcbrHOASyWdBtwLvAtA0jiwKiJOz5e9GdhT0qn5eqfmZ5Z/RdICQMAGYFWp2ZsZ0Psx76lP8dDFp3gzK1dEPBwRb4uIJRFxREQ8ki+fyAs3EfHliHhxw8/Bnv9JWES8NSJeFRGvjIjfiYjH+5LY1q1w+OGwbVtfNpeMUez3KPYZ+t7vXov3OcCRku4CjsifI2lc0nl5m6lP8ad6Ygcza2nNGrjuOli9etiZlGsU+z2KfYa+91vZCafVMz4+HhMTE8NOw6zyJN0YEePDzmM6bcfznDnw1FM7Lx8bgyefHHxiwzKK/R7FPsOM+110PHuGNTMbnk2bYPlymDs3ez53Lpx8Mtxzz3DzGrRR7Pco9hkG1m8XbzMbnoULYd687JvJ2Fh2P28e7N3qBy41Mor9HsU+w8D67eJtZsP1wAOwahWsX5/dj8qJTKPY71HsMwyk3z7mbZa4pI95m9kOfMzbzMysply8zczMEuPibWZmlhgXbzMzs8S4eJuZmSXGxdvMzCwxLt5mZmaJcfE2MzNLjIu3mZlZYly8zczMEuPibTZiJO0h6UpJd+X3u7dp96ykDfltXcPyAyRdL2mjpEsk7VJe9mYGLt5mo+hM4OqIWAJcnT9v5cmIOCS/Hduw/KPAJyLil4BHgdMGm66ZNXPxNhs9S4EL88cXAscVXVGSgLcCl3Wzvpn1R0/Fu+jut7ztPEmbJX2ml5hm1rO9ImJr/ngbsFebdmOSJiStl3RcvmxP4CcRsT1/vhnYp9XKklbm609MTk72K3czo/dv3kV3vwGsAb7fYzwzK0DSVZJuaXFb2tgusmsCt7su8P75pQmXA5+U9IszySEi1kbEeESML1iwoLuOmFlLs3tcfynwlvzxhcC1wAeaG0l6Ldmn+38AKn3dYbM6iIgj2r0m6QFJCyNiq6SFwINttrElv98k6Vrg1cDfAbtJmp1/+94X2NL3DpjZtHr95t1x95ukFwH/E3h/j7HMrD/WASvyxyuAbzU3kLS7pF3zx/OBNwK35d/UvwecON36ZjZYHYt3H3a/vRe4PCI2F4jlY2Rmg3cOcKSku4Aj8udIGpd0Xt7mIGBC0g/JivU5EXFb/toHgPdJ2kh2DPwLpWZvZp13m/dh99vrgTdJei/wEmAXSY9HxE7HxyNiLbAWYHx8vN1xODPrQUQ8DLytxfIJ4PT88b8Ar2qz/ibg0EHmaGbT6/WY99Tut3Nos/ssIk6eeizpVGC8VeE2MzOzYno95l1k95uZmZn1UU/fvIvsfmtafgFwQS8xzczMRp1nWDMzM0uMi7eZmVliXLzNzMwS4+JtZmaWGBdvMzOzxLh4m5mZJcbF28zMLDEu3mZmZolx8TYzM0uMi7eZmVliXLzNzMwS4+JtZmaWGBdvsxEiaQ9JV0q6K7/fvUWb35C0oeH2lKTj8tcukHRPw2uHlN0HM3PxNhs1ZwJXR8QS4Or8+Q4i4nsRcUhEHAK8FXgC+MeGJn8y9XpEbCghZzNr4uJtNlqWAhfmjy8EjuvQ/kTguxHxxCCTMrOZcfE2Gy17RcTW/PE2YK8O7ZcBX21a9mFJN0n6hKRd+56hmXU0e9gJmFl/SboK2LvFS2c3PomIkBTTbGch8CrgiobFZ5EV/V2AtcAHgNVt1l8JrARYtGjRDHpgZp30VLwl7QFcAiwGfgS8KyIebdFuEXAesB8QwDER8aNeYptZaxFxRLvXJD0gaWFEbM2L84PTbOpdwDci4mcN25761v60pC8C758mj7VkBZ7x8fG2HxLMbOZ63W3e8eSX3EXAxyPiIOBQpv8Pw8wGZx2wIn+8AvjWNG1PommXeV7wkSSy4+W39D9FM+uk1+Ld8eQXSQcDsyPiSoCIeNwnv5gNzTnAkZLuAo7InyNpXNJ5U40kLSbbU/ZPTet/RdLNwM3AfOAvykjazHbU6zHvIie//DLwE0lfBw4ArgLOjIhne4xtZjMUEQ8Db2uxfAI4veH5j4B9WrR76yDzM7NiOhbvPpz8Mht4E/Bq4Mdkx8hPBb7QIpZPcDEzM+ugY/Huw8kvm4ENEbEpX+ebwGG0KN4+wcXMzKyzXo95Fzn55QZgN0kL8udvBW7rMa6ZmdnI6rV4dzz5JT+2/X7g6vxEFwF/02NcMzOzkdXTCWszOPnlSuBXe4llZmZmGU+PamZmlhgXbzMzs8S4eJuZmSXGxdvMzCwxLt5mZmaJcfE2MzNLTNrFe+tWOPxw2LZt2JmY9d8o/X2PUl8bjWK/R7HP0Pd+p12816yB666D1auHnYlZ/43S3/co9bXRKPZ7FPsMfe+3Iqo5hfj4+HhMTEy0fnHOHHjqqZ2Xj43Bk08ONjGzQZvh37ekGyNivITMutZ2PI/qWB7Ffo9in2Fg4znNb96bNsHy5TB3bvZ87lw4+WS4557h5mXWD6P09z1KfW00iv0exT7DwPqdZvFeuBDmzcs+zYyNZffz5sHera5capaYAf99S3qnpFslPSep7Sd8SUdJukPSRklnNiw/QNL1+fJLJO3SdTKjOpZHsd+j2GcYWL/TLN4ADzwAq1bB+vXZ/aid/GD1Nti/71uA3wK+366BpFnAucDRwMHASZIOzl/+KPCJiPgl4FHgtJ6yGdWxPIr9HsU+w0D6neYxbzN7XrfHvCVdC7w/v5BQ82uvBz4UEe/In5+Vv3QOMAnsHRHbm9u14/FsVky9j3mb2aDtA9zX8HxzvmxP4CcRsb1puZmVqKdLgppZNUm6Cmh1UO3siPhWSTmsBFYCLFq0qIyQZiPDxdushiLiiB43sQXYr+H5vvmyh4HdJM3Ov31PLW+Vw1pgLWS7zXvMx8waVLZ433jjjQ9JunfYeTSZDzw07CSGzO9B9d6D/QewzRuAJZIOICvOy4DlERGSvgecCFwMrAA6fpNvMZ6r9h52I/U+pJ4/1LMPhcZzZU9YqyJJE1WfDGPQ/B6k/x5IOh74NLAA+AmwISLeIellwHkRcUze7hjgk8As4PyI+HC+/ECywr0H8O/A70TE0zPMIen3ENLvQ+r5w2j3obLfvM1sMCLiG8A3Wiy/Hzim4fnlwOUt2m0CDh1kjmY2PZ9tbmZmlhgX75lZO+wEKsDvgd+DfqjDe5h6H1LPH0a4Dz7mbWZmlhh/8zYzM0uMi/c0JO0h6UpJd+X3u7dp96ykDfltXdl5DkK7i1I0vL5rflGKjflFKhYPIc2BKvAenCppsuHf/vRh5JmCXi+GUgWp/n9Qh7Gc+liUdL6kByXd0uZ1SfpU3r+bJL2m40Yjwrc2N+BjwJn54zOBj7Zp9/iwc+1zv2cBdwMHArsAPwQObmrzXuBz+eNlwCXDznsI78GpwGeGnWsKN+Ag4OXAtcB4t+/5kPuQ3P8HdRjLdRiLwJuB1wC3tHn9GOC7gIDDgOs7bdPfvKe3FLgwf3whcNzwUinVocDGiNgUEc+Q/aZ3aVObxvfmMuBtklRijoNW5D2wgiLi9oi4o0Ozqr/nKf5/UIexXPW/i44i4vvAI9M0WQpcFJn1ZLMYLpxumy7e09srIrbmj7cBe7VpNyZpQtJ6SceVk9pAtbsoRcs2kU2T+RjZRSvqosh7AHBCvpvrMkn7tXjdiiv6ng9Liv8f1GEsj8JYnPHf/shP0jLdBRwan0RESGp3av7+EbEln3nqGkk3R8Td/c7VKufbwFcj4mlJ7yH79vLWIec0NFW4GEqv/P9BskZuLI588Y5pLuAg6QFJCyNia74L48E229iS32/Kr5H8arJjNKlqd1GKVm02S5oNvJTsohV10fE9iIjG/p5Hdkx0ZE03lgoq8nc3UDX8/6AOY3kUxuKM//a923x668guvABtLsAgaXdJu+aP5wNvBG4rLcPBeP6iFJJ2ITuJpfms2cb35kTgmsjPvKiJju9B0zGpY4HbS8yvjor83Q1Tiv8f1GEsj8JYXAeckp91fhjwWMMhmtaGfRZelW9kx32uBu4CrgL2yJePk13AAeANwM1kZ0DeDJw27Lz71PdjgDvJvjGcnS9bDRybPx4DvgZsBP4VOHDYOQ/hPfgIcGv+b/894FeGnXNVb8DxZMfxngYeAK7Il78MuHy697wqt1T/P6jDWE59LAJfBbYCP8vHwWnAKmBV/rqAc/P+3UybX2Q03jzDmpmZWWK829zMzCwxLt5mZmaJcfE2MzNLjIu3mZlZYly8zczMEuPibWZmlhgXbzMzs8S4eJuZmSXGxdvMzCwxLt41JmmZpNsl/VTS3ZLe1PT6ByWFpI4XlJB0qqSbJT0haZukv5b00jbtQtJvNy1/S778G03Lfy1ffm2X3TSrFUm7SvqCpHsl/aekDZKOzl9bnI+Xxxtu/2/T+kdI+rd83G+W9K4O8XaT9Nl8XD+Rj/MVbdpeK+nRqfnbG5ZfkOe1tGn5J/Llp3b1ZlhbLt41JelI4KPAu4GfB94MbGp4/ReBd5LNt9tpW/9Pvq0/Ibvi0GHAYuAfJb24qfkKsovOn9JiU5PA6yXt2dT+zkKdMhsNs8mu7Xw42Xj7U+BSSYsb2uwWES/Jb2umFko6GPhbskuYvhT4NeDGdoHyC31cBewPvD5f50+Aj0n6w6a2i4E3AUF28Y9md9Iw7vMrlL2LtK+wWFku3vX158DqiFgfEc9FxJbIL1WYOxf4APDMdBuRNC/f1h9ExD9ExM8i4kdkg/JAYHlD2/3J/sNZCbxDUvN1kZ8Bvkl2VSAkzQJ+G/hK1700q5mI+GlEfCgifpSP3e8A9wCvLbD6nwKfj4jvRsT2iHg4pr+W+O8Ci4B3RsQ9+fj+B+APgb+Q9JKGtqcA64ELeOEqZI2+Dfy6pN3z50cBNwHbCuRtM+TiXUN5URwHFkjamO86+4ykOfnr7wSejojLC2zuDWRXHfp648KIeBy4HHh7w+JTgImI+DuyS/Kd3GJ7F/HCp/N3ALcA9xfunNmIkbQX8MtkV82acm8+rr+YX3p0ymH5OjdL2irpy5L2mGbzRwLfjYifNi3/O2Au2bfxKaeQfdD+CtmH872a1nmK7DKpyxraX9S5h9YNF+962gt4Mdm1ed8EHAK8GvhTST8P/CXwRwW3NR94KCK2t3htK7Cg4fkpZLvsyO932nUeEf8C7CHp5Xhwm00rPyz1FeDCiPgP4CHgv5Dt5n4t2SGxxj1X+5J9mz4BWALMAT49TYj5tDh0lo/3h8jHt6Rfz2NeGhE3ku0KX968HvmHc0m7ke2F+2axntpMuXjX05P5/acjYmtEPAT8L7Jr4n4I+FK+63sHkt7UcBLM1Kf8h4D5+fGrZgvz15H0RuAA4OL8tb8FXiXpkBbrfQk4A/gN4BstXjcbeZJeRDZWniEbL0TE4xExke8SfyBf/vb8QzlkY/+LEXFnvnfsL8nGPZI+1zC+/0fe/iGycdwcezb5B/d80QrgH/P/SyAb3zvtOo+I68gK/tnAdyLiyeY21h+t/kO2xEXEo5I2k51Y8vzi/P5twL6S3ps/X0B2MsxHI+KjQOMxLoAfAE8DvwVcOrUwPxZ2NNkxNsgGsoANkhrXXwFsaNrml4CNwEUR8URTe7ORp2xQfIFsL9oxEfGzNk2nxvXUF7GbaD3uiYhVwKqm9a8C/lLSzzXtOj+B7EPD9fnhtncBsyRNHb/eFdhN0q9FxA+btvll4INkH85tQPzNu76+CPyBpF/ITyD5Y+A7ZMX7lWS70g8hO978HrIT2HYSEY+RnbD2aUlHSXpxftbppWSfyr8iaYxscK9s2O4hwB8Ay5u/tUfEPWS71M7uV2fNauazwEHAf2389irpdZJeLulF+a82PgVcm49TyMb9uyUdKGkucCbZuG/nS8Bm4Gv5z9BeLOkd+XY/nm/3OOBZ4GBeGNsHAf9M61+VfIrsWPr3u+q5FeJv3vW1hmy3151kJ5JcCnw4Ip5qbCTpWeDRfBdbSxHxMUkPA/8f8Etkn7r/CTgiIn4qaRnZ7rqLGr8hSDofWE121unjTdu8rvcumtVP/quN95Dt8drWsGfqPcBzZLvCfwH4/4ErgZOmGkTE+fn61+eLps4cbykinlY2z8NH8nX2BGYB/4Ps56GQ7T37YkT8uCnPzwCfkvSBpm0+Alw9s17bTCkiOrcyayDp3WRF+Y3NA9rM0pWfIPddYAtwarhAVJZ3m9uMRcQXyT6Zv2HYuZhZ/+R7zk4gO5v85UNOx6bhb95mZmaJ8TdvMzOzxLh4m5mZJaayZ5vPnz8/Fi9ePOw0zCrvxhtvfCgiFnRuOTwez2bFFB3PlS3eixcvZmJiYthpmFWepHuHnUMnHs9mxRQdz95tbmZmlhgXbzMzs8SkXby3boXDD4dtA75cbN3ilBmrbnHKjFVmn4Ztpn3t5r0ZdAznVI32dcmpk4io5O21r31tdPR7vxfxohdl94NUtzhlxqpbnDJjFYxDdg31oY/Z6W4dx/NM39Nu/g0GHcM5VaN94jkVHc+VnaRlfHw82p7gMmcOPPXUzsvHxuDJPl6Brm5xyoxVtzhlxpphHEk3RsR4/xLov7bjeabvaTf/BoOO4Zyq0b4mORUdz2nuNt+0CZYvh7lzs+dz58LJJ8M99zhOVWLVLU6Zscrs07DNtK/dvDeDjuGcqtG+LjkVlGbxXrgQ5s3LPs2MjWX38+bB3ns7TlVi1S1OmbHK7NOwzbSv3bw3g47hnKrRvi45FZRm8QZ44AFYtQrWr8/uB3VST93ilBmrbnHKjFVmn4Ztpn3t5r0ZdAznVI32dcmpgL4c886v2/ybwIMR8coWrwv4K+AY4AmyS83923TbnPaYt5k9L+lj3ma2g7KPeV8AHDXN60cDS/LbSuCzfYprZmY2cvpSvCPi+8Aj0zRZClyUnwm/HthN0sJ+xDYzMxs1ZR3z3ge4r+H55nyZmZmZzVClTliTtFLShKSJycnJYadjZmZWSWUV7y3Afg3P982X7SAi1kbEeESML1hQ6SscmtWSpPMlPSjpljavS9KnJG2UdJOk15Sdo5mVV7zXAafkA/8w4LGI2FpSbDMr7gKGcfJpFeeWdk5ptq9LTp0UmUO10w34KrAV+BnZ8ezTgFXAqvx1AecCdwM3A+OdtllobnMz6/vc5sBi4JY2r30eOKnh+R3Awk7b9Nzmzqm09onnVHQ8pzm3uZk9r9+/85a0GPhOtJ6z4TvAORFxXf78auADETHtYPXc5s5pJPvQxTr1ntvczCqv0AmoVZxb2jlVI6c69KHbdQpw8TazmSh08ikUPAG1inNLO6dq5FSHPnS7TgEu3mY2E/0/+bSKc0s7p2rkVIc+dLtOBz7mbZa4fh7zlvRV4C3AfOAB4M+AFwNExOfy6xR8huyM9CeAd3c63g0ez2ZFFR3Ps8tIxszSEBEndXg9gN8vKR0za8O7zc3MzBLj4m1mZpYYF28zM7PEuHibmZklxsXbzIavinNLO6c029clp06KzKE6jJvnNjcrhj7PbT6Im+c2d06ltU88p6LjeeiDut2tUPG+//6IN785YuvWzm17Ubc4ZcaqW5wyYxWMk3TxHhvL/htqvo2N9ad9GTGcUzXa1ySn0Sje3Xz66Ubd4pQZq25xyozV50/qw7y1Hc/33x+xfHnE3LnZf0dz50acfHL7DywzbV9GDOdUjfY1yanoeE7zmPecOSDBZz8Lzz2X3UvZcsepRqy6xSkzVpl9GrYqzi3tnKqRUx360O06BaRZvAd0lZbaxykzVt3ilBmrzD5VQRXnlnZO1cipDn3odp1Oinw9H8at427zVauyXYpjY4PdhVm3OGXGqlucMmPNIA4p7zY3sx0UHc9pfvOGwXySGYU4ZcaqW5wyY5XZJzNLjq8qZpa4fl5VbFA8ns2KKTqe0/3mbWZmNqJcvM3MzBLj4m1mZpYYF28zM7PEuHib2fBV8cIQzinN9nXJqZMivycbxs2/CzUrhjr8zrtCF4ZwThXLqQ59mME6Rcezfypmlrikfyo2Z042XWSzsTF48sne25cRwzlVo31NcvJPxcys+mY6FWw3U8cOOoZzqkb7uuRUkIu3mQ1PFS8M4ZyqkVMd+tDtOgW4eJvZcFXxwhDOqRo51aEP3a7TgY95myUu6WPeZrYDH/M2MzOrKRdvMzOzxLh4m5mZJcbF28zMLDEu3mZmZonpS/GWdJSkOyRtlHRmi9dPlTQpaUN+O70fcc2sJqo4t7RzSrN9XXLqpMgcqtPdgFnA3cCBwC7AD4GDm9qcCnxmJtv13OZmxeC5zQezjnNKs33iORUdzz3/zlvS64EPRcQ78udn5R8KPtLQ5lRgPCLOKLpd/y7UrJh+/85b0lHAX5F9MD8vIs5pev1U4OPAlnzRZyLivOm26bnNndNI9qGLdcr8nfc+wH0Nzzfny5qdIOkmSZdJ2q/VhiStlDQhaWJycrJz5H7vhhiVOGXGqlucMmOV2aecpFnAucDRwMHASZIObtH0kog4JL9NW7inVcW5pZ1TNXKqQx+6XaeAsk5Y+zawOCJ+FbgSuLBVo4hYGxHjETG+YMGCzltdswauuw5Wr+5rsrWPU2asusUpM1aZfXrBocDGiNgUEc8AFwNLBxatinNLO6dq5FSHPnS7TgH9KN5bgMZv0vvywu40ACLi4Yh4On96HvDaniLOmQMSfPaz8Nxz2b2ULe+nusUpM1bd4pQZq8w+7axve9IKq+Lc0s6pGjnVoQ/drtNJkQPj092A2cAm4ABeOGHtFU1tFjY8Ph5Y32m7057gcv/9EcuXR8ydGwHZ/cknR2zdOu2JADNWtzhlxqpbnDJjzTAOfTxhDTiR7Dj31PPfpelkU2BPYNf88XuAa9psayUwAUwsWrSov++RWU0VHc89f/OOiO3AGcAVwO3ApRFxq6TVko7Nm/2hpFsl/RD4Q7Kzz7s3oN0QtY9TZqy6xSkzVpl92lnf9qTFTA+DmVlhfTnmHRGXR8QvR8QvRsSH82UfjIh1+eOzIuIVEfFrEfEbEfEfPQcdxG6IUYhTZqy6xSkzVpl92tENwBJJB0jaBVgGrGtsIGlhw9NjyT60m1mJfElQs8QN4KdixwCfJPup2PkR8WFJq8l2562T9BGyor0deAT4vU4fyD2ezYopOp5nl5GMmaUjIi4HLm9a9sGGx2cBZ5Wdl5m9wHObm5mZJcbF28yGr4pzSzunNNvXJadOipySPoyb5zY3KwbPbT6YdZxTmu0Tz6noePYJa2aJ6/cJa4Pguc2d00j2oYt1ypzb3MysO1WcW9o5VSOnOvSh23UKcPE2s+Gp4tzSzqkaOdWhD92uU4CLt5kNVxXnlnZO1cipDn3odp0OfMzbLHFJH/M2sx34mLeZmVlNuXibmZklxsXbzMwsMS7eZmZmiXHxNjMzS4yLt5mZWWJcvM1s+Kp4YQjnlGb7uuTUSZEJ0Idx84VJzIrBFyYZzDrOKc32iedUdDx7khazxCU9SUsFLwzhnCqSUx360MU6nqTFzKqviheGcE7VyKkOfeh2nQJcvM1seKp4YQjnVI2c6tCHbtcpIO3i3e8TAEYlTpmx6hanzFhl9mmYqnhhCOdUjZzq0Idu1+mkyIHxYdwKnbDWzUkD3ahbnDJj1S1OmbH6fILLMG8+AdWsmKLjOc0T1ro5aaAbdYtTZqy6xSkz1oBOcBkmn4BqVky9T1gb0AkAtY9TZqy6xSkzVpl9MrMkpVm8B3QCQO3jlBmrbnHKjFVmn8wsSWkWbxjMCQCjEKfMWHWLU2asMvtkZslJ85i3mT3Px7zN6qPex7zNrF6qOLe0c0qzfV1y6qTIKenDuPmnJWbFUIefilVobmnnVLGc6tCHGaxTdDx7t7lZ4pLebV7BuaWdU0VyqkMfuljHu83NrPqqOLe0c6pGTnXoQ7frFODibWbDU8W5pZ1TNXKqQx+6XaeAvhRvSUdJukPSRklntnh9V0mX5K9fL2lxP+KaWf+VPp6rOLe0c6pGTnXoQ7frdNDzMW9Js4A7gSOBzcANwEkRcVtDm/cCvxoRqyQtA46PiN+ebrs+5m1WTD+PeXs8mw1Xmce8DwU2RsSmiHgGuBhY2tRmKXBh/vgy4G2S1IfYZtZfHs9mCehH8d4HuK/h+eZ8Wcs2EbEdeAzYsw+xzay/PJ7NElCpE9YkrZQ0IWlicnJy2OmYWQ88ns0Gpx/FewuwX8PzffNlLdtImg28FHi4eUMRsTYixiNifMGCBX1IzcxmyOPZLAH9KN43AEskHSBpF2AZsK6pzTpgRf74ROCaqOrsMGajzePZLAE9F+/8mNcZwBXA7cClEXGrpNWSjs2bfQHYU9JG4H3ATj8/MbPhG9p4ruLc0s4pzfZ1yamTInOoDuPmuc3NisFzmw9mHeeUZvvEcyo6nj23uVniPLf5NO3LiOGcqtG+Jjl5bnMzq74qzi3tnKqRUx360O06Bbh4m9nwVHFuaedUjZzq0Idu1ynAxdvMhquKc0s7p2rkVIc+dLtOBz7mbZa4pI95m9kORuOYd79PvR+VOGXGqlucMmOV2SczS0raxXvNGrjuOli92nGqGqtuccqMVWafzCwpae427+Z0/W7ULU6ZseoWp8xYA/ppyTB5t7lZMfXebT6gU+9rH6fMWHWLU2asMvtkZklKs3gP6NT72scpM1bd4pQZq8w+mVmS0izeMJBT70ciTpmx6hanzFhl9qkKqji3tHNKs31dcuqkyByqw7h5bnOzYvDc5oNZxzml2T7xnIqO5zRPWDOz5yV9wloF55Z2ThXJqQ596GKdep+wZmb1UMW5pZ1TNXKqQx+6XacAF28zG54qzi3tnKqRUx360O06Bbh4m9lwVXFuaedUjZzq0Idu1+nAx7zNEpf0MW8z24GPeZuZmdWUi7eZmVliXLzNzMwS4+JtZmaWGBdvMzOzxLh4m5mZJcbF28yGr4oXhnBOabavS06dFJkAfRg3X5jErBh8YZLBrOOc0myfeE5Fx7MnaTFLXNKTtFTwwhDOqSI51aEPXazjSVrMrPqqeGEI51SNnOrQh27XKcDF28yGp4oXhnBO1cipDn3odp0CXLzNbLiqeGEI51SNnOrQh27X6cDHvM0Sl/QxbzPbgY95m5mZ1VTaxbvfv5sblThlxqpbnDJjldknQNIekq6UdFd+v3ubds9K2pDf1pWSnJntIO3ivWYNXHcdrF7tOFWNVbc4ZcYqs0+ZM4GrI2IJcHX+vJUnI+KQ/HZsWcmZ2QvSPObdzW/tulG3OGXGqlucMmMN6HehnUi6A3hLRGyVtBC4NiJe3qLd4xHxkpls28e8zYop5Zj30HazDeh3c7WPU2asusUpM1aZfdrRXhGxNX+8DdirTbsxSROS1ks6btBJmdnOet1tPpzdbAP63Vzt45QZq25xyow1wDiSrpJ0S4vb0sZ2+TSN7XbL7Z9/M1gOfFLSL7aJtTIv8hOTk5PTJ1bFuaWdU5rt65JTJ0XmUG13A+4AFuaPFwJ3tGn3+Ey33XEu5OOPj3jveyM2bMjujz9++vbdqlucMmPVLU6ZsWYQhz7NbV50PDetcwFwYqd2ntvcOZXWPvGcio7nno55S/pJROyWPxbw6NTzpnbbgQ3AduCciPhmp237GJlZMX085v1x4OGIOEfSmcAeEfHfm9rsDjwREU9Lmg/8AFgaEbdNt23Pbe6cRrIPXazTt2Peld3NZmb9dg5wpKS7gCPy50gal3Re3uYgYELSD4HvkX0Yn7ZwT6uKc0s7p2rkVIc+dLtOAbM7NYiII9q9JukBSQvjhbNTH2yzjS35/SZJ1wKvBu5u0W4tsBayT+qFemBmfRERDwNva7F8Ajg9f/wvwKv6FrSKc0s7p2rkVIc+dLtOAb2esLYOWJE/XgF8q7mBpN0l7Zo/ng+8Eej+k7qZ1UsV55Z2TtXIqQ596HadDno95r0ncCmwCLgXeFdEPCJpHFgVEadLegPweeA5sg8Ln4yIL3Tato95mxXjuc3N6qPoeO6423w6Q9nNZmZmNuLSnh7VzMxsBLl4m5mZJcbF28zMLDEu3mZmZolx8Taz4avi3NLOKc32dcmpkyJzqA7j1nEuZDOLiP7NbT7Im+c2d06ltU88p6LjOc3reZvZ85L+nXcF55Z2ThXJqQ596GKdUq7nbWbWkyrOLe2cqpFTHfrQ7ToFuHib2fBUcW5p51SNnOrQh27XKcDF28yGq4pzSzunauRUhz50u04HPuZtlrikj3mb2Q58zNvMzKymXLzNzMwS4+JtZmaWGBdvMzOzxKRdvPs93dyoxCkzVt3ilBmrzD6ZWVLSLt5r1sB118Hq1Y5T1Vh1i1NmrDL7ZGZpKTKH6jBu086FPDYWATvfxsamnTN2xuoWp8xYdYtTZqwZxqEOc5vff3/Em98csXVrsfdopu3LiOGcqtE+8ZyKjuehD+p2t2kH+/33RyxfHjF3btaFuXMjTj55Zm9kEXWLU2asusUpM9YM49SieFfowhDOqWI51aEPM1in3sU7ImLVquyNGBub+Zs4E3WLU2asusUpM9YM4iRdvGe6N6ObvR+DjuGcqtG+JjkVHc/pHvMewHRzIxGnzFh1i1NmrDL7NExVvDCEc6pGTnXoQ7frFDC7p7WH6etff+Hxuec6ThVj1S1OmbHK7NMwVfHCEM6pGjnVoQ/drlNAut+8zaweqnhhCOdUjZzq0Idu1+nAFyYxS5wvTGJWH74wiZmZWU25eJuZmSXGxdvMzCwxLt5mZmaJcfE2MwAkvVPSrZKek9T2hBlJR0m6Q9JGSWeWmaOZZVy8zWzKLcBvAd9v10DSLOBc4GjgYOAkSQf3HHmmV1Dr5oprg47hnKrRvi45dVJkGrZh3DpOj2pmEVF8OsWiN+BaYLzNa68Hrmh4fhZwVqdtem5z51Ra+8RzKjqe/Ttvs8T1+3fekq4F3h8ROw1ASScCR0XE6fnz3wVeFxFnTLfNtuN5zpxsxqlmY2Pw5JO9ty8jhnOqRvua5OTfeZvZTiRdJemWFrelA4i1UtKEpInJycnWjao4t7RzqkZOdehDt+sUkO7c5mY2YxFxRI+b2ALs1/B833xZq1hrgbWQffNuubUqzi3tnKqRUx360O06BfT0zdtnp5qNnBuAJZIOkLQLsAxY19MWqzi3tHOqRk516EO363TQ0zFvSQcBzwGfp/0xslnAncCRwGaywX9SRNw23bZ9zNusmH4d85Z0PPBpYAHwE2BDRLxD0suA8yLimLzdMcAngVnA+RHx4U7b9ng2K6boeO5pt3lE3J4Hm67ZocDGiNiUt70YWApMW7zNrFwR8Q3gGy2W3w8c0/D8cuDyElMzsyZlnLC2D3Bfw/PN+bKdFDrBxczMbMR1/OYt6Sqg1ZH1syPiW/1MptAJLmZmZiOuY/Eu8+xUMzMz66yM3eb9PzvVzMxshPX6U7HjJW0mmzLx7yVdkS9/maTLASJiO3AGcAVwO3BpRNzaW9q5fs8VOypxyoxVtzhlxiqzT8NWxbmlnVOa7euSUydF5lAdxq3Q3ObdzC/bjbrFKTNW3eKUGavPcyEP8+a5zZ1Tae0Tz6noeE5zbvNu5pftRt3ilBmrbnHKjDWguZCHyXObO6eR7EMX69R7bvMBzRVb+zhlxqpbnDJjldmnYavi3NLOqRo51aEP3a5TQJrFe0BzxdY+Tpmx6hanzFhl9mnYqji3tHOqRk516EO36xSQZvGGgcwVOxJxyoxVtzhlxiqzT8NWxbmlnVM1cqpDH7pdp4M0j3mb2fOSPuZtZjuo9zFvMzOzEebibWZmlhgXbzMzs8RU9pi3pEng3h43Mx94qA/pDFoqeYJzHYRe89w/Ihb0K5lB6NN4blb1f1/n15uq5weDybHQeK5s8e4HSRNVP5EH0skTnOsgpJJn1VT9fXN+val6fjDcHL3b3MzMLDEu3mZmZompe/FeO+wECkolT3Cug5BKnlVT9ffN+fWm6vnBEHOs9TFvMzOzOqr7N28zM7PaqU3xlvROSbdKek5S27P/JB0l6Q5JGyWdWWaODTnsIelKSXfl97u3afespA35bV3JOU77PknaVdIl+evXS1pcZn4NeXTK81RJkw3v4+lDyvN8SQ9KuqXN65L0qbwfN0l6Tdk5Vl3Vx3hVx3XVx3LVx3Blx26Ri36ncAMOAl4OXAuMt2kzC7gbOBDYBfghcPAQcv0YcGb++Ezgo23aPT6k97Lj+wS8F/hc/ngZcElF8zwV+Mww3semPN4MvAa4pc3rxwDfBQQcBlw/7Jyrdqv6GK/iuK76WE5hDFd17Nbmm3dE3B4Rd3RodiiwMSI2RcQzwMXA0sFnt5OlwIX54wuB44aQw3SKvE+NfbgMeJsklZgjVOffs6OI+D7wyDRNlgIXRWY9sJukheVkl4YExngVx3XVx3Llx3BVx25tindB+wD3NTzfnC8r214RsTV/vA3Yq027MUkTktZLOq6c1IBi79PzbSJiO/AYsGcp2bXIIdfu3/OEfHfWZZL2Kye1GavK32bqhvk+VnFcV30s12EMD+VvbvagA/STpKuAVlcwPzsivlV2PtOZLtfGJxERktqd8r9/RGyRdCBwjaSbI+Lufudac98GvhoRT0t6D9k3jLcOOSdro+pj3ON6KDyGW0iqeEfEET1uYgvQ+Klt33xZ302Xq6QHJC2MiK357pUH22xjS36/SdK1wKvJjg8NWpH3aarNZkmzgZcCD5eQW6scpuyUZ0Q05nQe2XHJKirtb7PKqj7GExzXVR/LdRjDQxm7o7bb/AZgiaQDJO1CdnJGqWdx59YBK/LHK4CdvlFI2l3Srvnj+cAbgdtKyq/I+9TYhxOBayI/e6NEHfNsOvZ0LHB7ifnNxDrglPzM1cOAxxp2wVpxwxzjVRzXVR/LdRjDwxm7wzqDr9834HiyYw1PAw8AV+TLXwZc3tDuGOBOsk+6Zw8p1z2Bq4G7gKuAPfLl48B5+eM3ADeTnX15M3BayTnu9D4Bq4Fj88djwNeAjcC/AgcO6b3slOdHgFvz9/F7wK8MKc+vAluBn+V/p6cBq4BV+esCzs37cTNtzqYe5VvVx3hVx3XVx3LVx3BVx65nWDMzM0vMqO02NzMzS56Lt5mZWWJcvM3MzBLj4m1mZpYYF28zM7PEuHibmZklxsXbzMwsMS7eZmZmifk/H80MOEvxW7QAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bpsk = BPSK()\n",
    "qam4 = QAM(4)\n",
    "qam16 = QAM(16)\n",
    "qam64 = QAM(64)\n",
    "qam256 = QAM(256)\n",
    "\n",
    "fig_bpsk, ax_bpsk = plt.subplots(figsize=(4, 4))\n",
    "ax_bpsk.set_title(\"BPSK\")\n",
    "ax_bpsk.plot(bpsk.symbols.real, bpsk.symbols.imag, \"*r\", label=\"4-QAM\")\n",
    "ax_bpsk.axis(\"equal\")\n",
    "\n",
    "fig, [[ax11, ax12], [ax21, ax22]] = plt.subplots(figsize=(8, 8),\n",
    "                                                 nrows=2,\n",
    "                                                 ncols=2)\n",
    "\n",
    "ax11.set_title(\"4-QAM\")\n",
    "ax11.plot(qam4.symbols.real, qam4.symbols.imag, \"*r\", label=\"4-QAM\")\n",
    "ax11.axis(\"equal\")\n",
    "\n",
    "ax12.set_title(\"16-QAM\")\n",
    "ax12.plot(qam16.symbols.real, qam16.symbols.imag, \"*r\", label=\"16-QPSK\")\n",
    "ax12.axis(\"equal\")\n",
    "\n",
    "ax21.set_title(\"64-QAM\")\n",
    "ax21.plot(qam64.symbols.real, qam64.symbols.imag, \"*r\", label=\"64-QAM\")\n",
    "ax21.axis(\"equal\")\n",
    "\n",
    "ax22.set_title(\"256-QAM\")\n",
    "ax22.plot(qam256.symbols.real, qam256.symbols.imag, \"*r\", label=\"256-QAM\")\n",
    "ax22.axis(\"equal\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implement a simulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we will use the `run_in_parallel` method to run the simulation, which **requires our simulator to be importable** (the reason is that it needs to work with pickle, which is not possible if the class is define interactively in the notebook). For that, we add the code in the cell below and used the `%%writefile` cell magic to save the content of the cell to a file. The cell content is **NOT executed**. After that, we can import from the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting rayleigh_qam_simulator.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile rayleigh_qam_simulator.py\n",
    "\n",
    "import math\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from pyphysim.modulators.fundamental import BPSK, QAM, Modulator\n",
    "from pyphysim.simulations import Result, SimulationResults, SimulationRunner\n",
    "from pyphysim.util.conversion import dB2Linear\n",
    "from pyphysim.util.misc import randn_c, count_bit_errors\n",
    "\n",
    "\n",
    "class RayleighOrAwgnSimulator(SimulationRunner):\n",
    "\n",
    "    def __init__(self, SINR_dB_values, simulate_with_rayleigh=False):\n",
    "        # If simulate_with_rayleigh is false only AWGN is used\n",
    "        super().__init__()\n",
    "\n",
    "        self._simulate_with_rayleigh = simulate_with_rayleigh\n",
    "\n",
    "        # Add the simulation parameters to the `params` attribute.\n",
    "        self.params.add('EbN0_db', SINR_dB_values)\n",
    "        self.params.set_unpack_parameter('EbN0_db')\n",
    "\n",
    "        # Note that when M=2 BPSK modulation will be used, while other values will use QAM\n",
    "        self.params.add(\"M\", [2, 4, 16, 64, 256])\n",
    "        self.params.set_unpack_parameter('M')\n",
    "\n",
    "        # Number of times the `_run_simulation` method will run when `simulate` method is called.\n",
    "        # We are using a value 100 times larger than before, but the simulation will not take\n",
    "        # 100 times the previous elapsed time to finish thanks to the implementation of the\n",
    "        # `_keep_going` method that will allow us to skip many of these iterations for low EbN0 values\n",
    "        self.rep_max = 50000\n",
    "\n",
    "        # Number of symbols generated for this realization\n",
    "        self.num_symbols = 1000\n",
    "\n",
    "        # Used in the implementation of `_keep_going` method. This is the maximum numbers of symbol\n",
    "        # errors we allow before `_run_simulation` is stoped for a given configuration\n",
    "        self.max_symbol_errors = 1. / 300. * self.num_symbols * self.rep_max\n",
    "\n",
    "        # Set a nice message for the progressbar\n",
    "        self.progressbar_message = f\"Simulating for {self.params.get_num_unpacked_variations()} configurations\"\n",
    "\n",
    "        self.update_progress_function_style = \"text1\"  # \"ipython\"\n",
    "\n",
    "    def _keep_going(self, current_params, current_sim_results, current_rep):\n",
    "        # Note that we have added a \"symbol_errors\" result in `_run_simulation` to use here\n",
    "\n",
    "        # Get the last value in the \"symbol_errors\" results list, which corresponds to the current configuration\n",
    "        cumulated_symbol_errors \\\n",
    "            = current_sim_results['symbol_errors'][-1].get_result()\n",
    "        return cumulated_symbol_errors < self.max_symbol_errors\n",
    "\n",
    "    def _run_simulation(self, current_parameters):\n",
    "        # Since EbN0_db is an \"unpacked parameter\" a single value is passed to `_run_simulation`.\n",
    "        # We can get the current value as below\n",
    "        sinr_dB = current_parameters['EbN0_db']\n",
    "        M = current_parameters['M']\n",
    "\n",
    "        modulator = BPSK() if M == 2 else QAM(M)\n",
    "\n",
    "        # Find the noise power from the EbN0 value (in dB)\n",
    "        EbN0_linear = dB2Linear(sinr_dB)\n",
    "        snr_linear = EbN0_linear * math.log2(M)\n",
    "        noise_power = 1 / snr_linear\n",
    "\n",
    "        # Generate random transmit data and modulate it\n",
    "        data = np.random.randint(0, modulator.M, size=self.num_symbols)\n",
    "        modulated_data = modulator.modulate(data)\n",
    "\n",
    "        # Noise vector\n",
    "        n = math.sqrt(noise_power) * randn_c(self.num_symbols)\n",
    "\n",
    "        if self._simulate_with_rayleigh:\n",
    "            # Rayleigh channel\n",
    "            h = randn_c(modulated_data.size)\n",
    "\n",
    "            # Receive the corrupted data\n",
    "            received_data = h * modulated_data + n\n",
    "\n",
    "            # Equalization\n",
    "            received_data /= h\n",
    "\n",
    "        else:\n",
    "            # Receive the corrupted data\n",
    "            received_data = modulated_data + n\n",
    "\n",
    "        # Demodulate the received data and compute the number of symbol errors\n",
    "        demodulated_data = modulator.demodulate(received_data)\n",
    "        symbol_errors = sum(demodulated_data != data)\n",
    "\n",
    "        num_bit_errors = count_bit_errors(data, demodulated_data)\n",
    "\n",
    "        # Create a SimulationResults object and save the symbol error rate.\n",
    "        # Note that the symbol error rate is given by the number of symbol errors divided by the number of\n",
    "        # transmited symbols. We want to combine the symbol error rate for the many calls of `_run_simulation`.\n",
    "        # Thus, we choose `Result.RATIOTYPE` as the \"update_type\". See the documentation of the `Result` class\n",
    "        # for more about it.\n",
    "        simResults = SimulationResults()\n",
    "        simResults.add_new_result(\"symbol_error_rate\",\n",
    "                                  Result.RATIOTYPE,\n",
    "                                  value=symbol_errors,\n",
    "                                  total=self.num_symbols)\n",
    "        simResults.add_new_result(\"symbol_errors\",\n",
    "                                  Result.SUMTYPE,\n",
    "                                  value=symbol_errors)\n",
    "        simResults.add_new_result(\"num_bit_errors\",\n",
    "                                  Result.SUMTYPE,\n",
    "                                  value=num_bit_errors)\n",
    "        simResults.add_new_result(\"bit_error_rate\",\n",
    "                                  Result.RATIOTYPE,\n",
    "                                  value=num_bit_errors,\n",
    "                                  total=int(np.log2(modulator.M)) * data.size)\n",
    "        return simResults"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the simulation\n",
    "\n",
    "Now we import the simulator with the line below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from rayleigh_qam_simulator import RayleighOrAwgnSimulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The parallel computation os powered by the `ipyparallel` library. Before you can run the simulation in parallel you must start the ipython cluster and engines. This can be done by running the `ipcluster start` command in a separated terminal.\n",
    "\n",
    "After that, in our python code we can import from the `ipyparallel` library and create a `Client`. From the client we get a \"view\" of the engines that can be used to run code in parallel. This view is passed to the `simulate_in_parallel` method of our simulator.\n",
    "\n",
    "The code below illustrates how to create a client and how to get a view. Note that each engine corresponds to a different python process (possible running in a different machine) and the working directory in the engines is where the cluster was started and not necessarelly our working directory. Assuming you started the engines in a shell with the virtual environment with pyphysim installed everything in pyphysim should be importable in the engines. However, code in the same folder of this notebook might not be importable in the engines. To solve that we add the current directory of this notebook in each engine's path."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipyparallel import Client\n",
    "import sys\n",
    "import os\n",
    "\n",
    "c = Client()\n",
    "# Get a \"direct view\" -> we will use it to run some code in all engines before we start the simulation\n",
    "# Partucularly, we want to clear the engine's workspace and to append the current working directory to each engine's path\n",
    "dview = c.direct_view()  # Get a view of all engines in the cluster\n",
    "# This will execute the command in ALL engines\n",
    "dview.execute('%reset')\n",
    "dview.execute('import sys')\n",
    "dview.execute('sys.path.append(\"{0}\")'.format(os.getcwd()), block=True)\n",
    "\n",
    "# Get a load balanced view, which is the one we will pass to the `simulate_in_parallel` method.\n",
    "lview = c.load_balanced_view()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can run the simulation. Let's create an `RayleighSimulator` and call the `simulate_in_parallel` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Simulation parameters: {'EbN0_db*': [-5.  0.  5. 10. 15. 20. 25. 30.], 'M*': [2, 4, 16, 64, 256]}\n",
      "-------- Simulating for 40 configurations -------1\n",
      "    1    2    3    4    5    6    7    8    9    0\n",
      "----0----0----0----0----0----0----0----0----0----0\n",
      "**************************************************\n",
      "0.64s\n"
     ]
    }
   ],
   "source": [
    "EbN0_db_rayleigh = np.linspace(-5, 30, 8)\n",
    "\n",
    "runner_rayleigh = RayleighOrAwgnSimulator(EbN0_db_rayleigh,\n",
    "                                          simulate_with_rayleigh=True)\n",
    "runner_rayleigh.set_results_filename(\"qam_rayleigh\")\n",
    "print(\"Simulation parameters:\", runner_rayleigh.params)\n",
    "\n",
    "runner_rayleigh.simulate_in_parallel(lview)\n",
    "# runner_rayleigh.simulate()\n",
    "print(runner_rayleigh.elapsed_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's simulate transmission in an AWGN channel. However, this time we will not pass an ipyparallel view. If a view is not passed, then one will be created inside the `simulate_in_parallel` method for us like the one we have previously defined. Usually that is enough, but it is useful to know how to pass a view manually as before if, for instance, you want to use a different profile (we have not specified one when we created the client and the default profile was used) or when you want a view that does not include all started engines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Simulation parameters: {'EbN0_db*': [-5.  0.  5. 10. 15. 20. 25. 30.], 'M*': [2, 4, 16, 64, 256]}\n",
      "-------- Simulating for 40 configurations -------1\n",
      "    1    2    3    4    5    6    7    8    9    0\n",
      "----0----0----0----0----0----0----0----0----0----0\n",
      "**************************************************\n",
      "3m:08s\n"
     ]
    }
   ],
   "source": [
    "EbN0_db_awgn = np.linspace(-5, 30, 8)\n",
    "\n",
    "runner_awgn = RayleighOrAwgnSimulator(EbN0_db_awgn,\n",
    "                                      simulate_with_rayleigh=False)\n",
    "runner_awgn.set_results_filename(\"qam_awgn\")\n",
    "print(\"Simulation parameters:\", runner_awgn.params)\n",
    "\n",
    "runner_awgn.simulate_in_parallel()\n",
    "# runner_awgn.simulate()\n",
    "print(runner_awgn.elapsed_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you run this notebook you might notice that the `simulate_in_parallel` method of the `runner_rayleigh` runner blocks and only when it finishes is that the `simulate_in_parallel` method of the `runner_awgn` runner in the subsequent cell can start. That means that at some point when only a few (or only one) variations of the parameters for `runner_rayleigh` runner are missing not all processors in your computer will be used.\n",
    "\n",
    "When you want to simulate in parallel using multiple runners as in this notebook, you might want to pass the optional `wait` argument as `False`. In that case, you need to manually call the `wait_parallel_simulation` method of both simulators at some point."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the results\n",
    "\n",
    "To get the obtained results we can use the `runner.results.get_result_values_list` as before. However, since we have two parameters that were unpacked we will get the results of all possible combinations. We likely want to specify which subset we want. This can be done by passing the `fixed_params` argument to the `get_result_values_list` with a dictionary indicating the fixed values as below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symbol Errors Rayleigh Channel (BPSK):\n",
      " [0.25555283307810106, 0.1468345070422535, 0.06420916795069337, 0.02325687177340589, 0.007729085512891857, 0.0024845, 0.00079406, 0.0002528]\n",
      "Symbol Errors Rayleigh Channel (4-QAM):\n",
      " [0.43257512953367877, 0.2581424148606811, 0.1148457300275482, 0.04214664981036662, 0.014026171842127408, 0.004512250588840458, 0.00143248, 0.00045808]\n",
      "Symbol Errors Rayleigh Channel (16-QAM):\n",
      " [0.7352819383259912, 0.5483421052631579, 0.31333646616541355, 0.13420370370370371, 0.048150779896013865, 0.01577465455233769, 0.005083696812566723, 0.00161378]\n",
      "Symbol Errors Rayleigh Channel (64-QAM):\n",
      " [0.8976774193548387, 0.7916682464454976, 0.5858035087719298, 0.3270882352941176, 0.13800579470198676, 0.048673576642335764, 0.016055485984009247, 0.005121120875069133]\n",
      "Symbol Errors Rayleigh Channel (256-QAM):\n",
      " [0.965393063583815, 0.9222872928176795, 0.8144829268292683, 0.6024368231046932, 0.3362560483870968, 0.14060286677908937, 0.04953937592867756, 0.016284416218856863]\n",
      "Symbol Errors AWGN Channel (BPSK):\n",
      " [0.3816704805491991, 0.15129854809437387, 0.011826722486340736, 7.4e-06, 0.0, 0.0, 0.0, 0.0]\n",
      "Symbol Errors AWGN Channel (4-QAM):\n",
      " [0.3816704805491991, 0.15129854809437387, 0.011826722486340736, 7.4e-06, 0.0, 0.0, 0.0, 0.0]\n",
      "Symbol Errors AWGN Channel (16-QAM):\n",
      " [0.7111702127659575, 0.47969540229885055, 0.1604754571703561, 0.007013296865137807, 6.8e-07, 0.0, 0.0, 0.0]\n",
      "Symbol Errors AWGN Channel (64-QAM):\n",
      " [0.8907340425531914, 0.7674403669724771, 0.5082713414634147, 0.15301651376146788, 0.0046187335457946515, 1.2e-07, 0.0, 0.0]\n",
      "Symbol Errors AWGN Channel (256-QAM):\n",
      " [0.962919540229885, 0.9160054945054945, 0.7977368421052632, 0.5237398119122257, 0.15210310218978101, 0.0040527646744152115, 1e-07, 0.0]\n"
     ]
    }
   ],
   "source": [
    "symbol_error_rate_bpsk_rayleigh = runner_rayleigh.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 2})\n",
    "symbol_error_rate_qam4_rayleigh = runner_rayleigh.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 4})\n",
    "symbol_error_rate_qam16_rayleigh = runner_rayleigh.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 16})\n",
    "symbol_error_rate_qam64_rayleigh = runner_rayleigh.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 64})\n",
    "symbol_error_rate_qam256_rayleigh = runner_rayleigh.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 256})\n",
    "\n",
    "print(\"Symbol Errors Rayleigh Channel (BPSK):\\n\",\n",
    "      symbol_error_rate_bpsk_rayleigh)\n",
    "print(\"Symbol Errors Rayleigh Channel (4-QAM):\\n\",\n",
    "      symbol_error_rate_qam4_rayleigh)\n",
    "print(\"Symbol Errors Rayleigh Channel (16-QAM):\\n\",\n",
    "      symbol_error_rate_qam16_rayleigh)\n",
    "print(\"Symbol Errors Rayleigh Channel (64-QAM):\\n\",\n",
    "      symbol_error_rate_qam64_rayleigh)\n",
    "print(\"Symbol Errors Rayleigh Channel (256-QAM):\\n\",\n",
    "      symbol_error_rate_qam256_rayleigh)\n",
    "\n",
    "symbol_error_rate_bpsk_awgn = runner_awgn.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 2})\n",
    "symbol_error_rate_qam4_awgn = runner_awgn.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 4})\n",
    "symbol_error_rate_qam16_awgn = runner_awgn.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 16})\n",
    "symbol_error_rate_qam64_awgn = runner_awgn.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 64})\n",
    "symbol_error_rate_qam256_awgn = runner_awgn.results.get_result_values_list(\n",
    "    \"symbol_error_rate\", fixed_params={\"M\": 256})\n",
    "\n",
    "print(\"Symbol Errors AWGN Channel (BPSK):\\n\", symbol_error_rate_qam4_awgn)\n",
    "print(\"Symbol Errors AWGN Channel (4-QAM):\\n\", symbol_error_rate_qam4_awgn)\n",
    "print(\"Symbol Errors AWGN Channel (16-QAM):\\n\", symbol_error_rate_qam16_awgn)\n",
    "print(\"Symbol Errors AWGN Channel (64-QAM):\\n\", symbol_error_rate_qam64_awgn)\n",
    "print(\"Symbol Errors AWGN Channel (256-QAM):\\n\", symbol_error_rate_qam256_awgn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can finally see the plot and compare the simulated results with theoretical values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now let's plot the results\n",
    "fig, [ax1, ax2] = plt.subplots(figsize=(15, 6), ncols=2)\n",
    "\n",
    "ax1.semilogy(EbN0_db_rayleigh,\n",
    "             symbol_error_rate_bpsk_rayleigh,\n",
    "             \"-\",\n",
    "             color=\"red\",\n",
    "             label=\"BPSK Simulation\")\n",
    "ax1.semilogy(EbN0_db_rayleigh,\n",
    "             symbol_error_rate_qam4_rayleigh,\n",
    "             \"-\",\n",
    "             color=\"orange\",\n",
    "             label=\"4-QAM Simulation\")\n",
    "ax1.semilogy(EbN0_db_rayleigh,\n",
    "             symbol_error_rate_qam16_rayleigh,\n",
    "             \"-\",\n",
    "             color=\"blue\",\n",
    "             label=\"16-QAM Simulation\")\n",
    "ax1.semilogy(EbN0_db_rayleigh,\n",
    "             symbol_error_rate_qam64_rayleigh,\n",
    "             \"-\",\n",
    "             color=\"lightgreen\",\n",
    "             label=\"64-QAM Simulation\")\n",
    "ax1.semilogy(EbN0_db_rayleigh,\n",
    "             symbol_error_rate_qam256_rayleigh,\n",
    "             \"-\",\n",
    "             color=\"magenta\",\n",
    "             label=\"256-QAM Simulation\")\n",
    "# ax1.semilogy(EbN0_db, QAM(256).calcTheoreticalSER(EbN0_db), color=\"magenta\", label=\"M=256 Theory\")\n",
    "ax1.set_title(\"Symbol Error Rate (Rayleigh channel)\")\n",
    "ax1.set_ylabel(\"Symbol Error Rate\")\n",
    "ax1.set_xlabel(\"EbN0 (dB)\")\n",
    "ax1.grid(True, which=\"both\")\n",
    "ax1.set_ylim((1e-4, 1e0))\n",
    "ax1.legend()\n",
    "\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             symbol_error_rate_bpsk_awgn,\n",
    "             \"o\",\n",
    "             color=\"red\",\n",
    "             label=\"BPSK Simulation\")\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             BPSK().calcTheoreticalSER(EbN0_db_awgn),\n",
    "             color=\"red\",\n",
    "             label=\"BPSK Theory\")\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             symbol_error_rate_qam4_awgn,\n",
    "             \"o\",\n",
    "             color=\"orange\",\n",
    "             label=\"M=4 Simulation\")\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             QAM(4).calcTheoreticalSER(EbN0_db_awgn + linear2dB(2)),\n",
    "             color=\"orange\",\n",
    "             label=\"4-QAM Theory\")\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             symbol_error_rate_qam16_awgn,\n",
    "             \"o\",\n",
    "             color=\"blue\",\n",
    "             label=\"16-QAM Simulation\")\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             QAM(16).calcTheoreticalSER(EbN0_db_awgn + linear2dB(4)),\n",
    "             color=\"blue\",\n",
    "             label=\"16-QAM Theory\")\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             symbol_error_rate_qam64_awgn,\n",
    "             \"o\",\n",
    "             color=\"lightgreen\",\n",
    "             label=\"64-QAM Simulation\")\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             QAM(64).calcTheoreticalSER(EbN0_db_awgn + linear2dB(6)),\n",
    "             color=\"lightgreen\",\n",
    "             label=\"64-QAM Theory\")\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             symbol_error_rate_qam256_awgn,\n",
    "             \"o\",\n",
    "             color=\"magenta\",\n",
    "             label=\"256-QAM Simulation\")\n",
    "ax2.semilogy(EbN0_db_awgn,\n",
    "             QAM(256).calcTheoreticalSER(EbN0_db_awgn + linear2dB(8)),\n",
    "             color=\"magenta\",\n",
    "             label=\"256-QAM Theory\")\n",
    "ax2.set_title(\"Symbol Error Rate (AWGN channel)\")\n",
    "ax2.set_ylabel(\"Symbol Error Rate\")\n",
    "ax2.set_xlabel(\"EbN0 (dB)\")\n",
    "ax2.grid(True, which=\"both\")\n",
    "ax2.set_ylim((1e-5, 1e0))\n",
    "ax2.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results matches the theoretical values pretty well for AWGN channel.\n",
    "\n",
    "See [this link for some derivations](http://www.dsplog.com/2012/01/01/symbol-error-rate-16qam-64qam-256qam/).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final Note\n",
    "\n",
    "This notebook illustrated how to create simulators in `pyphysim` and run them in parallel, but very little functionality was shown for simulating wireless transmissions.\n",
    "\n",
    "For an example of transmitting through a multipath channel with OFDM, see the noteook [TDL_and_OFDM](TDL_and_OFDM.ipynb).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.4"
  },
  "toc-autonumbering": false,
  "toc-showmarkdowntxt": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}