{
    "cells": [
        {
            "cell_type": "code",
            "execution_count": 1,
            "id": "4bcd49a4",
            "metadata": {
                "nbsphinx": "hidden"
            },
            "outputs": [],
            "source": [
                "# Install HermesPy and its dependencies in the current kernel\n",
                "# When running on Colabs, a restart of the runtime is required afterwards\n",
                "\n",
                "import sys\n",
                "!{sys.executable} -m pip install --quiet hermespy"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Implementing Evaluators\n",
                "=======================\n",
                "\n",
                "[Evaluators](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Evaluator) represent the process of estimating performance indicators within Hermes' API, both during simulation runtime and in custom use-cases.\n",
                "They are, arguably, one of the more complex concepts to grasp for library users not very accustomed to distributed computing.\n",
                "\n",
                "In order to demonstrate the programming workflow, we'll add an evaluator estimating the average signal power received at a wireless device.\n",
                "Such an tool could be useful to gain insight into the behaviour of beamformers in multipath environments, or simply as a debugging tool of channel models and waveforms.\n",
                "Let's get right into it:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [],
            "source": [
                "from __future__ import annotations\n",
                "from typing import List\n",
                "\n",
                "import matplotlib.pyplot as plt\n",
                "import numpy as np\n",
                "\n",
                "from hermespy.core import Artifact, Evaluation, EvaluationResult, Evaluator, Executable, GridDimension, Receiver, Signal\n",
                "    \n",
                "\n",
                "class PowerArtifact(Artifact):\n",
                "    \n",
                "    power: float\n",
                "    \n",
                "    def __init__(self, power: float) -> None:\n",
                "        \n",
                "        self.power = power\n",
                "        \n",
                "    def __str__(self) -> str:\n",
                "        \n",
                "        return f\"{self.power:.2f}\"\n",
                "    \n",
                "    def to_scalar(self) -> float:\n",
                "        \n",
                "        return self.power\n",
                "    \n",
                "\n",
                "class PowerEvaluation(Evaluation):\n",
                "    \n",
                "    power: np.ndarray\n",
                "    \n",
                "    def __init__(self, signal: Signal) -> None:\n",
                "        \n",
                "        self.power = signal.power\n",
                "        \n",
                "    def plot(self) -> None:\n",
                "        \n",
                "        with Executable.style_context():\n",
                "            \n",
                "            fig, axis = plt.subplots()\n",
                "            fig.suptitle('Received Signal Powers')\n",
                "            \n",
                "            axis.stem(np.arange(len(self.power)), self.power)\n",
                "            axis.set_xlabel('Antenna Index')\n",
                "            axis.set_ylabel('Power')\n",
                "            \n",
                "    def artifact(self) -> PowerArtifact:\n",
                "        \n",
                "        summed_power = np.sum(self.power, keepdims=False)\n",
                "        return PowerArtifact(summed_power)\n",
                "\n",
                "\n",
                "class PowerEvaluationResult(EvaluationResult):\n",
                "    \n",
                "    def __init__(\n",
                "        self,\n",
                "        grid: List[GridDimension],\n",
                "        evaluator: PowerEstimator,\n",
                "        artifacts: np.ndarray,\n",
                "    ) -> None:\n",
                "\n",
                "        self.mean_powers = np.empty(artifacts.shape, dtype=float)\n",
                "        for section_coords in np.ndindex(artifacts.shape):\n",
                "            self.mean_powers[section_coords] = np.mean([a.power for a in artifacts[section_coords]])\n",
                "\n",
                "        EvaluationResult.__init__(self, grid, evaluator)\n",
                "        \n",
                "    def _plot(self, axes: plt.Axes) -> None:\n",
                "\n",
                "        self._plot_multidim(self.mean_powers, 0, 'Average Power', 'linear', 'linear', axes)\n",
                "        \n",
                "    def to_array(self) -> np.ndarray:\n",
                "        \n",
                "        return self.mean_powers\n",
                "\n",
                "\n",
                "class PowerEstimator(Evaluator):\n",
                "    \n",
                "    def __init__(self, receiver: Receiver) -> None:\n",
                "        \n",
                "        self.__receiver = receiver\n",
                "        Evaluator.__init__(self)\n",
                "        \n",
                "    def evaluate(self) -> PowerEvaluation:\n",
                "        \n",
                "        if self.__receiver.reception is None:\n",
                "            raise RuntimeError(\"Receiver has not reception available to evaluate\")\n",
                "            \n",
                "        return PowerEvaluation(self.__receiver.reception.signal)\n",
                "    \n",
                "    @property\n",
                "    def abbreviation(self) -> str:\n",
                "        \n",
                "        return \"Power\"\n",
                "    \n",
                "    @property\n",
                "    def title(self) -> str:\n",
                "        \n",
                "        return \"Received Power\"\n",
                "    \n",
                "    def generate_result(self, grid: List[GridDimension], artifacts: np.ndarray) -> PowerEvaluationResult:\n",
                "        \n",
                "        return PowerEvaluationResult(grid, self, artifacts)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Here's what you're probably thinking right now: [Artifacts](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Artifact), [Evaluations](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Evaluation), [EvaluationResults](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.EvaluationResult) and [Evaluators](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Evaluator), why do we need four interacting classes to investigate a single performance indicator?\n",
                "The answer is, this structure is required to enable efficient distributed execution of Monte Carlo simulations, while simulatenously offering an easily programmable interface for other use-cases such as software defined radio operation.\n",
                "\n",
                "The basis is the [Evaluator](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Evaluator), in our case the  *PowerEstimator*.\n",
                "Given a single scenario data drop, it generates an [Evaluation](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Evaluation) object representing the extracted performance indicator information.\n",
                "This information is then compressed to Artifacts [Artifacts](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Artifact) for each simulation grid sample and finally collected within the [generate_result](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Evaluator.generate_result) method of the [Evaluator](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Evaluator), creating an [EvaluationResult](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.EvaluationResult).\n",
                "\n",
                "During distributed simulations, the process of generating [Artifacts](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.Artifact) is executed multiple times in parallel, with only the resulting artifacts being sent to the simulation controller, in order to optimize the simulation data throughput between simulation controller and distributed simulation workers.\n",
                "Hermes is built around the [Ray](https://www.ray.io/), with optimizations like this Monte Carlo simulations become \"embarassingly parallel\" and, as a consequence, blazingly fast on multicore systems.\n",
                "\n",
                "We can now define the simulation scenario of a two-device $5 \\times 5$ MIMO simplex link transmitting an OFDM waveform over an ideal channel.\n",
                "Within a Monte Carlo simulation, we sweep the channel gain and observe the effect on the received signal power by our newly created Estimator:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {},
            "outputs": [],
            "source": [
                "from hermespy.core import ConsoleMode, dB\n",
                "from hermespy.modem import SimplexLink, ElementType, FrameElement, FrameResource, FrameSymbolSection, OFDMWaveform, SpatialMultiplexing\n",
                "from hermespy.simulation import Simulation, SimulatedIdealAntenna, SimulatedUniformArray\n",
                "\n",
                "\n",
                "# Create a new Monte Carlo simulation\n",
                "simulation = Simulation(console_mode=ConsoleMode.SILENT)\n",
                "\n",
                "# Configure a simplex link between a transmitting and receiving device, interconnected by an ideal channel\n",
                "link = SimplexLink(simulation.new_device(antennas=SimulatedUniformArray(SimulatedIdealAntenna, 1e-2, [5, 1, 1])),\n",
                "                   simulation.new_device(antennas=SimulatedUniformArray(SimulatedIdealAntenna, 1e-2, [5, 1, 1])))\n",
                "\n",
                "# Configure an OFDM waveform with a frame consisting of a single symbol section\n",
                "link.waveform = OFDMWaveform(resources=[FrameResource(elements=[FrameElement(ElementType.DATA, 1024)])],\n",
                "                                       structure=[FrameSymbolSection(pattern=[0])])\n",
                "link.precoding[0] = SpatialMultiplexing()\n",
                "\n",
                "# Configure a sweep over the linking channel's gain\n",
                "simulation.new_dimension('gain', dB(0, 2, 4, 6, 8, 10),\n",
                "                         simulation.scenario.channel(link.transmitting_device, link.receiving_device),\n",
                "                         title=\"Channel Gain\")\n",
                "\n",
                "# Configure our custom power evaluator\n",
                "power_estimator = PowerEstimator(link)\n",
                "simulation.add_evaluator(power_estimator)\n",
                "\n",
                "# Run the simulation\n",
                "result = simulation.run()"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "The simulation routine automatically distributes the workload to all detected CPU cores within the system (in this case $24$) and generates *PowerArtifact* objects in parallel.\n",
                "Once the simulation is finished, a single *PowerEvaluationResult* is generated and stored within a [MonteCarloResult](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.MonteCarloResult) returned by the simulation [run](../api/simulation.simulation.Simulation.rst#hermespy.simulation.simulation.Simulation.run) method.\n",
                "\n",
                "Calling the result's [plot](../api/core.monte_carlo.rst#hermespy.core.monte_carlo.MonteCarloResult.plot) method will then internally call the evaluation result's [plot](../api/core.visualize.rst#hermespy.core.visualize.Visualizable.plot), resulting in the following performance indicator visualization:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 640x480 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "_ = result.plot()\n",
                "plt.show()"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Now while this renders the average power over a number of samples within a simulation, the [Hardware Loop](../api/hardware_loop.rst) has a feature representing performance indicator information in real time during data collection.\n",
                "\n",
                "This is internally realized by calling the plot funtion of evaluations generated by evaluators, before they are being compressed to artifacts. \n",
                "We can demonstrate the output in our current simulation scenario by generating a single drop and calling the evaluator:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 640x480 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "_ = simulation.scenario.drop()\n",
                "\n",
                "power_estimator.evaluate().plot()\n",
                "plt.show()"
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3.9.13 ('hermes')",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.11.1"
        },
        "orig_nbformat": 4,
        "vscode": {
            "interpreter": {
                "hash": "15324ae639e283979e39f32b76ef84dde816ef5cb4e81fc04e688fd3d2128060"
            }
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}