example/random_request_network_mod.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Network with Applications\n",
    "\n",
    "In this file, we'll demonstrate the simulation of a more complicated network topology with randomized applications. These applications will act on each node, first choosing a random other node from the network and then requesting a random number of entangled pairs between the local and distant nodes. The network topology, including hardware components, is shown below:\n",
    "\n",
    "<img src=\"./notebook_images/star_network_mod.png\" width=\"1000\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example\n",
    "\n",
    "In this example, we construct the network described above and add the random request app included in SeQUeNCe. We'll be building the topology from an external json file `star_network.json`.\n",
    "\n",
    "### Imports\n",
    "We must first import the necessary tools from SeQUeNCe.\n",
    "- `Timeline` is the main simulation tool, providing an interface for the discrete-event simulation kernel.\n",
    "- `Topology` is a powerful class for creating and managing complex network topologies. We'll be using the `RouterNetTopo` subclass to build our network and intefrace with specific nodes and node types.\n",
    "- `RandomRequestApp` is an example application included with SeQUeNCe. We will investigate its behavior when we add applications to our network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from ipywidgets import interact\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sequence.kernel.timeline import Timeline\n",
    "from sequence.topology.router_net_topo import RouterNetTopo\n",
    "from sequence.app.random_request import RandomRequestApp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building the Simulation\n",
    "\n",
    "We'll now construct the network and add our applications. This example follows the usual process to ensure that all tools function properly:\n",
    "1. Create the topology instance for the simulation to manage our network\n",
    "    - This class will create a simulation timeline\n",
    "    - This instantiates the Simulation Kernel (see below)\n",
    "2. Create the simulated network topology. In this case, we are using an external JSON file to specify nodes and their connectivity.\n",
    "    - This includes specifying hardware parameters in the `set_parameters` function, defined later\n",
    "    - This instantiates the Hardware, Entanglement Management, Resource Management, and Network Management modules\n",
    "3. Install custom protocols/applications and ensure all are set up properly\n",
    "    - This instantiates the Application module\n",
    "4. Initialize and run the simulation\n",
    "5. Collect and display the desired metrics\n",
    "\n",
    "<img src=\"./notebook_images/sw_framework.png\" width=\"500\"/>\n",
    "\n",
    "The JSON file specifies that network nodes should be of type `QuantumRouter`, a node type defined by SeQUeNCe. This will automatically create all necessary hardware and protocol instances on the nodes, and the `Topology` class will automatically generate `BSMNode` instances on the quantum channels between such nodes.\n",
    "\n",
    "To construct an application, we need:\n",
    "- The node to attach the application to\n",
    "- The names (given as strings) of other possible nodes to generate links with\n",
    "- A seed for the internal random number generator of the application\n",
    "\n",
    "We can get a list of all desired application nodes, in this case routers, from the `Topology` class with the `get_nodes_by_type` method. We then set an application on each one, with the other possible connections being every other node in the network. We also give a unique random seed `i` to each application."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(sim_time, qc_atten):\n",
    "    \"\"\"\n",
    "    sim_time: duration of simulation time (ms)\n",
    "    qc_atten: quantum channel attenuation (dB/km)\n",
    "    \"\"\"\n",
    "    \n",
    "    network_config = \"star_network.json\"\n",
    "    \n",
    "    # here, we make a new topology using the configuration JSON file.\n",
    "    # we then modify some of the simulation parameters of the network.\n",
    "    network_topo = RouterNetTopo(network_config)\n",
    "    set_parameters(network_topo, sim_time, qc_atten)\n",
    "    \n",
    "    # construct random request applications\n",
    "    quantum_router_nodes = network_topo.get_nodes_by_type(RouterNetTopo.QUANTUM_ROUTER)\n",
    "    node_names = [node.name for node in quantum_router_nodes]\n",
    "    apps = []\n",
    "    for i, (name, node) in enumerate(zip(node_names, quantum_router_nodes)):\n",
    "        # copy node name list\n",
    "        other_nodes = node_names[:]\n",
    "        other_nodes.remove(name)\n",
    "        \n",
    "        # create our application\n",
    "        # arguments are:\n",
    "        #   the host node,\n",
    "        #   possible destination node names,\n",
    "        #   a seed for the random number generator, and\n",
    "        #   several arguments for request parameters.\n",
    "        app = RandomRequestApp(node, other_nodes, i,\n",
    "                               min_dur=1e13, max_dur=2e13, min_size=10,\n",
    "                               max_size=25, min_fidelity=0.8, max_fidelity=1.0)\n",
    "        apps.append(app)\n",
    "        app.start()\n",
    "        \n",
    "    # run the simulation\n",
    "    tl = network_topo.get_timeline()\n",
    "    tl.show_progress = True\n",
    "    tl.init()\n",
    "    tick = time.time()\n",
    "    tl.run()\n",
    "    print(\"execution time %.2f sec\" % (time.time() - tick))\n",
    "    \n",
    "    for app in apps:\n",
    "        print(\"node \" + app.node.name)\n",
    "        print(\"\\tnumber of wait times: \", len(app.get_wait_time()))\n",
    "        print(\"\\twait times:\", app.get_wait_time())\n",
    "        print(\"\\treservations: \", app.reserves)\n",
    "        print(\"\\tthroughput: \", app.get_throughput())\n",
    "    \n",
    "    print(\"\\nReservations Table:\\n\")\n",
    "    node_names = []\n",
    "    start_times = []\n",
    "    end_times = []\n",
    "    memory_sizes = []\n",
    "    for node in network_topo.get_nodes_by_type(RouterNetTopo.QUANTUM_ROUTER):\n",
    "        node_name = node.name\n",
    "        for reservation in node.network_manager.protocol_stack[1].accepted_reservation:\n",
    "            s_t, e_t, size = reservation.start_time, reservation.end_time, reservation.memory_size\n",
    "            if reservation.initiator != node.name and reservation.responder != node.name:\n",
    "                size *= 2\n",
    "            node_names.append(node_name)\n",
    "            start_times.append(s_t)\n",
    "            end_times.append(e_t)\n",
    "            memory_sizes.append(size)\n",
    "    log = {\"Node\": node_names, \"Start_time\": start_times, \"End_time\": end_times, \"Memory_size\": memory_sizes}\n",
    "    df = pd.DataFrame(log)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting parameters\n",
    "\n",
    "Here we define the `set_parameters` function we used earlier. This function will take a `Topology` as input and change many parameters to desired values.\n",
    "\n",
    "<img src=\"./notebook_images/Params.png\" width=\"700\"/>\n",
    "\n",
    "The simulation time limit will be set using the `get_timeline` method.\n",
    "\n",
    "Quantum memories and detectors are hardware elements, and so parameters are changed by accessing the hardware included with the `QuantumRouter` and `BSMNode` node types. Many complex hardware elements, such as bsm devices or memory arrays, have methods to update parameters for all included hardware elements. This includes `update_memory_params` to change all memories in an array or `update_detector_params` to change all detectors.\n",
    "\n",
    "We will also set the success probability and swapping degradation of the entanglement swapping protocol. This will be set in the Network management Module (specifically the reservation protocol), as this information is necessary to create and manage the rules for the Resource Management module.\n",
    "\n",
    "Lastly, we'll update some parameters of the quantum channels. Quantum channels (and, similarly, classical channels) can be accessed from the `Topology` class as the `qchannels` field. Since these are individual hardware elements, we will set the parameters directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_parameters(topology, simulation_time, attenuation):\n",
    "    \"\"\"\n",
    "    simulation_time: duration of simulation time (ms)\n",
    "    attenuation: attenuation on quantum channels (db/m)\n",
    "    \"\"\"\n",
    "    \n",
    "    PS_PER_MS = 1e9\n",
    "    \n",
    "    # set timeline stop time\n",
    "    topology.get_timeline().stop_time = (simulation_time * PS_PER_MS)\n",
    "    \n",
    "    # set memory parameters\n",
    "    MEMO_FREQ = 2e3\n",
    "    MEMO_EXPIRE = 0\n",
    "    MEMO_EFFICIENCY = 1\n",
    "    MEMO_FIDELITY = 0.9349367588934053\n",
    "    for node in topology.get_nodes_by_type(RouterNetTopo.QUANTUM_ROUTER):\n",
    "        memory_array = node.get_components_by_type(\"MemoryArray\")[0]\n",
    "        memory_array.update_memory_params(\"frequency\", MEMO_FREQ)\n",
    "        memory_array.update_memory_params(\"coherence_time\", MEMO_EXPIRE)\n",
    "        memory_array.update_memory_params(\"efficiency\", MEMO_EFFICIENCY)\n",
    "        memory_array.update_memory_params(\"raw_fidelity\", MEMO_FIDELITY)\n",
    "\n",
    "    # set detector parameters\n",
    "    DETECTOR_EFFICIENCY = 0.9\n",
    "    DETECTOR_COUNT_RATE = 5e7\n",
    "    DETECTOR_RESOLUTION = 100\n",
    "    for node in topology.get_nodes_by_type(RouterNetTopo.BSM_NODE):\n",
    "        bsm = node.get_components_by_type(\"SingleAtomBSM\")[0]\n",
    "        bsm.update_detectors_params(\"efficiency\", DETECTOR_EFFICIENCY)\n",
    "        bsm.update_detectors_params(\"count_rate\", DETECTOR_COUNT_RATE)\n",
    "        bsm.update_detectors_params(\"time_resolution\", DETECTOR_RESOLUTION)\n",
    "        \n",
    "    # set entanglement swapping parameters\n",
    "    SWAP_SUCC_PROB = 0.90\n",
    "    SWAP_DEGRADATION = 0.99\n",
    "    for node in topology.get_nodes_by_type(RouterNetTopo.QUANTUM_ROUTER):\n",
    "        node.network_manager.protocol_stack[1].set_swapping_success_rate(SWAP_SUCC_PROB)\n",
    "        node.network_manager.protocol_stack[1].set_swapping_degradation(SWAP_DEGRADATION)\n",
    "        \n",
    "    # set quantum channel parameters\n",
    "    ATTENUATION = attenuation\n",
    "    QC_FREQ = 1e11\n",
    "    for qc in topology.qchannels:\n",
    "        qc.attenuation = ATTENUATION\n",
    "        qc.frequency = QC_FREQ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running the Simulation\n",
    "\n",
    "All that is left is to run the simulation with user input. We'll specify:\n",
    "\n",
    "    sim_time: duration of simulation time (ms)\n",
    "    qc_atten: attenuation on quantum channels (db/m)\n",
    "\n",
    "Note that different hardware parameters or network topologies may cause the simulation to run for a very long time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "463491e8346844aab2859ed3dfee55ec",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=50000.0, description='sim_time', max=150000.0, min=-50000.0), Dropdown…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.test(sim_time, qc_atten)>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interact(test, sim_time=50e3, qc_atten=[0, 1e-5, 2e-5])"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}