compile.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neutral Atom Mapper Visualizer\n",
    "\n",
    "## Generation of CSV File\n",
    "\n",
    "First, a CSV file is generated that defines the location of every atom at each time step. Additionally, different colors and sizes of atoms can be used to depict the application of various quantum operations.\n",
    "\n",
    "### Input\n",
    "Takes a description of a circuit compiled for the neutral atoms platform. The input must follow the following format:\n",
    "- Line comments start with `#`, those lines are ignored during parsing.\n",
    "- Every line is terminated with a `;`\n",
    "- allowed keywords are `init`, `move`, `load`, `store`, `ry`, `rz`, `cz`\n",
    "    - theres is one keyword per line and the line starts with the keyword\n",
    "    - `init` must not follow after any other keyword\n",
    "    - the keywords `ry` and `rz` receive a parameter, e.g. `ry(pi/2)`\n",
    "    - the keywords `init` and `rz` are followed by a sequence of pairs of natural numbers defining the coordinates of atoms, e.g. `init (6, 24) (12, 24)` means that one atom is placed at $(6,24)$ and one at $(12,24)$. Here, the unit µm is assumed. \n",
    "    - for a `load`, `store`, and `move` the syntax is, e.g., `move (1, 2) (3, 4) to (1, 3) (3, 5)`. This moves both atoms 1µm upwards.\n",
    "\n",
    "### Output (for gganimate)\n",
    "A CSV file containing the position of every atom at each point in time. The file has the following format\n",
    "\n",
    " time | id | x | y | size | fill | color | axes | axesId | margin | marginId\n",
    "---|---|---|---|---|---|---|---|---|---|---\n",
    " 0.000 | 0 | 0 | 56 | 1 | 0 | 0 | 0 | 0 | 0 | 0\n",
    " 0.000 | 1 | 5 | 56 | 1 | 0 | 0 | 0 | 0 | 0 | 0\n",
    " 0.000 | 2 | 10 | 56 | 1 | 0 | 0 | 0 | 0 | 0 | 0\n",
    " 0.000 | 3 | 0 | 61 | 1 | 0 | 0 | 0 | 0 | 0 | 0\n",
    " 0.000 | 4 | 5 | 61 | 1 | 0 | 0 | 0 | 0 | 0 | 0\n",
    " 0.000 | 5 | 10 | 61 | 1 | 0 | 0 | 0 | 0 | 0 | 0\n",
    " ... | ... | ... | ... | ... | . ... | ... | ... | ... | ... | ...\n",
    "\n",
    "Explanation\n",
    "- `time`: The time when the object (atom) should have the new location/appearance\n",
    "- `id`: The id of the object (atom). This is required such that when objects move, the animation knows which objects belong to each other and can interpolate their movement.\n",
    "- `x`: The x-coordinate of the object (at that time).\n",
    "- `y`: The y-coordinate of the object (at that time).\n",
    "- `size`: The size of the object (at that time). This value will be rescaled to a fixed interval.\n",
    "- `fill`: The color of the object (at that time).\n",
    "- `color`: The color of the border of the object (at that time). If it is the same as `fill` the border will seem to disappear.\n",
    "- `axes`: 0 or 1 whether x- and y-axes through the object should be shown.\n",
    "- `axesId`: When axes should disappear again and later reappear for the same object, they have to have another id. Increment this value for an object each time after its axes disappeared/or when they reappear.\n",
    "- `margin`: 0 or 1 whether a margin in red should be drawn around an object.\n",
    "- `marginId`: Same as axesId, just for dis-/appearing margins.\n",
    "\n",
    "### Output (for Plotly)\n",
    "\n",
    "> TODO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from re import match, search  # use of regex for parsing input\n",
    "from math import sqrt  # square root\n",
    "import pandas as pd\n",
    "from json import load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ParseError(Exception):\n",
    "    '''\n",
    "    Custom Exception that is raised when a parsing error occurs,\n",
    "    e.g. due to an syntax error.\n",
    "    '''\n",
    "    def __init__(self, msg):\n",
    "        super().__init__(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here you can specify which configs should be used for the animation. Use the same as the circuit was generated with. The last option allows to either have durations of the operations based on their actual time or if false, every operation takes the same amount of time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "INPUT_FILE = 'circuit.na'\n",
    "LAYOUT_FILE = 'config/huge.csv'\n",
    "ARCHITECTURE_FILE = 'config/huge.json'\n",
    "REALTIME = False  # True: the real durations of the operations are used; False: one operations is one time step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell reads the circuit description from 'circuit.na' and produces the CSV file described above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check whether the layout file has the required format, otherwise transform it\n",
    "with open(LAYOUT_FILE, 'r') as f:\n",
    "    header = f.readline()\n",
    "    if not match(r'x;y;size;color', header):\n",
    "        transformed = 'x;y;size;color\\n'\n",
    "        with open(ARCHITECTURE_FILE, 'r') as a:\n",
    "            arch = load(a)\n",
    "        while True:\n",
    "            line = f.readline()\n",
    "            if not line:\n",
    "                break\n",
    "            x, y = map(int, line.split(','))\n",
    "            zone = 0\n",
    "            for z in arch['zones']:\n",
    "                if x >= z['xmin'] and x <= z['xmax'] and y >= z['ymin'] and y <= z['ymax']:\n",
    "                    break\n",
    "                zone += 1\n",
    "            try:\n",
    "                transformed += f\"{x};{y};1;{zone}\\n\"\n",
    "            except NameError:\n",
    "                raise ParseError(f'Unknown zone for coordinates {x}, {y}')\n",
    "            else:\n",
    "                del zone\n",
    "\n",
    "try:\n",
    "    transformed\n",
    "    with open(LAYOUT_FILE, 'w') as f:\n",
    "        f.write(transformed)\n",
    "except NameError:\n",
    "    pass\n",
    "else:\n",
    "    del transformed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "arch = load(open(ARCHITECTURE_FILE, 'r'))\n",
    "def duration_of(operation, dist = None):\n",
    "    '''\n",
    "    `duration_of` returns the duration of an operation in microseconds if `REALTIME` is set to `True`,\n",
    "    otherwise it returns always 1000 microseconds.\n",
    "    '''\n",
    "    if REALTIME:\n",
    "        if operation in [op['name'] for op in arch['operations']]:\n",
    "            return int(next(op['time'] for op in arch['operations'] if op['name'] == operation) * 1000)\n",
    "        elif operation == 'load':\n",
    "            return int(arch['shuttling'][0]['load']['time'] * 1000)\n",
    "        elif operation == 'store':\n",
    "            return int(arch['shuttling'][0]['store']['time'] * 1000)\n",
    "        elif operation == 'move':\n",
    "            if dist is None:\n",
    "                raise ValueError('Distance not provided')\n",
    "            return int(dist * arch['shuttling'][0]['move']['speed'] * 1000)\n",
    "        else:\n",
    "            raise ValueError('Operation not found')\n",
    "    else:\n",
    "        return 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Output for gganimate\n",
    "\n",
    "The following cell produces the output that can be fed into the `animate.R` script.\n",
    "\n",
    "To produce the animation with the R script, change to the script (You do not need any of the cells below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "program = {}        # acontains the data at every timestep for each atom, i.e., is of type\n",
    "                    # `dict[int, dict[int, tuple[int, int, int, int, int, int, int, int, int, int, int]]]`\n",
    "                    # where the inner dict has the atom id as key and a tuple with the following values:\n",
    "                    # (x, y, size, fill, color, axes, axesId, margin, marginId)\n",
    "init = True         # true iff no other keyword except init occurred yet\n",
    "pos2atoms = {}      # a mapping from position to atom id, i.e., it is of type `dict[int, dict[int, int]]`\n",
    "atoms2pos = []      # a list that maps atom ids to positions (tuples of ints), i.e., it is of type `list[tuple[int, int]]`\n",
    "shuttling = set()   # a set of atom ids that are currently being shuttled\n",
    "atoms_n = 0         # number of atoms, used to determine the id of an atom\n",
    "lineno = 1          # linenumber in the input file (comments are ignored)\n",
    "time = 0            # [ns] nanoseconds to be able to have store it as int\n",
    "aodCycle = 0        # aod cycle\n",
    "rydbergBeam = 0     # rydberg beam\n",
    "\n",
    "\n",
    "def add_atom(x, y):\n",
    "    '''\n",
    "    `add_atom` adds an atom at position `(x, y)` to the data-structures `pos2atoms` and `atoms2pos`.\n",
    "    '''\n",
    "    global atoms_n, pos2atoms, atoms2pos\n",
    "    if x not in pos2atoms:\n",
    "        pos2atoms[x] = {}\n",
    "    id = atoms_n\n",
    "    pos2atoms[x][y] = id\n",
    "    atoms2pos.append((x, y))\n",
    "    atoms_n += 1\n",
    "    return id\n",
    "\n",
    "\n",
    "def append_program(t, id, x, y, size, fill, color, axes, axesId, margin, marginId, overwrite = False):\n",
    "    '''\n",
    "    `append_program` appends the data of an atom to the program data-structure.\n",
    "    '''\n",
    "    global program\n",
    "    if t not in program:\n",
    "        program[t] = {}\n",
    "    if overwrite or id not in program[t]:\n",
    "        program[t][id] = (x, y, size, fill, color, axes, axesId, margin, marginId)\n",
    "\n",
    "\n",
    "def update_positions(old, new):\n",
    "    '''\n",
    "    `update_positions` updates the positions of the atoms in the data-structures `pos2atoms` and `atoms2pos`.\n",
    "    '''\n",
    "    global pos2atoms, atoms2pos\n",
    "    for pos_old, pos_new in zip(old, new):\n",
    "        x_old, y_old = pos_old\n",
    "        x_new, y_new = pos_new\n",
    "        atoms2pos[pos2atoms[x_old][y_old]] = (x_new, y_new)\n",
    "    pos2atoms.clear()\n",
    "    for i, p in enumerate(atoms2pos):\n",
    "        x, y = p\n",
    "        if x not in pos2atoms: pos2atoms[x] = {}\n",
    "        pos2atoms[x][y] = i\n",
    "\n",
    "\n",
    "with open(INPUT_FILE, \"r\") as src: # open the output file\n",
    "    while True:\n",
    "        line = src.readline().rstrip()  # readline and remove trailing whitespace characters\n",
    "        if line == \"\": # end of input reach, jump out of loop\n",
    "            break\n",
    "        elif match(r\"^#.*$\", line): # comments are ignored\n",
    "            continue\n",
    "        elif match(r\"^init at (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # init\n",
    "            if not init:\n",
    "                raise ParseError(f\"The keyword init occurred after another operation in line {lineno}: {line}\")\n",
    "            # parse the coordinates of the atoms to initialize\n",
    "            exec(\"coords = [\" + search(r\"^init at (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "            for x, y in coords:\n",
    "                id = add_atom(x, y)\n",
    "                append_program(time, id, x, y, 1, 0, 0, 0, 0, 0, 0)\n",
    "        else:\n",
    "            if init:\n",
    "                init = False\n",
    "            affected = set()            # a set of atom ids that are affected by the current operation\n",
    "                                        # this is required in the last step to write out all atoms that have not been affected\n",
    "            shuttleOperation = False    # true iff the current operation is a shuttle operation\n",
    "            try:\n",
    "                if match(r\"^ry\\(.+\\);$\", line): # ry (color: 2, size: 2)\n",
    "                    d = duration_of('ry')\n",
    "                    for k, p in enumerate(atoms2pos): # ry is global and affects all atoms\n",
    "                        x, y = p\n",
    "                        affected.add(k)\n",
    "                        # the operation has a certain duration. The atom is supposed to \"light up\" during that duration.\n",
    "                        # The style is interpolated (tweened) between the different time steps given for that certain\n",
    "                        # atom. To achieve the correct appearance, we insert a standard (not activated) style at the\n",
    "                        # beginning and at the end of the operation, the actual highlighting is assigned to a time step\n",
    "                        # in the middle of the duration.\n",
    "                        append_program(time, k, x, y, 1, 1 if k in shuttling else 0, 1 if k in shuttling else 0, 1 if k in shuttling else 0, aodCycle, 0, 0)\n",
    "                        append_program(time + d // 2, k, x, y, 2, 2, 2, 1 if k in shuttling else 0, aodCycle, 0, 0)\n",
    "                        append_program(time + d, k, x, y, 1, 1 if k in shuttling else 0, 1 if k in shuttling else 0, 1 if k in shuttling else 0, aodCycle, 0, 0)\n",
    "                elif match(r\"^rz\\(.+\\) at (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # rz (color: 3, size: 2)\n",
    "                    exec(\"coords = [\" + search(r\"^rz\\(.+\\) at (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "                    d = duration_of('rz')\n",
    "                    for x, y in coords: # rz is local and affects only the atoms at the given positions\n",
    "                        k = pos2atoms[x][y]\n",
    "                        affected.add(k)\n",
    "                        # for an explanation of the three steps, see above the ry operation\n",
    "                        append_program(time, k, x, y, 1, 1 if k in shuttling else 0, 1 if k in shuttling else 0, 1 if k in shuttling else 0, aodCycle, 0, 0)\n",
    "                        append_program(time + d // 2, k, x, y, 2, 3, 3, 1 if k in shuttling else 0, aodCycle, 0, 0)\n",
    "                        append_program(time + d, k, x, y, 1, 1 if k in shuttling else 0, 1 if k in shuttling else 0, 1 if k in shuttling else 0, aodCycle, 0, 0)\n",
    "                elif match(r\"^cz;$\", line): # cz (color: 4, size: 3)\n",
    "                    d = duration_of('cz')\n",
    "                    # go through all pairs of atoms and check whether they are in the interaction radius of another atom\n",
    "                    for k1, p1 in enumerate(atoms2pos):\n",
    "                        x1, y1 = p1\n",
    "                        for k2, p2 in enumerate(atoms2pos[:k1]):\n",
    "                            x2, y2 = p2\n",
    "                            if sqrt((x1 - x2)**2 + (y1 - y2)**2) <= 2:  # interaction radius is assumed to be 2\n",
    "                                affected.add(k1)\n",
    "                                affected.add(k2)\n",
    "                                # for an explanation of the three steps, see above the ry operation\n",
    "                                append_program(time, k1, x1, y1, 1, 1 if k1 in shuttling else 0, 1 if k1 in shuttling else 0, 1 if k1 in shuttling else 0, aodCycle, 0, 0)\n",
    "                                append_program(time, k2, x2, y2, 1, 1 if k2 in shuttling else 0, 1 if k2 in shuttling else 0, 1 if k2 in shuttling else 0, aodCycle, 0, 0)\n",
    "\n",
    "                                append_program(time + d // 2, k1, x1, y1, 3, 4, 5, 1 if k1 in shuttling else 0, aodCycle, 1, rydbergBeam)\n",
    "                                append_program(time + d // 2, k2, x2, y2, 3, 4, 5, 1 if k2 in shuttling else 0, aodCycle, 1, rydbergBeam)\n",
    "\n",
    "                                append_program(time + d, k1, x1, y1, 1, 1 if k1 in shuttling else 0, 1 if k1 in shuttling else 0, 1 if k1 in shuttling else 0, aodCycle, 0, 0)\n",
    "                                append_program(time + d, k2, x2, y2, 1, 1 if k2 in shuttling else 0, 1 if k2 in shuttling else 0, 1 if k2 in shuttling else 0, aodCycle, 0, 0)\n",
    "                    rydbergBeam += 1\n",
    "                elif match(r\"^load (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # move\n",
    "                    exec(\"start = [\" + search(r\"^load (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "                    exec(\"end = [\" + search(r\"^load (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(3) + \"]\")\n",
    "                    shuttleOperation = True\n",
    "                    d = duration_of('load')\n",
    "                    for old, new in zip(start, end):\n",
    "                        x_old, y_old = old\n",
    "                        x_new, y_new = new\n",
    "                        k = pos2atoms[x_old][y_old]\n",
    "                        affected.add(k)\n",
    "                        shuttling.add(k)\n",
    "\n",
    "                        append_program(time, k, x_old, y_old, 1, 0, 0, 1, aodCycle, 0, 0, overwrite = True)\n",
    "                        append_program(time + d, k, x_new, y_new, 1, 1, 1, 1, aodCycle, 0, 0)\n",
    "\n",
    "                    update_positions(start, end)\n",
    "                elif match(r\"^move (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # move\n",
    "                    exec(\"start = [\" + search(r\"^move (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "                    exec(\"end = [\" + search(r\"^move (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(3) + \"]\")\n",
    "                    shuttleOperation = True\n",
    "                    d = duration_of('move', max(sqrt(float(old[0] - new[0])**2 + float(old[1] - new[1])**2) for old, new in zip(start, end)))\n",
    "                    for old, new in zip(start, end):\n",
    "                        x_old, y_old = old\n",
    "                        x_new, y_new = new\n",
    "                        k = pos2atoms[x_old][y_old]\n",
    "                        affected.add(k)\n",
    "\n",
    "                        append_program(time, k, x_old, y_old, 1, 1, 1, 1, aodCycle, 0, 0)\n",
    "                        append_program(time + d, k, x_new, y_new, 1, 1, 1, 1, aodCycle, 0, 0)\n",
    "\n",
    "                    update_positions(start, end)\n",
    "                elif match(r\"^store (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # move\n",
    "                    exec(\"start = [\" + search(r\"^store (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "                    exec(\"end = [\" + search(r\"^store (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(3) + \"]\")\n",
    "                    shuttleOperation = True\n",
    "                    d = duration_of('store')\n",
    "                    for old, new in zip(start, end):\n",
    "                        x_old, y_old = old\n",
    "                        x_new, y_new = new\n",
    "                        k = pos2atoms[x_old][y_old]\n",
    "                        affected.add(k)\n",
    "                        shuttling.remove(k)\n",
    "\n",
    "                        append_program(time, k, x_old, y_old, 1, 1, 1, 1, aodCycle, 0, 0)\n",
    "                        append_program(time + d, k, x_new, y_new, 1, 0, 0, 1, aodCycle, 0, 0)\n",
    "\n",
    "                    # increment the aod cycle if no atom is shuttling anymore, this defines the end of one cycle\n",
    "                    if not shuttling:\n",
    "                        aodCycle += 1\n",
    "                    update_positions(start, end)\n",
    "                else:\n",
    "                    raise ParseError(f\"There is a syntax error in line {lineno}: {line}\")\n",
    "                # increment the time by the duration of the operation\n",
    "                time += d\n",
    "            except KeyError as e:\n",
    "                raise ParseError(f\"The key {e} was not found in line {lineno}: {line}\")\n",
    "        lineno += 1\n",
    "    # write out all atoms with the last location that have not been affected by the last operation above\n",
    "    # this is required that all atoms remain in the animation until the end and do not disappear before\n",
    "    for i in set(range(atoms_n)).difference(affected):\n",
    "        x, y = atoms2pos[i]\n",
    "        append_program(time, i, x, y, 1, 1 if i in shuttling else 0, 1 if i in shuttling else 0, 1 if i in shuttling else 0, aodCycle, 0, 0)\n",
    "\n",
    "# write out the program data-structure to a csv file\n",
    "with open(\"data.csv\", \"w\") as csv: # open the input file\n",
    "    csv.write(\"time;id;x;y;size;fill;color;axes;axesId;margin;marginId\\n\") # write header\n",
    "    for t in sorted(list(program.keys())):\n",
    "        for id in sorted(list(program[t].keys())):\n",
    "            x, y, size, fill, color, axes, axesId, margin, marginId = program[t][id]\n",
    "            csv.write(f\"{t/1000:.3f};{id};{x};{y};{size};{fill};{color};{axes};{axesId};{margin};{marginId}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Output for Plotly\n",
    "\n",
    "The following cell produces the output that the Plotly animation can be generated from.\n",
    "\n",
    "For this, just continue evaluating the cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(INPUT_FILE, \"r\") as src: # open the output file\n",
    "    with open(\"data.csv\", \"w\") as csv: # open the input file\n",
    "        csv.write(\"time;id;x;y;size;color\\n\") # write header\n",
    "        init = True         # true iff no other keyword except init occurred yet\n",
    "        pos2atoms = {}      # a mapping from position to atom id, i.e. it is a 2D dictionary\n",
    "        atoms2pos = []      # a list that maps atom ids to positions (tuples of ints)\n",
    "        shuttling = set()   # a set of atom ids that are currently being shuttled\n",
    "        atoms_n = 0         # number of atoms, used to determine the id of an atom\n",
    "        lineno = 1          # linenumber in the input file, corresponds to timestamps (comments are ignored)\n",
    "        while True:\n",
    "            line = src.readline().rstrip()  # readline and remove trailing whitespace characters\n",
    "            if line == \"\": # end of input reach, jump out of loop\n",
    "                break\n",
    "            elif match(r\"^#.*$\", line): # comments are ignored\n",
    "                continue\n",
    "            elif match(r\"^init at (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # init\n",
    "                if not init:\n",
    "                    raise ParseError(f\"The keyword init occurred after one out of ry, rz, cz, ccz, move\")\n",
    "                exec(\"coords = [\" + search(r\"^init at (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "                for x, y in coords:\n",
    "                    if x not in pos2atoms: pos2atoms[x] = {}\n",
    "                    pos2atoms[x][y] = atoms_n\n",
    "                    atoms2pos.append((x, y))\n",
    "                    csv.write(f\"{lineno};{pos2atoms[x][y]};{x};{y};1;0\\n\")\n",
    "                    atoms_n += 1\n",
    "            else:\n",
    "                init = False\n",
    "                affected = set()\n",
    "                try:\n",
    "                    if match(r\"^ry\\(.+\\);$\", line): # ry (color: 2, size: 2)\n",
    "                        for k, p in enumerate(atoms2pos):\n",
    "                            x, y = p\n",
    "                            affected.add(k)\n",
    "                            csv.write(f\"{lineno};{k};{x};{y};2;2\\n\")\n",
    "                    elif match(r\"^rz\\(.+\\) at (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # rz (color: 3, size: 2)\n",
    "                        exec(\"coords = [\" + search(r\"^rz\\(.+\\) at (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "                        for x, y in coords:\n",
    "                            affected.add(pos2atoms[x][y])\n",
    "                            csv.write(f\"{lineno};{pos2atoms[x][y]};{x};{y};2;3\\n\")\n",
    "                    elif match(r\"^cz;$\", line): # cz (color: 4, size: 3)\n",
    "                        for k1, p1 in enumerate(atoms2pos):\n",
    "                            x1, y1 = p1\n",
    "                            for k2, p2 in enumerate(atoms2pos[:k1]):\n",
    "                                x2, y2 = p2\n",
    "                                if sqrt((x1 - x2)**2 + (y1 - y2)**2) <= 2:  # interaction radius\n",
    "                                    affected.add(k1)\n",
    "                                    affected.add(k2)\n",
    "                                    csv.write(f\"{lineno};{pos2atoms[x1][y1]};{x1};{y1};3;4\\n\")\n",
    "                                    csv.write(f\"{lineno};{pos2atoms[x2][y2]};{x2};{y2};3;4\\n\")\n",
    "                    elif match(r\"^load (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # move\n",
    "                        exec(\"start = [\" + search(r\"^load (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "                        exec(\"end = [\" + search(r\"^load (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(3) + \"]\")\n",
    "                        for old, new in zip(start, end):\n",
    "                            x_old, y_old = old\n",
    "                            x_new, y_new = new\n",
    "                            affected.add(pos2atoms[x_old][y_old])\n",
    "                            shuttling.add(pos2atoms[x_old][y_old])\n",
    "                            csv.write(f\"{lineno};{pos2atoms[x_old][y_old]};{x_new};{y_new};1;1\\n\")\n",
    "                        # update both data-structures that store the locations of the atoms\n",
    "                        for old, new in zip(start, end):\n",
    "                            x_old, y_old = old\n",
    "                            x_new, y_new = new\n",
    "                            atoms2pos[pos2atoms[x_old][y_old]] = (x_new, y_new)\n",
    "                        pos2atoms.clear()\n",
    "                        for i, p in enumerate(atoms2pos):\n",
    "                            x, y = p\n",
    "                            if x not in pos2atoms: pos2atoms[x] = {}\n",
    "                            pos2atoms[x][y] = i\n",
    "                    elif match(r\"^move (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # move\n",
    "                        exec(\"start = [\" + search(r\"^move (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "                        exec(\"end = [\" + search(r\"^move (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(3) + \"]\")\n",
    "                        for old, new in zip(start, end):\n",
    "                            x_old, y_old = old\n",
    "                            x_new, y_new = new\n",
    "                            affected.add(pos2atoms[x_old][y_old])\n",
    "                            csv.write(f\"{lineno};{pos2atoms[x_old][y_old]};{x_new};{y_new};1;1\\n\")\n",
    "                        # update both data-structures that store the locations of the atoms\n",
    "                        for old, new in zip(start, end):\n",
    "                            x_old, y_old = old\n",
    "                            x_new, y_new = new\n",
    "                            atoms2pos[pos2atoms[x_old][y_old]] = (x_new, y_new)\n",
    "                        pos2atoms.clear()\n",
    "                        for i, p in enumerate(atoms2pos):\n",
    "                            x, y = p\n",
    "                            if x not in pos2atoms: pos2atoms[x] = {}\n",
    "                            pos2atoms[x][y] = i\n",
    "                    elif match(r\"^store (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line): # move\n",
    "                        exec(\"start = [\" + search(r\"^store (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(1) + \"]\")\n",
    "                        exec(\"end = [\" + search(r\"^store (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*) to (\\(-?\\d+, -?\\d+\\)(, \\(-?\\d+, -?\\d+\\))*);$\", line).group(3) + \"]\")\n",
    "                        for old, new in zip(start, end):\n",
    "                            x_old, y_old = old\n",
    "                            x_new, y_new = new\n",
    "                            affected.add(pos2atoms[x_old][y_old])\n",
    "                            shuttling.remove(pos2atoms[x_old][y_old])\n",
    "                            csv.write(f\"{lineno};{pos2atoms[x_old][y_old]};{x_new};{y_new};1;1\\n\")\n",
    "                        # update both data-structures that store the locations of the atoms\n",
    "                        for old, new in zip(start, end):\n",
    "                            x_old, y_old = old\n",
    "                            x_new, y_new = new\n",
    "                            atoms2pos[pos2atoms[x_old][y_old]] = (x_new, y_new)\n",
    "                        pos2atoms.clear()\n",
    "                        for i, p in enumerate(atoms2pos):\n",
    "                            x, y = p\n",
    "                            if x not in pos2atoms: pos2atoms[x] = {}\n",
    "                            pos2atoms[x][y] = i\n",
    "                    else:\n",
    "                        raise ParseError(f\"There is a syntax error in line {lineno}: {line}\")\n",
    "                    # write out all atoms with the last location that have not been affected by an operation above\n",
    "                    for i in set(range(atoms_n)).difference(affected):\n",
    "                        x, y = atoms2pos[i]\n",
    "                        csv.write(f\"{lineno};{i};{x};{y};1;{1 if i in shuttling else 0}\\n\")\n",
    "                except KeyError as e:\n",
    "                    raise ParseError(f\"The key {e} was not found in line {lineno}: {line}\")\n",
    "            lineno += 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build Visualization\n",
    "\n",
    "The above generated CSV file is taken and turned into a visulaization showing the movements and gate applications.\n",
    "\n",
    "### Input\n",
    "\n",
    "See the description of the output [above](#output).\n",
    "\n",
    "### Output\n",
    "\n",
    "A graphic showing the possible atom sites (SLM) in the background and the actual atoms including there movements. This figure can be exported in various formats using the functionality of plotly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "import plotly.graph_objects as go"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read in the two csv files generated above\n",
    "df_atoms = pd.read_csv(\"data.csv\", sep=\";\")\n",
    "df_atoms.sort_values(by=['time','id'], inplace=True)\n",
    "df_sites = pd.read_csv(LAYOUT_FILE, sep=\";\")\n",
    "df_sites['color'] = df_sites['color'].astype(str)\n",
    "df_sites"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 5\n",
    "range_x = [min(df_atoms['x'].min(), df_sites['x'].min()) - d, max(df_atoms['x'].max(), df_sites['x'].max()) + d]\n",
    "range_y = [max(df_atoms['y'].max(), df_sites['y'].max()) + d, min(df_atoms['y'].min(), df_sites['y'].min()) - d]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we use the library plotly.express to define the graphics\n",
    "# First, we define a graphics that shows the atoms as dots and animates there movement\n",
    "atoms = px.scatter(df_atoms,\n",
    "        height=800,\n",
    "        width=1600,\n",
    "        x=\"x\",\n",
    "        y=\"y\",\n",
    "        animation_frame=\"time\",\n",
    "        animation_group=\"id\",\n",
    "        size=\"size\",\n",
    "        color=\"color\",\n",
    "        hover_name=\"id\",\n",
    "        size_max=10,\n",
    "        range_x = range_x,\n",
    "        range_y = range_y,\n",
    "        range_color=[0,4],\n",
    "        template=\"plotly_white\")\n",
    "atoms.layout.updatemenus[0].buttons[0].args[1][\"frame\"][\"duration\"] = 1000 # slow down animation\n",
    "atoms.update(layout_coloraxis_showscale=False); # hide colorscale\n",
    "# Second, we define a second graphic that will be used as the background showing the atom sites\n",
    "sites = px.scatter(df_sites,\n",
    "        x = \"x\",\n",
    "        y = \"y\",\n",
    "        size = \"size\",\n",
    "        color = \"color\",\n",
    "        color_discrete_sequence = [\"#bbf\", \"#bbb\", \"#fbb\"],\n",
    "        size_max = 5,\n",
    "        range_x = range_x,\n",
    "        range_y = range_y,\n",
    "        template=\"plotly_white\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here, we combine the two figures above into one figure\n",
    "# [SPOILER]: The following is very hacky, be warned!\n",
    "# For an explanation: in principle two figures can be combined by invoking the method `add_traces` on one graphic and\n",
    "# passing the content of the `.data` attribute of the other figure. However, in this case this results in either having\n",
    "# the grid in the foreground or loosing the animation capability. Hence, we convert both figures to python dictionaries\n",
    "# (to bypass integrity checks of the python objects).\n",
    "#   1. We add the layers (one for every zone) showing the grid BEFORE the animation layer (`add_traces` would append them\n",
    "#      to the end), and\n",
    "#   2. Add three empty layers to each frame such that the atom layer is always the fourth one.\n",
    "fig_dict = atoms.to_dict()\n",
    "fig_dict[\"data\"] = sites.to_dict()[\"data\"] + fig_dict[\"data\"]\n",
    "for frame in fig_dict[\"frames\"]:\n",
    "    frame[\"data\"] = [{},{},{},frame[\"data\"][0]]\n",
    "# Read-in the dictionary and display figure\n",
    "fig = go.Figure(fig_dict)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To export the generated animation to a HTML-file, execute the next cell. When opening the file in a browser, you will see the exact same animation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"animation.html\", \"w\") as file:\n",
    "    file.writelines(fig.to_html(auto_play=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!open animation.html"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "plotly",
   "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.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}