notebooks/Transmission_with_AWGN_channel.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulation of digital modulation with AWGN channel\n",
    "\n",
    "\n",
    "This notebook illustrates how to perform a simulation of a transmission through an AWGN channel using QPSK modulation. It also shows how to use the features in `pyphysim` to implement \"simulators\" and how they can have with some boiler plate code and add functionality such as progressbar, saving results to a file and running simulations in parallel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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, QPSK, Modulator\n",
    "from pyphysim.simulations import Result, SimulationResults, SimulationRunner\n",
    "from pyphysim.util.conversion import dB2Linear\n",
    "from pyphysim.util.misc import pretty_time, randn_c\n",
    "\n",
    "np.set_printoptions(precision=2, linewidth=120)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualize the constellation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "qpsk = QPSK()\n",
    "bpsk = BPSK()\n",
    "qam16 = QAM(16)\n",
    "qam64 = QAM(64)\n",
    "\n",
    "fig, [[ax11, ax12], [ax21, ax22]] = plt.subplots(figsize=(10, 10),\n",
    "                                                 nrows=2,\n",
    "                                                 ncols=2)\n",
    "\n",
    "ax11.set_title(\"BPSK\")\n",
    "ax11.plot(bpsk.symbols.real, bpsk.symbols.imag, \"*r\", label=\"BPSK\")\n",
    "ax11.axis(\"equal\")\n",
    "\n",
    "ax12.set_title(\"QPSK\")\n",
    "ax12.plot(qpsk.symbols.real, qpsk.symbols.imag, \"*r\", label=\"QPSK\")\n",
    "ax12.axis(\"equal\")\n",
    "\n",
    "ax21.set_title(\"16-QAM\")\n",
    "ax21.plot(qam16.symbols.real, qam16.symbols.imag, \"*r\", label=\"16-QAM\")\n",
    "ax21.axis(\"equal\")\n",
    "\n",
    "ax22.set_title(\"64-QAM\")\n",
    "ax22.plot(qam64.symbols.real, qam64.symbols.imag, \"*r\", label=\"64-QAM\")\n",
    "ax22.axis(\"equal\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transmit though the channel\n",
    "\n",
    "Now let's see a transmission with QPSK modulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "qpsk = QPSK()\n",
    "num_symbols = int(1e3)\n",
    "\n",
    "# We need the data to be in the interval [0, M), where M is the\n",
    "# number of symbols in the constellation\n",
    "data_qpsk = np.random.randint(0, qpsk.M, size=num_symbols)\n",
    "modulated_data_qpsk = qpsk.modulate(data_qpsk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "SNR_dB = 20\n",
    "snr_linear = dB2Linear(SNR_dB)\n",
    "noise_power = 1 / snr_linear\n",
    "\n",
    "# Noise vector\n",
    "n = math.sqrt(noise_power) * randn_c(num_symbols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# received_data_qam = su_channel.corrupt_data(modulated_data_qam)\n",
    "received_data_qpsk = modulated_data_qpsk + n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.9941791935839641,\n",
       " 1.0165313894292265,\n",
       " -0.9810272536115086,\n",
       " 0.9798690572412926)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Received data\n",
    "fig, ax = plt.subplots(figsize=(5, 5))\n",
    "ax.plot(received_data_qpsk.real, received_data_qpsk.imag, \"*\")\n",
    "ax.axis(\"equal\")\n",
    "# fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see the obtained error value. However, note that in order to get the proper error value we need to repeat this simulation many times and average the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error QPSK: 0.0\n"
     ]
    }
   ],
   "source": [
    "demodulated_data_qpsk = qpsk.demodulate(received_data_qpsk)\n",
    "symbol_error_rate_qpsk = 1 - sum(\n",
    "    demodulated_data_qpsk == data_qpsk) / demodulated_data_qpsk.size\n",
    "print(\"Error QPSK:\", symbol_error_rate_qpsk)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Delete previous variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "del SNR_dB, ax, ax11, ax12, ax21, ax22, bpsk, data_qpsk, demodulated_data_qpsk, fig, modulated_data_qpsk, n, noise_power, num_symbols, qam16, qam64, qpsk, received_data_qpsk, snr_linear, symbol_error_rate_qpsk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Move code to a function in order to average results\n",
    "\n",
    "For comparison, let's also create a function to simulate the symbol error rate for a pure AWGN channel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_awgn(modulator: Modulator, num_symbols: int, noise_power: float,\n",
    "                  num_reps: int):\n",
    "    \"\"\"Return the symbol error rate\"\"\"\n",
    "    symbol_error_rate = 0.0\n",
    "    for rep in range(num_reps):\n",
    "        data = np.random.randint(0, modulator.M, size=num_symbols)\n",
    "        modulated_data = modulator.modulate(data)\n",
    "\n",
    "        # Noise vector\n",
    "        n = math.sqrt(noise_power) * randn_c(num_symbols)\n",
    "\n",
    "        # received_data_qam = su_channel.corrupt_data(modulated_data_qam)\n",
    "        received_data = modulated_data + n\n",
    "\n",
    "        demodulated_data = modulator.demodulate(received_data)\n",
    "        symbol_error_rate += 1 - sum(\n",
    "            demodulated_data == data) / demodulated_data.size\n",
    "    return symbol_error_rate / num_reps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "qpsk = QPSK()\n",
    "num_symbols = int(1e3)\n",
    "\n",
    "SNR_dB = 5\n",
    "snr_linear = dB2Linear(SNR_dB)\n",
    "noise_power = 1 / snr_linear\n",
    "\n",
    "# We run twice just to check that the number of simulated symbols and repetitions is enouth to get a proper value\n",
    "symbol_error1 = simulate_awgn(qpsk, num_symbols, noise_power, num_reps=5000)\n",
    "symbol_error2 = simulate_awgn(qpsk, num_symbols, noise_power, num_reps=5000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obtained symbol error for SNR 5: 0.07400820000000001\n",
      "Obtained symbol error for SNR 5: 0.073906\n",
      "\n",
      "Theoretical symbol error for SNR 5: 0.07535797629492685\n"
     ]
    }
   ],
   "source": [
    "print(f\"Obtained symbol error for SNR {SNR_dB}: {symbol_error1}\")\n",
    "print(f\"Obtained symbol error for SNR {SNR_dB}: {symbol_error2}\")\n",
    "\n",
    "# Let's print the theoretical value\n",
    "print(\n",
    "    f\"\\nTheoretical symbol error for SNR {SNR_dB}: {qpsk.calcTheoreticalSER(SNR_dB)}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulate for different values of noise power\n",
    "\n",
    "The previously implemented `simulate_awgn` function is very simple and we only need to call it with different values of noise power to get the values for a \"SNR x Symbol Error Rate\" plot.\n",
    "\n",
    "However, this is a good oportunity to see what the classes in the `pyphysim.simulations` module can offer.\n",
    "\n",
    "To create a \"simulator\" we need to create a subclass of `pyphysim.simulations.SimulationRunner` and implement the `_run_simulation` method. This method should perform a single iteration (similar to the previous `simulate_awgn` function, but without the loop) and return a `SimulationResults` object containing whatever results you want to save from that iteration. These results will be automatically combined for the many calls of `_run_simulation` method that will be performed when the `simulate` of the `SimulationRunner` base class is called. \n",
    "\n",
    "In the `__init__` of your simulator class you must at least do two things: set the desired \"simulation parameters\" and set a value for `self.rep_max` (default is 1) with the number of times you want to call `_run_simulation`.\n",
    "\n",
    "In the code below we add a \"SNR_db\" parameter by calling the `add` method of `self.params` (defined in the base class). The inportant fact here is that we set \"SNR_db\" as an array with several values, but we set it to be \"unpacked\", which means that one value should be used at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AwgnSimulator(SimulationRunner):\n",
    "\n",
    "    def __init__(self, SINR_dB_values):\n",
    "        \"\"\"\n",
    "        Parameters\n",
    "        ----------\n",
    "        SINR_dB_values : np.ndarray\n",
    "            An array with the several SNR values to simulate\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "\n",
    "        # Add the simulation parameters to the `params` attribute.\n",
    "        self.params.add('SNR_db', SINR_dB_values)\n",
    "\n",
    "        # Here we indicate that the SNR_db parameter should be \"unpacked\". \n",
    "        # What that means is that the `current_parameters` argument passed to `_run_simulation` will only have one value\n",
    "        # and this value will change in subsequent calls to `_run_simulation`\n",
    "        self.params.set_unpack_parameter('SNR_db')\n",
    "\n",
    "        # Number of times the `_run_simulation` method will run when `simulate` method is called\n",
    "        self.rep_max = 500\n",
    "\n",
    "        # We can save anything that does not change in `_run_simulation` as attributes\n",
    "        # We could also add the information to `self.params` and buind the modulator inside `_run_simulation`\n",
    "        self.modulator = QPSK()\n",
    "\n",
    "    def _run_simulation(self, current_parameters):\n",
    "        # Since SNR_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['SNR_db']\n",
    "\n",
    "        # Number of symbols generated for this realization\n",
    "        num_symbols = 1000\n",
    "\n",
    "        # Find the noise power from the SNR value (in dB)\n",
    "        snr_linear = dB2Linear(sinr_dB)\n",
    "        noise_power = 1 / snr_linear\n",
    "\n",
    "        # Generate random transmit data and modulate it\n",
    "        data = np.random.randint(0, self.modulator.M, size=num_symbols)\n",
    "        modulated_data = self.modulator.modulate(data)\n",
    "\n",
    "        # Noise vector\n",
    "        n = math.sqrt(noise_power) * randn_c(num_symbols)\n",
    "\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 = self.modulator.demodulate(received_data)\n",
    "        symbol_errors = sum(demodulated_data != 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(\n",
    "            \"symbol_error_rate\",\n",
    "            Result.RATIOTYPE,\n",
    "            value=symbol_errors,\n",
    "            total=num_symbols)  # Add one each result you want\n",
    "        return simResults"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can run the simulation. Let's create an AwgnSimulator object and check its parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'SNR_db*': [-5.  -2.5  0.   2.5  5.   7.5 10.  12.5 15. ]}\n"
     ]
    }
   ],
   "source": [
    "SNR_db = np.linspace(-5, 15, 9)\n",
    "\n",
    "runner = AwgnSimulator(SNR_db)\n",
    "# We can see the simulation parameters using the `params` attribute of the `SimulationRunner`\n",
    "print(runner.params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have only added the `SNR_db` parameter. The `*` in the name of the `SNR_db` parameter indicates that this parameter will be *unpacked*. This means that the `_run_simulation` method will receive one element of it at a time instead of the whole array.\n",
    "\n",
    "Now we can finally call the `simulate` method to perform the simulation. Notice the nice progressbar and that we have 9 variations. Each variation corresponds to a different SNR value. If we had added other parameters that should also be unpacked then we would get a different variation for each combination of unpacked parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------- Current Variation: 1/9 -------------\n",
      "[**********************100%**********************]  Progress\n",
      "------------- Current Variation: 2/9 -------------\n",
      "[**********************100%**********************]  Progress\n",
      "------------- Current Variation: 3/9 -------------\n",
      "[**********************100%**********************]  Progress\n",
      "------------- Current Variation: 4/9 -------------\n",
      "[**********************100%**********************]  Progress\n",
      "------------- Current Variation: 5/9 -------------\n",
      "[**********************100%**********************]  Progress\n",
      "------------- Current Variation: 6/9 -------------\n",
      "[**********************100%**********************]  Progress\n",
      "------------- Current Variation: 7/9 -------------\n",
      "[**********************100%**********************]  Progress\n",
      "------------- Current Variation: 8/9 -------------\n",
      "[**********************100%**********************]  Progress\n",
      "------------- Current Variation: 9/9 -------------\n",
      "[**********************100%**********************]  Progress\n"
     ]
    }
   ],
   "source": [
    "runner.simulate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get the simulation results (a SimulationResults object) with the `results` atribute of our simulator object. We can call the `get_result_values_list` method to get the actual values. Let's first check what is stored there.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SimulationResults: ['elapsed_time', 'num_skipped_reps', 'symbol_error_rate']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "runner.results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that we have our \"symbol_error_rate\" result, which is a combination of all the times the `_run_simulation` method was called. Other stored information are the \"elapsed_time\" and \"num_skipped_reps\" (more on this one later).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symbol Errors:\n",
      " [4.92e-01 4.02e-01 2.92e-01 1.74e-01 7.37e-02 1.78e-02 1.54e-03 1.80e-05 0.00e+00]\n",
      "\n",
      "Elapsed times:\n",
      " [1.18 1.1  1.17 1.14 1.16 1.3  1.15 1.15 1.18]\n",
      "\n",
      "Total elapsed time: 10.53s\n"
     ]
    }
   ],
   "source": [
    "print(\"Symbol Errors:\\n\",\n",
    "      np.array(runner.results.get_result_values_list(\"symbol_error_rate\")))\n",
    "elapsed_times = runner.results.get_result_values_list(\"elapsed_time\")\n",
    "print(\"\\nElapsed times:\\n\", np.array(elapsed_times))\n",
    "\n",
    "# pretty_time receives a float number corresponding to an elapsed time in seconds and returns a nice string\n",
    "print(f\"\\nTotal elapsed time: {pretty_time(sum(elapsed_times))}\")"
   ]
  },
  {
   "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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now let's plot the results\n",
    "fig, ax = plt.subplots(figsize=(5, 5))\n",
    "ax.semilogy(SNR_db, qpsk.calcTheoreticalSER(SNR_db), \"--\", label=\"Theoretical\")\n",
    "ax.semilogy(SNR_db,\n",
    "            runner.results.get_result_values_list(\"symbol_error_rate\"),\n",
    "            label=\"Simulated\")\n",
    "ax.set_title(\"QPSK Symbol Error Rate (AWGN channel)\")\n",
    "ax.set_ylabel(\"Symbol Error Rate\")\n",
    "ax.set_xlabel(\"SNR (dB)\")\n",
    "ax.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simulated values match the theoretical values up to some point, where we can see that we need to simulate more symbols to get the proper symbol error rate. The easy way is to increase the `rep_max` attribute in our simulator, but this will simulate more symbols also for lower SNR values, which will unecesarelly make the simulation slower. Ideally, we want to simulate a large number of symbols for high SNR values and a low number of symbols for low SNR values.\n",
    "\n",
    "One way to do this is to set `rep_max` to the highest value we want (for the high SNR values) and implement the `_keep_going` method. This method is called each iteration to indicate if we need more iterations of if we can stop early (for a particular variation of parameters). Since we didn't implement it before, the default implementation was used, which just returns True.\n",
    "\n",
    "The `_keep_going` should be simple to avoid creating unecessary overhead (is cost must be much lower than `_run_simulation`). One possible implementation if to return True as long as the number of cumulative symbol errors is below some value. That is, for low SNR values this value will be reached before the number of times `_run_simulation` is called reach `rep_max`, while for high SNR values this maximum number of sumbol errors might never be reached and `_run_simulation` is called `rep_max` times.\n",
    "\n",
    "The changed implementation of our simulator is given below.\n",
    "\n",
    "**Note**: We have set `self.progressbar_message` in the `__init__` method. This allow us to change the message of the progressbar and we can use parameters names in the message, which is automatically replaced by the current value (if unpacked)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AwgnSimulator2(SimulationRunner):\n",
    "\n",
    "    def __init__(self, SINR_dB_values):\n",
    "        super().__init__()\n",
    "\n",
    "        # Add the simulation parameters to the `params` attribute.\n",
    "        self.params.add('SNR_db', SINR_dB_values)\n",
    "\n",
    "        # Here we indicate that the SNR_db parameter should be \"unpacked\". \n",
    "        # What that means is that the `current_parameters` argument passed to `_run_simulation` will only have one value\n",
    "        # and this value will change in subsequent calls to `_run_simulation`\n",
    "        self.params.set_unpack_parameter('SNR_db')\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 SNR 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. / 1000. * self.num_symbols * self.rep_max\n",
    "\n",
    "        # We can save anything that does not change in `_run_simulation` as attributes\n",
    "        self.modulator = QPSK()\n",
    "\n",
    "        # Set a nice message for the progressbar\n",
    "        self.progressbar_message = \"Simulating for SNR {SNR_db}\"\n",
    "\n",
    "        # Change the progressbar \"style\" to something nicer for the notebook\n",
    "        # Possible values are 'text1', 'text2' and 'ipython'\n",
    "        self.update_progress_function_style = \"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 SNR_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['SNR_db']\n",
    "\n",
    "        # Find the noise power from the SNR value (in dB)\n",
    "        snr_linear = dB2Linear(sinr_dB)\n",
    "        noise_power = 1 / snr_linear\n",
    "\n",
    "        # Generate random transmit data and modulate it\n",
    "        data = np.random.randint(0, self.modulator.M, size=self.num_symbols)\n",
    "        modulated_data = self.modulator.modulate(data)\n",
    "\n",
    "        # Noise vector\n",
    "        n = math.sqrt(noise_power) * randn_c(self.num_symbols)\n",
    "\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 = self.modulator.demodulate(received_data)\n",
    "        symbol_errors = sum(demodulated_data != 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",
    "        return simResults"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can run the simulation. We will also call the `set_results_filename` so that the results are saved to the disk. The results will be saved using pickle. Furthermore, partial results are also saved (inside a \"partial_results\" folder) and you can interrupt the simulation and continue from where it was interrupted.\n",
    "\n",
    "If you do not set the results filename before starting the simulation, you can also save the results by calling the `save_to_file` method of the `runner2.results` object (although in this case partial results will not be saved during the simulation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bf868dd2045e444bb4f12ba90ace05e7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR -5.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0c0abb77922c41e4b6c0208cf58180bf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR -2.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "384eb67b404a42c7bef129d56a08d596",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 0.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "97d882106e8d458da3321e688e522c9c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 2.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5a52553f6dd44e11a48955be0ed015cb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 5.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "55fc27f4371f40718a2eba61ec93df9f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 7.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "50e6889cd5094997b7bb9b1850469974",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 10.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7843738e87314e00a508ac79633a078e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 12.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ca1520784d0442a29b3fdc197dd8cc48",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 15.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "runner2 = AwgnSimulator2(SNR_db)\n",
    "# Set the name name of the results file\n",
    "# If the file extension is not provided, then pickle will be used to save the results\n",
    "# If an extension is provided, it can be either 'pickle' or 'json'\n",
    "runner2.set_results_filename(\"results_qpsk_awgn\")\n",
    "runner2.simulate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling again will simply load the results from the file and it should be very fast."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9bc0abf6c80145bdbea621b9a867a547",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR -5.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2ff5c447be0948bc80429f48c90f9f35",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR -2.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0b44d82af17248918a421d5e806253f8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 0.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e66839e2c8dd4ce39779c1f41e7bf178",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 2.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1b0af2809bc54b0db501e96ed42f2bd8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 5.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3ac0a52f3dbe4e00a481247d4c0951c7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 7.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "574ac83b398042e596208ab8fdfe4c4f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 10.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "24d4a43c397040568cc6f94fb55f5a4b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 12.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9f8aa567903d47d0a104c495888d403f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 15.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "runner2.simulate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c2a87dba02bc4ec199bfa00ecea36ef4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR -5.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8dd1430d857a4148a3ff0da83d8b9732",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR -2.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e729f8a9c86843259f48b57039c99e0d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 0.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f8edeceb527e4f8b8d594df20d682fd2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 2.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0b6e3885c2084c38a41ed4d4e2e987dd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 5.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "430dec56d6b648c480d5bf21674db68a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 7.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0ce1464e3d8b46569c5812fccfa1eaf2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 10.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3bce96d8358148828968f0051e8c872e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 12.5')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "869e84758418443b8da584849200b064",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0), Label(value='Simulating for SNR 15.0')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# However, if you increase the value of rep_max and run the `simulate` method again\n",
    "# it will run only the remaining iterations\n",
    "runner2.rep_max += 2000\n",
    "runner2.simulate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before we have the \"symbol_error_rate\", \"elapsed_time\" and \"num_skipped_reps\" results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SimulationResults: ['elapsed_time', 'num_skipped_reps', 'symbol_error_rate', 'symbol_errors']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "runner2.results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "print(runner2.results.get_result_values_list(\"num_skipped_reps\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"num_skipped_reps\" results indicate how many iterations were skiped due to a `SkipThisOne` exception being raised in the `_run_simulation` method for some reason. It is not related to the simulation being stopped ealier due to `_keep_going` returning `False`. If you need to know how many iterations were run just add a result in `_run_simulation` to track that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symbol Errors:\n",
      " [4.91e-01 4.02e-01 2.90e-01 1.74e-01 7.40e-02 1.76e-02 1.58e-03 2.40e-05 1.92e-08]\n",
      "\n",
      "Elapsed times:\n",
      " [  0.21   0.24   0.45   0.59   1.47   7.06  72.12 119.8  122.22]\n",
      "\n",
      "Total elapsed time: 5m:24s\n"
     ]
    }
   ],
   "source": [
    "print(\"Symbol Errors:\\n\",\n",
    "      np.array(runner2.results.get_result_values_list(\"symbol_error_rate\")))\n",
    "elapsed_times2 = runner2.results.get_result_values_list(\"elapsed_time\")\n",
    "print(\"\\nElapsed times:\\n\", np.array(elapsed_times2))\n",
    "\n",
    "# pretty_time receives a float number corresponding to an elapsed time in seconds and returns a nice string\n",
    "print(f\"\\nTotal elapsed time: {pretty_time(sum(elapsed_times2))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the elapsed times for the low SNR values. The simulation was very fast for low SNR values, while for high SNR values it took longer. You can compare this to the case where the `_keep_going` method was not implemented and the elapsed time was approximatelly the same for all SNR values.\n",
    "\n",
    "Let's plot the results with the new simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5. , -2.5,  0. ,  2.5,  5. ,  7.5, 10. , 12.5, 15. ])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SNR_db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now let's plot the results\n",
    "fig, ax = plt.subplots(figsize=(5, 5))\n",
    "ax.semilogy(SNR_db, qpsk.calcTheoreticalSER(SNR_db), \"--\", label=\"Theoretical\")\n",
    "ax.semilogy(SNR_db,\n",
    "            runner2.results.get_result_values_list(\"symbol_error_rate\"),\n",
    "            label=\"Simulated\")\n",
    "ax.set_title(\"QPSK Symbol Error Rate (AWGN channel)\")\n",
    "ax.set_ylabel(\"Symbol Error Rate\")\n",
    "ax.set_xlabel(\"SNR (dB)\")\n",
    "ax.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the simulated symbol error rate match the theoretical value also in the high SNR regime."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run simulations in parallel\n",
    "\n",
    "By implementing a subclass of `SimulationRunner` you also gain the possibility of running the different configurations (different SNR values in our case) in parallel by using the `simulate_in_parallel` method, instead of `simulate`. This parallel computation is performed using the `ipyparallel` library, which is an optional dependency of `pyphysim`. \n",
    "\n",
    "See the [Transmission_with_Rayleigh_and_AWGN_channels](Transmission_with_Rayleigh_and_AWGN_channels.ipynb) notebook for an example that performs simulations in parallel.\n",
    "\n",
    "\n",
    "**Note**: When running in parallel only a single progressbar will be presented, but it will account the progress of all running configurations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using saved results from a simulation\n",
    "\n",
    "The `results` atribute of the simulator (the `runner2` object in this notebook) is an instance of the `SimulationResults` class. There are a few ways to get the values stored in it. To see which results are stored in the `results` object we can call the `get_result_names` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['symbol_error_rate', 'symbol_errors', 'elapsed_time', 'num_skipped_reps']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "runner2.results.get_result_names()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index this object with the name of the desired result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Result -> elapsed_time: 0.20981049537658691,\n",
       " Result -> elapsed_time: 0.2427213191986084,\n",
       " Result -> elapsed_time: 0.45435571670532227,\n",
       " Result -> elapsed_time: 0.5926723480224609,\n",
       " Result -> elapsed_time: 1.4656848907470703,\n",
       " Result -> elapsed_time: 7.056248903274536,\n",
       " Result -> elapsed_time: 72.12221837043762,\n",
       " Result -> elapsed_time: 119.8037121295929,\n",
       " Result -> elapsed_time: 122.21845483779907]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "runner2.results[\"elapsed_time\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This yeilds a list of `Result` objects (see the help of the `Result class for more`), but if you just want the values then call the `get_result_values_list` method of the `SimulationResults` class instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.20981049537658691,\n",
       " 0.2427213191986084,\n",
       " 0.45435571670532227,\n",
       " 0.5926723480224609,\n",
       " 1.4656848907470703,\n",
       " 7.056248903274536,\n",
       " 72.12221837043762,\n",
       " 119.8037121295929,\n",
       " 122.21845483779907]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the elapsed time of each configuration (each SNR in our case)\n",
    "runner2.results.get_result_values_list(\"elapsed_time\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also get the confidence interval of some result with the `get_result_values_confidence_intervals` method. You can even use the confidence interval in the implementation of the `_keep_going` method, if you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0.4883117978827526, 0.4939823197643062),\n",
       " (0.399371746528551, 0.404564253471449),\n",
       " (0.2882075005801296, 0.29245145895744257),\n",
       " (0.17274459388963365, 0.1755679061103662),\n",
       " (0.0734197600734171, 0.07463349436445313),\n",
       " (0.017432923843822248, 0.01773303958796422),\n",
       " (0.0015620721459866176, 0.001589618736171652),\n",
       " (2.2707996796215086e-05, 2.536892628070698e-05),\n",
       " (-1.8461176033760512e-08, 5.6922714495298977e-08)]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "runner2.results.get_result_values_confidence_intervals(\"symbol_error_rate\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To save the results to a file you can use `save_to_file` method of `SimulationResults`. That was already done for us in the end of the simulation, since we have called the `set_results_filename` method of our simulator. \n",
    "\n",
    "Once you have a file with the saved results you can load its data using the `SimulationResults.load_from_file`. This returns a `SimulationResults` object with the loaded data and you can use the previously discussed ways to access its data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SimulationResults: ['elapsed_time', 'num_skipped_reps', 'symbol_error_rate', 'symbol_errors']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If the filename is provided without extension, then 'pickle' is assumed as the file extension\n",
    "results = SimulationResults.load_from_file(\"results_qpsk_awgn\")\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to use the data in a `SimulationResults` object is calling its `to_dataframe` method. It will create a (https://pandas.pydata.org/)[pandas] `DataFrame` with the data in the `SimulationResults` object. This required the `pandas` library to be installed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>SNR_db</th>\n",
       "      <th>rep_max</th>\n",
       "      <th>symbol_error_rate</th>\n",
       "      <th>symbol_errors</th>\n",
       "      <th>elapsed_time</th>\n",
       "      <th>num_skipped_reps</th>\n",
       "      <th>runned_reps</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-5.0</td>\n",
       "      <td>52000</td>\n",
       "      <td>4.911471e-01</td>\n",
       "      <td>50097</td>\n",
       "      <td>0.209810</td>\n",
       "      <td>0</td>\n",
       "      <td>102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-2.5</td>\n",
       "      <td>52000</td>\n",
       "      <td>4.019680e-01</td>\n",
       "      <td>50246</td>\n",
       "      <td>0.242721</td>\n",
       "      <td>0</td>\n",
       "      <td>125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>52000</td>\n",
       "      <td>2.903295e-01</td>\n",
       "      <td>50227</td>\n",
       "      <td>0.454356</td>\n",
       "      <td>0</td>\n",
       "      <td>173</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.5</td>\n",
       "      <td>52000</td>\n",
       "      <td>1.741563e-01</td>\n",
       "      <td>50157</td>\n",
       "      <td>0.592672</td>\n",
       "      <td>0</td>\n",
       "      <td>288</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>52000</td>\n",
       "      <td>7.402663e-02</td>\n",
       "      <td>50042</td>\n",
       "      <td>1.465685</td>\n",
       "      <td>0</td>\n",
       "      <td>676</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>7.5</td>\n",
       "      <td>52000</td>\n",
       "      <td>1.758298e-02</td>\n",
       "      <td>50006</td>\n",
       "      <td>7.056249</td>\n",
       "      <td>0</td>\n",
       "      <td>2844</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>10.0</td>\n",
       "      <td>52000</td>\n",
       "      <td>1.575845e-03</td>\n",
       "      <td>50000</td>\n",
       "      <td>72.122218</td>\n",
       "      <td>0</td>\n",
       "      <td>31729</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>12.5</td>\n",
       "      <td>52000</td>\n",
       "      <td>2.403846e-05</td>\n",
       "      <td>1250</td>\n",
       "      <td>119.803712</td>\n",
       "      <td>0</td>\n",
       "      <td>52000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>15.0</td>\n",
       "      <td>52000</td>\n",
       "      <td>1.923077e-08</td>\n",
       "      <td>1</td>\n",
       "      <td>122.218455</td>\n",
       "      <td>0</td>\n",
       "      <td>52000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   SNR_db  rep_max  symbol_error_rate  symbol_errors  elapsed_time  \\\n",
       "0    -5.0    52000       4.911471e-01          50097      0.209810   \n",
       "1    -2.5    52000       4.019680e-01          50246      0.242721   \n",
       "2     0.0    52000       2.903295e-01          50227      0.454356   \n",
       "3     2.5    52000       1.741563e-01          50157      0.592672   \n",
       "4     5.0    52000       7.402663e-02          50042      1.465685   \n",
       "5     7.5    52000       1.758298e-02          50006      7.056249   \n",
       "6    10.0    52000       1.575845e-03          50000     72.122218   \n",
       "7    12.5    52000       2.403846e-05           1250    119.803712   \n",
       "8    15.0    52000       1.923077e-08              1    122.218455   \n",
       "\n",
       "   num_skipped_reps  runned_reps  \n",
       "0                 0          102  \n",
       "1                 0          125  \n",
       "2                 0          173  \n",
       "3                 0          288  \n",
       "4                 0          676  \n",
       "5                 0         2844  \n",
       "6                 0        31729  \n",
       "7                 0        52000  \n",
       "8                 0        52000  "
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results.to_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that besides the simulation results, the dataframe also includes the simulation parameters (`SNR_db` in our case) as well as the number of runned repetitions, skipped repetitions, and the elapsed time.\n",
    "\n",
    "Indeed, the `SimulationResults` object stores all of this information. Particularly, the `params` attribute has all the simulation parameters. This allow you to have all necessary information of a simulation from the saved results file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'SNR_db*': [-5.  -2.5  0.   2.5  5.   7.5 10.  12.5 15. ], 'rep_max': 52000}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results.params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final Note\n",
    "\n",
    "This notebook illustrated how to create simulators in `pyphysim`, but it only touched a very small part of functionality to simulate physical layer transmission in wireless communications. You can explore the classes in `pyphysim` for other functionality such as other channels, MIMO transmission, etc.. In general you can addapt code here to simulate other scenarios by just changing the implementation of the `_run_simulation` and `_keep_going` methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the notebook [Transmission_with_Rayleigh_and_AWGN_channels](Transmission_with_Rayleigh_and_AWGN_channels.ipynb) for a simulation with Rayleigh channel and different QAM constelation sizes."
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}