docs/Intro.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import qm\n",
    "from entropylab import *\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "%config Completer.use_jedi = False\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\"> <font size=\"+5\"><u>Entropy: A lab workflow manager</u></font></div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entropy is a tool for managing your quantum workflow. It allows you to build complex experiments, coordinating lab instruments and arbitrary computational steps.\n",
    "\n",
    "It is built to solve three major problems: data collection, device management and calibration automation. This notebook introduces the basic concepts needed to start working with this tool. \n",
    "\n",
    "\n",
    "# The Experiment and Graph\n",
    "\n",
    "An experiment is a set of steps which may or may not be directly dependent on each other. You may want to run steps (or *not* run them) \n",
    "based on the result of a previous step. You may want to run steps using a result from a previous step. And you will almost always need to have \n",
    "access to the results each previous step had generated. \n",
    "\n",
    "This model is well described by a _Directed Acyclic Graph_ (DAG). _Directed_ means there is a direction to the flow of the graph, \n",
    "from root to leaves. _Acyclic_ means there shouldn't be closed loops in which you can get \"stuck\" when flowing through the graph.\n",
    "DAG based authoring of experiments is perhaps the defining feature of Entropy. \n",
    "\n",
    "A simple DAG is shown below. Each experimental stage can be placed in a separate node and nodes pass data to descendant nodes. This is marked as \"res\"\n",
    "on vertices in the image. Note how you can also set the node run order without passing data between nodes. For example, noded `b` and `d` have a vertex \n",
    "connecting them but no data is passed. \n",
    "\n",
    "![](DAG.svg)\n",
    "\n",
    "\n",
    "The data passed into, and out of nodes is automatically saved to the result handeling backend (see below). But we can also take advantage of the \n",
    "strucutre to do some pretty nifty things. A graph run can have branching logic (conditional execution of branches), can be parameterized and there can \n",
    "be more than one way to traverse a graph from one end to another. This last point is particularly important when you have a graph with one **target** node, \n",
    "including the algorithm you really want to run and many **calibration** nodes with the all the experimental prerequisites. Solving the problem of complex \n",
    "calibration is actually the first task we had in mind for this project. \n",
    "\n",
    "## Building your first graph\n",
    "\n",
    "The `PyNode` is the basic element in an Entropy grpah. It runs arbitrary python code defined in the `program` parameter. \n",
    "In the example below, the `program` is defined by the function `node_operation` which doesn't do anything but returns a dictionary with the key:value pair ```{`res`:1}```. \n",
    "Programs used in PyNodes must always return a dictionary. The node also has a name, set by `label` and defined the names of the variables it (optionally) passes on to other nodes. \n",
    "\n",
    "```python\n",
    "def node_operation():\n",
    "    return {'res':1}\n",
    "\n",
    "node1 = PyNode(label=\"first_node\", program=node_operation,output_vars={'res'})\n",
    "\n",
    "```\n",
    "\n",
    "You can now attache the node to a graph (containing just one node) \n",
    "\n",
    "```python\n",
    "experiment = Graph(resources=None, graph={node1}, story=\"run_a\") \n",
    "```\n",
    "\n",
    "There are some explanations in order here. You can see that this graph has the `resources` parameter set to `None`, but we have not defined resources yet. \n",
    "We also didn't say anything about the `story` associated with a graph. But let's ignore that for now. \n",
    "\n",
    "We can now run the graph, saving the results to `handle`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-05-09 18:57:20,103 - entropy - WARNING - Results of current execution None will be permanently lost on session close\n",
      "2021-05-09 18:57:20,107 - entropy - INFO - Running node <PyNode> first_node\n",
      "2021-05-09 18:57:20,109 - entropy - INFO - Finished entropy experiment execution successfully\n"
     ]
    }
   ],
   "source": [
    "def node_operation():\n",
    "    return {'res':1}\n",
    "\n",
    "node1 = PyNode(label=\"first_node\", program=node_operation,output_vars={'res'})\n",
    "experiment = Graph(resources=None, graph={node1}, story=\"run_a\") \n",
    "handle = experiment.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"What's with the `WARNING`?\" you may ask. Because we didn't define any `resources`, and we don't have a backend for result saving defined, Entropy warns us we will not have any persistance (nothing will be saved for posterity). \n",
    "We will address this issue soon. Regardless, while in the python session, we can access the (wholly unspectacular) experiment results as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "handle.results.get_results_from_node(\"first_node\")[0].results[0].data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see the returned result is what was returned by `node_operation`. There is clearly some strucutre here: results are returned in a list, \n",
    "that list is made of a certain type of object and so on. We will go into more detail later but will gloss over this for now. \n",
    "\n",
    "To view the graph, you need to have `graphviz` installed ([installation guide](https://graphviz.org/download/)). If it's properly installed on your environment, you can view the graph as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\r\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\r\n",
       "<!-- Generated by graphviz version 2.47.1 (20210417.1919)\r\n",
       " -->\r\n",
       "<!-- Pages: 1 -->\r\n",
       "<svg width=\"82pt\" height=\"44pt\"\r\n",
       " viewBox=\"0.00 0.00 82.00 44.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 40)\">\r\n",
       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-40 78,-40 78,4 -4,4\"/>\r\n",
       "<!-- first_node -->\r\n",
       "<g id=\"node1\" class=\"node\">\r\n",
       "<title>first_node</title>\r\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"74,-36 0,-36 0,0 74,0 74,-36\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"37\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">first_node</text>\r\n",
       "</g>\r\n",
       "</g>\r\n",
       "</svg>\r\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x1c797388ac0>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "handle.dot_graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If not, you can use a textual representation of the graph. This is called `dot` notation and is a standard way to serialize a graph. To access the dot representation, run the following commnad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "digraph {\n",
      "\tfirst_node [shape=box]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "print(str(handle.dot_graph()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This string can then be pasted in a service such as [GraphVizOnline](https://dreampuf.github.io/GraphvizOnline/) or [Edotor](https://edotor.net/) to get the graphical representation. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A graph with two nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a graph with a single node is hardly a graph, here's an example containing two nodes which pass a result between them. \n",
    "\n",
    "For simpliciy, both nodes are running the same operation (same `node_operation` as before)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-05-09 18:57:47,153 - entropy - WARNING - Results of current execution None will be permanently lost on session close\n",
      "2021-05-09 18:57:47,155 - entropy - INFO - Running node <PyNode> first_node\n",
      "2021-05-09 18:57:47,156 - entropy - INFO - Running node <PyNode> first_node\n",
      "2021-05-09 18:57:47,158 - entropy - INFO - Finished entropy experiment execution successfully\n"
     ]
    },
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\r\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\r\n",
       "<!-- Generated by graphviz version 2.47.1 (20210417.1919)\r\n",
       " -->\r\n",
       "<!-- Pages: 1 -->\r\n",
       "<svg width=\"223pt\" height=\"44pt\"\r\n",
       " viewBox=\"0.00 0.00 223.00 44.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 40)\">\r\n",
       "<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-40 219,-40 219,4 -4,4\"/>\r\n",
       "<!-- first_node -->\r\n",
       "<g id=\"node1\" class=\"node\">\r\n",
       "<title>first_node</title>\r\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"74,-36 0,-36 0,0 74,0 74,-36\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"37\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">first_node</text>\r\n",
       "</g>\r\n",
       "<!-- first_node_2 -->\r\n",
       "<g id=\"node2\" class=\"node\">\r\n",
       "<title>first_node_2</title>\r\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"215,-36 127,-36 127,0 215,0 215,-36\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"171\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">first_node_2</text>\r\n",
       "</g>\r\n",
       "<!-- first_node&#45;&gt;first_node_2 -->\r\n",
       "<g id=\"edge1\" class=\"edge\">\r\n",
       "<title>first_node&#45;&gt;first_node_2</title>\r\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M74.07,-18C87.21,-18 102.37,-18 116.69,-18\"/>\r\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"116.94,-21.5 126.94,-18 116.94,-14.5 116.94,-21.5\"/>\r\n",
       "<text text-anchor=\"middle\" x=\"100.5\" y=\"-21.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">res</text>\r\n",
       "</g>\r\n",
       "</g>\r\n",
       "</svg>\r\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x1c7f4e913a0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "node1 = PyNode(label=\"first_node\", program=node_operation,output_vars={'res'})\n",
    "node2 = PyNode(label=\"first_node\", program=node_operation,output_vars={'res'},input_vars={'ina':node1.outputs['res']})\n",
    "experiment = Graph(resources=None, graph={node1,node2}, story=\"run_a\") \n",
    "handle = experiment.run()\n",
    "graph=handle.dot_graph()\n",
    "graph.graph_attr['rankdir'] = 'LR'\n",
    "graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By inspecting the results object, we can see we have two `ResultRecord`s coming from each of the nodes, and an additional one which is automatically added. The additional record is the result of the final node and it is always included. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ResultRecord(experiment_id=1620575867155736600, id=0, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=1620575867155736600, id=1, label='res', story=None, stage=1, data=1),\n",
       " ResultRecord(experiment_id=1620575867155736600, id=2, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1})]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "handle.results.get_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results in Entropy: Setting up a DB\n",
    "\n",
    "Collecting and arranging experimental data is a difficult task. It's often managed in files and folders with some structure\n",
    "users agree upon, but in many cases that is not enforced. To solve this problem we provide a way to automate data saving\n",
    "as an integral part of structuring the experimental sequence. Each node can save the data you specify, but also saves additional \n",
    "data on its own. \n",
    "\n",
    "The data saving backend is flexible, we will provide several backends starting with a SQLite DB but later extending to other targets.\n",
    "The first backend we intend to target after SQLite is HDF5. \n",
    "\n",
    "Below we set up a DB saved to a file. In the cell below we first make sure that file doesn't exist and then start an instance of a DB backend. \n",
    "`SqlAlchemyDB` is the specific implementaion we currently provide and it generates a SQLite file. SQLite is an easy choice: it doesn't require any \n",
    "difficult setup, essentially it's just a file that lives on your file system. If you want, you can use common DB tools (e.g. [DBeaver](https://dbeaver.io/)) to view the \n",
    "structure of this file. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "db_file='docs_cache/tutorial.db'\n",
    "if os.path.exists(db_file):\n",
    "  os.remove(db_file)\n",
    "db = SqlAlchemyDB(db_file)\n",
    "\n",
    "experiment_resources = ExperimentResources(db)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-05-09 18:58:13,827 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:13,884 - entropy - INFO - Finished entropy experiment execution successfully\n"
     ]
    }
   ],
   "source": [
    "node1 = PyNode(\"node_with_DB\", node_operation,output_vars={'res'})\n",
    "experiment_with_db = Graph(resources=experiment_resources, graph={node1},story=\"run with DB\")\n",
    "handle2 = experiment_with_db.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you now try to observe the saved results, what do you expect to see? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ResultRecord(experiment_id=1, id=1, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=1, id=2, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1})]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "handle2.results.get_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only the results of the last run are here. Even if you run this experiments a few more times, you will only see the last run. \n",
    "\n",
    "This is a bit disappointing as we promised persistance. So, what gives? \n",
    "\n",
    "Well, the `handle` is just for a specific experimental run so it makes sense you only see the results of _that run_. To see everything in the database you can query it directly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ResultRecord(experiment_id=1, id=1, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=1, id=2, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1})]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.get_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And if we run the experiment a few more times, see how the DB is populated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-05-09 18:58:24,634 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:24,709 - entropy - INFO - Finished entropy experiment execution successfully\n",
      "2021-05-09 18:58:24,725 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:24,799 - entropy - INFO - Finished entropy experiment execution successfully\n",
      "2021-05-09 18:58:24,820 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:24,872 - entropy - INFO - Finished entropy experiment execution successfully\n",
      "2021-05-09 18:58:24,886 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:24,928 - entropy - INFO - Finished entropy experiment execution successfully\n",
      "2021-05-09 18:58:24,942 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:24,988 - entropy - INFO - Finished entropy experiment execution successfully\n",
      "2021-05-09 18:58:25,000 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:25,049 - entropy - INFO - Finished entropy experiment execution successfully\n",
      "2021-05-09 18:58:25,061 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:25,108 - entropy - INFO - Finished entropy experiment execution successfully\n",
      "2021-05-09 18:58:25,120 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:25,163 - entropy - INFO - Finished entropy experiment execution successfully\n",
      "2021-05-09 18:58:25,174 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:25,221 - entropy - INFO - Finished entropy experiment execution successfully\n",
      "2021-05-09 18:58:25,234 - entropy - INFO - Running node <PyNode> node_with_DB\n",
      "2021-05-09 18:58:25,280 - entropy - INFO - Finished entropy experiment execution successfully\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[ResultRecord(experiment_id=1, id=1, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=1, id=2, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=2, id=3, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=2, id=4, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=3, id=5, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=3, id=6, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=4, id=7, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=4, id=8, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=5, id=9, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=5, id=10, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=6, id=11, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=6, id=12, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=7, id=13, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=7, id=14, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=8, id=15, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=8, id=16, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=9, id=17, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=9, id=18, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=10, id=19, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=10, id=20, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1}),\n",
       " ResultRecord(experiment_id=11, id=21, label='res', story=None, stage=0, data=1),\n",
       " ResultRecord(experiment_id=11, id=22, label='experiment_result', story='Final output of the experiment', stage=-1, data={'res': 1})]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[experiment_with_db.run() for ind in range(10)]\n",
    "db.get_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Entropy Environment\n",
    "\n",
    "By \"device management\" what is meant is more than just the set of all instruments you use in the lab. A _device_ in this\n",
    "context can be many things. For example, it could be some calculation that is run on a remote compute resource, it may\n",
    "be the object representing a web-based GUI you are working with or, indeed, it can be your DC voltage source. Sharing these\n",
    "resources between nodes in Entropy is easy. The nodes in an Entropy graph have access to resources automatically, and \n",
    "there is a centralized store in which you can register the resources that are always present in the lab or temporary resources\n",
    "which only exist for a specific run of an experiment. \n",
    "\n",
    "## Lab and Experiment Resoruces\n",
    "\n",
    "The mental image you need to keep to understand resources management in Entropy is as follows: Resources belong to a lab and persist in the DB. Every time we set up an experiment, we can use a \n",
    "lab resource by importing it. \n",
    "\n",
    "As an example, we first build a class representing some device, say an oscilloscope. \n",
    "\n",
    "```python\n",
    "class my_scope:\n",
    "    def __init__(self,name, ip):\n",
    "        self.name=name\n",
    "        self.ip=ip      \n",
    "```\n",
    "\n",
    "Typically you would start from an existing driver you already have, or a contributed one.\n",
    "You can use exising drivers from the QCodes library using our wrapper class, more details on this in seperate tutorial.\n",
    "\n",
    "We start our example by deleting our DB file from before and setting up a new lab. \n",
    "\n",
    "Warning: This is destructive to any work we've done so far so if you want to keep the existing DB please copy the file over. \n",
    "\n",
    "Note that setting up a lab is only done once under normal circumstances. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "db_file='docs_cache/tutorial.db'\n",
    "if os.path.exists(db_file):\n",
    "  os.remove(db_file)\n",
    "db = SqlAlchemyDB(db_file)\n",
    "lab = LabResources(db)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Registering resources\n",
    "\n",
    "We can now **register** our resources (our oscilloscope) to the lab. The act of registration adds a resource to the ones available to us in the lab. \n",
    "\n",
    "There are many options here we will go into in later tutorials but for now, we can point out just a few. The `register_resource` method takes a `resource_class` argument, note that this is the **name** of the class and not an instance. There are then `args` and `kwargs` we pass, which are the _positional_ arguments passed to the constructor of our resource and the _keyword_ (named) arguments we pass. We don't have do use both, we can use just one or the other or (as in the example below) a combination of both. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-05-09 22:13:20,016 - entropy - WARNING - instrument my_scope is not an entropylab Resource and additional metadata won't be saved\n",
      "2021-05-09 22:13:20,017 - entropy - WARNING - could not save source of my_scope\n"
     ]
    }
   ],
   "source": [
    "class my_scope:\n",
    "    def __init__(self,name, ip):\n",
    "        self.name=name\n",
    "        self.ip=ip      \n",
    "    def identify(self):\n",
    "        print(f'This is scope:{self.name}')\n",
    "\n",
    "lab.register_resource(name=\"my_scope\", resource_class=my_scope,args=[\"gals scope\"],kwargs={'ip':0})\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you now try to run the cell from above again, this will fail. Why is that? Because you are trying to register an existing device to the DB. \n",
    "The `LabResources` API supports adding and removing resources from the lab and this failing behaviour is intentional. It is meant to help preventing an accidental overwrite of a device.\n",
    "\n",
    "### Running an experiment with a resource \n",
    "\n",
    "Let's now run an experiment the uses a registered resource. We need to start an `experiment_resource` instance (and specify the db to which it writes), and then import the resource we want to use from the lab. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-05-09 22:49:55,134 - entropy - INFO - Running node <PyNode> first_node\n",
      "This is scope:gals scope\n",
      "2021-05-09 22:49:55,205 - entropy - INFO - Finished entropy experiment execution successfully\n"
     ]
    }
   ],
   "source": [
    "experiment_resources = ExperimentResources(db)\n",
    "experiment_resources.import_lab_resource('my_scope')\n",
    "\n",
    "def node_action_with_scope(context: EntropyContext):\n",
    "   \n",
    "    scp=context.get_resource(\"my_scope\")\n",
    "    scp.identify()\n",
    "    return {\"a_out\": 10}\n",
    "\n",
    "node1 = PyNode(\"first_node\", node_action_with_scope,output_vars={'a_out'})\n",
    "experiment_with_instrument = Graph(experiment_resources, {node1}, \"run_a\") #No resources used here\n",
    "handle_with_instrument = experiment_with_instrument.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see the `identify` method was called as expected. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Entropy with QUA\n",
    "\n",
    "Entropy is developed to be a general purpose lab manager. It is however developed primarily by [Quantum Machines](www.quantum-machines.co), creators of the Quantum Orchastration Platform and the QUA programming language. \n",
    "\n",
    "Support of QUA is going to be extended in coming versions, primarily via Entropy extensions. However, you can already run QUA code by using the general purpose PyNode.\n",
    "This is shown in the following basic exmaple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#first we delete the DB file again\n",
    "db_file='docs_cache/tutorial.db'\n",
    "if os.path.exists(db_file):\n",
    "  os.remove(db_file)\n",
    "db = SqlAlchemyDB(db_file)\n",
    "lab = LabResources(db)\n",
    "\n",
    "#we now import the QUA package\n",
    "from qm.QuantumMachinesManager import QuantumMachinesManager\n",
    "from qm.qua import *\n",
    "from qm import SimulationConfig\n",
    "\n",
    "#now register the quntum machines mnager and import it to the experiment resources\n",
    "lab.register_resource('qmm',QuantumMachinesManager)\n",
    "experiment_resources = ExperimentResources(db)\n",
    "experiment_resources.import_lab_resource('qmm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After some intro house keeping, we set up a two-node graph. A first node to generate the config and pass it on, and a second node to run the QUA code. \n",
    "We write the operation of these two PyNodes in the two following functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_config():\n",
    "    config = {\n",
    "        \"version\": 1,\n",
    "        \"controllers\": {\n",
    "            \"con1\": {\n",
    "                \"type\": \"opx1\",\n",
    "                \"analog_outputs\": {\n",
    "                    1: {\"offset\": +0.0},\n",
    "                },\n",
    "            }\n",
    "        },\n",
    "        \"elements\": {\n",
    "            \"qe1\": {\n",
    "                \"singleInput\": {\"port\": (\"con1\", 1)},\n",
    "                \"intermediate_frequency\": 5e6,\n",
    "                \"operations\": {\n",
    "                    \"playOp\": \"constPulse\",\n",
    "                },\n",
    "            },\n",
    "        },\n",
    "        \"pulses\": {\n",
    "            \"constPulse\": {\n",
    "                \"operation\": \"control\",\n",
    "                \"length\": 1000,  # in ns\n",
    "                \"waveforms\": {\"single\": \"const_wf\"},\n",
    "            },\n",
    "        },\n",
    "        \"waveforms\": {\n",
    "            \"const_wf\": {\"type\": \"constant\", \"sample\": 0.2},\n",
    "        },\n",
    "    }\n",
    "\n",
    "    return {'config': config}\n",
    "\n",
    "\n",
    "def QUA_node_action(context: EntropyContext,config):\n",
    "    qmm = context.get_resource('qmm')\n",
    "    QM1 = qmm.open_qm(config)\n",
    "    with program() as prog:\n",
    "        play(\"playOp\", \"qe1\")\n",
    "    job = QM1.simulate(prog, SimulationConfig(int(1000)))  \n",
    "    samples = job.get_simulated_samples()\n",
    "    samples1 = samples.con1.analog['1']\n",
    "    return {\"samples\": samples1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can set up the nodes and graph and run our experiment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-05-09 23:47:03,095 - qm - INFO - Performing health check\n",
      "2021-05-09 23:47:03,103 - qm - INFO - Health check passed\n",
      "2021-05-09 23:47:03,122 - entropy - INFO - Running node <PyNode> config_node\n",
      "2021-05-09 23:47:03,167 - entropy - INFO - Running node <PyNode> QUA_node\n",
      "2021-05-09 23:47:03,218 - qm - INFO - to simulate a program, use QuantumMachinesManager.simulate(..)\n",
      "2021-05-09 23:47:03,246 - qm - INFO - Flags: \n",
      "2021-05-09 23:47:03,248 - qm - INFO - Simulating Qua program\n",
      "2021-05-09 23:47:03,502 - entropy - INFO - Finished entropy experiment execution successfully\n"
     ]
    }
   ],
   "source": [
    "config_node = PyNode(\"config_node\", get_config,output_vars={'config'})\n",
    "qua_node = PyNode(\"QUA_node\", QUA_node_action,input_vars={'config':config_node.outputs['config']},output_vars={'samples'})\n",
    "experiment_with_QUA = Graph(experiment_resources, {config_node,qua_node}, \"a QUA run\")\n",
    "handle_with_QUA = experiment_with_QUA.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can plot the result we obtained from running our experiment. Graph generation will be the first this the next Entropy version will automate. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(handle_with_QUA.results.get_results()[1].data)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Entropy",
   "language": "python",
   "name": "entropy"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}