{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QCoDeS Example with Keysight 344xxA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`344xxA` models of Keysight digital multimeters have similar QCoDeS drivers. In this tutorial, `Keysight_34465A` is chosen for showcasing the usage of the instrument.\n",
    "\n",
    "Note however that not every feature/parameter is available on all `344xxA` models. This, when possible, is reflected in the instantiated driver object. Also note that models like `34465A` have options (like `DIG` and `MEM`) that can either be enabled or disabled on a particular instrument; this also has impact on availability of some features/parameters and/or their settings. In general, refer to the instrument's manual for detailed information.\n",
    "\n",
    "__NOTE__: Beginning with firmware revision 3.0, the digitizing and advanced triggering option, referred to as \"DIG\", for models 34465A-DIG/34470A-DIG, is now standard.\n",
    "\n",
    "The driver does not cover all the features of the instrument. __At present, the driver only supports being used to measure DC Voltage__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "import numpy\n",
    "\n",
    "import qcodes\n",
    "from qcodes.dataset.measurements import Measurement\n",
    "from qcodes.dataset.plotting import plot_dataset\n",
    "from qcodes.instrument_drivers.Keysight.Keysight_34465A_submodules import Keysight_34465A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Connected to: Keysight Technologies 34465A (serial:MY54505281, firmware:A.03.00-02.40-03.00-00.52-02-01) in 0.61s\n"
     ]
    }
   ],
   "source": [
    "dmm = Keysight_34465A('dmm', 'TCPIP0::172.20.2.182::inst0::INSTR')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dmm.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters and methods overview\n",
    "\n",
    "Here is an overview (not exhaustive) of the parameters and methods that are available in the driver.\n",
    "\n",
    "The driver is not only comprised of root-level parameters and methods but also contains submodules which logically group some functionality.\n",
    "\n",
    "* Measurements\n",
    "  * `dmm.init_measurement()`\n",
    "  * `dmm.fetch()`\n",
    "  * `dmm.read()`\n",
    "  * `dmm.volt` - immediately measure one (the present) voltage value\n",
    "* Time trace measurements\n",
    "  * `dmm.timetrace` - covered in more detail below\n",
    "  * `dmm.time_axis`\n",
    "  * `dmm.timetrace_dt`\n",
    "  * `dmm.timetrace_npts`\n",
    "* Range settings\n",
    "  * `dmm.range`\n",
    "  * `dmm.autorange`\n",
    "  * `dmm.autorange_once()`\n",
    "* Triggering\n",
    "  * `dmm.trigger.source`\n",
    "  * `dmm.trigger.delay`\n",
    "  * `dmm.trigger.auto_delay_enabled`\n",
    "  * `dmm.trigger.count`\n",
    "  * `dmm.trigger.slope`\n",
    "  * `dmm.trigger.level`\n",
    "  * `dmm.trigger.force()`\n",
    "* Sample settings\n",
    "  * `dmm.sample.count`\n",
    "  * `dmm.sample.source`\n",
    "  * `dmm.sample.timer`\n",
    "  * `dmm.sample.pretrigger_count`\n",
    "* Display control\n",
    "  * `dmm.display.text`\n",
    "  * `dmm.display.clear()`\n",
    "  * `dmm.display.enabled`\n",
    "* Measurement type\n",
    "  * `dmm.sense_function`\n",
    "* Measurement accuracy (NB: DC Voltage mode only)\n",
    "  * `dmm.NPLC`\n",
    "  * `dmm.resolution`\n",
    "  * `dmm.line_frequency`\n",
    "  * `dmm.aperture_mode`\n",
    "  * `dmm.aperture_time`\n",
    "  * `dmm.autozero`\n",
    "\n",
    "As an extra, let's print the readable snapshot of the instrument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dmm:\n",
      "\tparameter     value\n",
      "--------------------------------------------------------------------------------\n",
      "IDN            :\t{'vendor': 'Keysight Technologies', 'model': '34465A', 'seri...\n",
      "NPLC           :\t10 (NPLC)\n",
      "aperture_mode  :\tOFF \n",
      "aperture_time  :\t0.1 \n",
      "autorange      :\tON \n",
      "autozero       :\tON \n",
      "line_frequency :\t50 (Hz)\n",
      "range          :\t0.1 \n",
      "resolution     :\t1e-08 (V)\n",
      "sense_function :\tDC Voltage \n",
      "time_axis      :\tNot available (s)\n",
      "timeout        :\t5 (s)\n",
      "timetrace      :\tNot available \n",
      "timetrace_dt   :\t0.1 (s)\n",
      "timetrace_npts :\t500 \n",
      "volt           :\t2.8814e-05 (V)\n",
      "dmm_display:\n",
      "\tparameter value\n",
      "--------------------------------------------------------------------------------\n",
      "enabled :\tTrue \n",
      "text    :\t \n",
      "dmm_trigger:\n",
      "\tparameter         value\n",
      "--------------------------------------------------------------------------------\n",
      "auto_delay_enabled :\tTrue \n",
      "count              :\t1 \n",
      "delay              :\t0.00016 (s)\n",
      "level              :\t0 (V)\n",
      "slope              :\tNEG \n",
      "source             :\tIMM \n",
      "dmm_sample:\n",
      "\tparameter       value\n",
      "--------------------------------------------------------------------------------\n",
      "count            :\t1 \n",
      "pretrigger_count :\t0 \n",
      "source           :\tIMM \n",
      "timer            :\t1 (s)\n",
      "timer_minimum    :\t0.43913 (s)\n"
     ]
    }
   ],
   "source": [
    "dmm.print_readable_snapshot(update=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single value reading\n",
    "\n",
    "If one simpy wants to measure a single voltage value right now, the convenient `volt` parameter can be used. This parameter will always return a voltage reading, even if the instrument is set up to measure something else than voltage. The instrument state is left untouched by getting this parameter.\n",
    "\n",
    "This is a convenience parameter that does not utilize the full power of the instrument. In the next two sections, we will present more prowerful and robust ways of performing measurements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-7.49454636e-05"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dmm.volt()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time trace type measurements\n",
    "\n",
    "For the commonly occuring case were one would like to measure N voltage points equidistantly spaced in time, the Keysight DMM driver offers the convenient `timetrace` parameter. It comes with three associated (helper) parameters:\n",
    "\n",
    " - `timetrace_dt` - the time spacing between the acquired points\n",
    " - `timetrace_npts` - the number of points\n",
    " - `time_axis` - the corresponding time axis (np.array, starts at 0)\n",
    " - `timetrace` - the array of voltage values\n",
    " \n",
    "Note that changing `timetrace_dt` and `timetrace_npts` does not change any corresponding setting on the instrument before `timetrace.get` is called. Once that happens, the state of the instrument is __temporarily__ switched into one compatible with performing a time trace measurement. This specifically means that we set\n",
    " \n",
    " - `trigger.count` to 1\n",
    " - `trigger.source` to \"BUS\" (internal trigger - __no other trigger can be used__)\n",
    " - `sample.timer` to `timetrace_dt`\n",
    " - `sample.count` to `timetrace_npts`\n",
    " \n",
    "After the acquisition has completed, the previous instrument settings are restored. This behaviour guarantees that calling `timetrace.get` always works, irrespective of instrument state. The only exception is if the specified `timetrace_dt` can not be realized with the present `dmm.NPLC` and/or `dmm.aperture_time` settings. If that is the case, the `timetrace.get` method will raise a `RuntimeError` with an instructive error message. The user may manually compare the value of `sample.timer_minimum` to the value of `timetrace_dt`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The usage is straightforward."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimal allowable dt: 0.015525 s\n",
      "Starting experimental run with id: 381\n"
     ]
    }
   ],
   "source": [
    "meas = Measurement()\n",
    "meas.register_parameter(dmm.timetrace)\n",
    "\n",
    "dmm.NPLC(0.006)\n",
    "dmm.timetrace_dt(0.02)\n",
    "dmm.timetrace_npts(500)\n",
    "\n",
    "print(f'Minimal allowable dt: {dmm.sample.timer_minimum()} s')\n",
    "\n",
    "with meas.run() as datasaver:\n",
    "    datasaver.add_result((dmm.timetrace, dmm.timetrace()),\n",
    "                          (dmm.time_axis, dmm.time_axis()))\n",
    "    \n",
    "time_trace_ds = datasaver.dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": [
    "axs, cbs = plot_dataset(time_trace_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## General guide: Multivalue triggered measurements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__NOTE__: Refer to the instrument manual for more information on how to perform measurements with the instrument; here, only the most basic and frequently used ones are demonstated.\n",
    "\n",
    "Measurements with the instrument are performed in the following way: the instrument's settings are set for a particular kind of measurement, then the measurement is started/initialized, then after all the data has been acquired, it is retrieved from the instrument. Below is an example of such a measurement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `range`, `autorange` parameters or `autorange_once` method to set the measurement range. Disabling autorange is recommended by the instrument's manual for speeding up the measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "dmm.autorange_once()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to set up the accuracy of the measurements and related settings, set up `NPLC` or `aperture_*` parameters (if available)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "dmm.aperture_mode('ON')\n",
    "dmm.aperture_time(2e-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set up triggering mechanism. Note that trigger settings and methods are inside `trigger` submodule of the instrument driver. Here, we will use immediate triggering (the measurement is triggered uppon measurement initialization, that is when `init_measurement` is called) with 1 trigger without any delays. Consulm the instrument's manual for more information on various triggering options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "dmm.trigger.source('IMM')\n",
    "dmm.trigger.count(1)\n",
    "dmm.trigger.delay(0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set up sampling settings. Note that sampling parameters and method are inside `sample` submodule of the instrument driver. Here, we set to measure 15 samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "dmm.sample.count(15)\n",
    "dmm.sample.pretrigger_count(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are also going to set the sample source to timer (not avaliable in all models) so that the instrument ensures that the samples are taken with fixed periods between them. The `timer` parameter allows to set the value of that fixed period. For simplicity, we are going to let the instrument deduce the minimum value of it according to the current instrument configuration (!) and set it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "dmm.sample.source('TIM')\n",
    "dmm.sample.timer('MIN')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It turns out that commands are executed faster when the display of the instrument is disabled or is displaying text. One of the further section expands on it. Here, we will just set the display to some text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "dmm.display.text('Example with 15 samples')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to initiate the measurement, call `init_measurement` method of the driver. In the case of this example, the instrument will get into \"wait-for-trigger\" mode but because the trigger source is \"immediate\", the instrument will immediately start measuring the 15 samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dmm.init_measurement()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The instrument is going to measure 15 samples and save them to its memory. Once the measurement is completed, we can call `fetch` method of the driver to retreive the acquired data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the measurement is going, there are two things we can do. One is to `sleep` until the end of the measurement, and then call `fetch`. The other one is to call `fetch` immediately after the measurement has been initiated - this way the instrument will return the acquired data right when the measurement is finished. This sounds pretty useful, however there are two considerations to keep in mind: the instrument manual hints that calling fetching immediately after initiation may be slower than waiting for the measurement to complete; if the measurement takes longer than the VISA command timeout, the code may raise a VISA timeout exception while the measurement is properly running (e.g. waiting for a trigger). To overcome the latter problem, one can temporarily change the VISA timeout value during the data fetching:\n",
    "```python\n",
    "new_timeout = old_timeout + n_samples * time_per_sample\n",
    "# where, n_samples == dmm.sample.count(),\n",
    "# and time_per_sample == dmm.sample.timer()\n",
    "with dmm.timeout.set_to(new_timeout):\n",
    "    data = dmm.fetch()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assuming that we've just slept or waited enough for the measurement to complete, let's `fetch` the data from the instrument. Note that due to the nature of the `fetch` command of the instrument, one can fetch the same measured data more than once (until, for example, a new measurement has been initiated; refer to the instrument's manual for more information on this)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.0092552 ,  0.00434024, -0.00366329, -0.00219105,  0.00356022,\n",
       "        0.01169778, -0.00892942,  0.00458304, -0.00102581, -0.00295006,\n",
       "       -0.00042901, -0.0006983 , -0.02305963,  0.00703878,  0.00509042])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = dmm.fetch()\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that there is also a `read` method. It's difference from `fetch` is that it also initiates the new measurement. Using `read` might be convenient for some cases while `init_measurement` + `fetch` definitely allow for more control."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the measurement is finished, let's bring back the display to life."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "dmm.display.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If needed, it is straightforward to calculate a vector of times when the acquired data points were measured; for example, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.     , 0.00063, 0.00126, 0.00189, 0.00252, 0.00315, 0.00378,\n",
       "       0.00441, 0.00504, 0.00567, 0.0063 , 0.00693, 0.00756, 0.00819,\n",
       "       0.00882])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = dmm.sample.count()\n",
    "t = dmm.sample.timer()\n",
    "setpoints = numpy.linspace(0, n*t, n)\n",
    "setpoints  # in seconds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that for this simple type of measurement with measurement times being equidistantly spaced, the `timetrace` parameter is preferred."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special values of some parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some parameters can be set to special values like `MIN`/`MAX`/`DEF` which usually mean minimum/maximum/default, respectively. \n",
    "\n",
    "In order to obtain the actual value of the parameter that gets set when setting it to one of these special values, just call the get method of the parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3600.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find out what the maximum value of `sample_timer` can be\n",
    "dmm.sample.timer('MAX')\n",
    "dmm.sample.timer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find out what the default value of `sample_timer` is\n",
    "dmm.sample.timer('DEF')\n",
    "dmm.sample.timer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.000588"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find out what the recommended minumum value of `sample_timer` is\n",
    "dmm.sample.timer('MIN')\n",
    "dmm.sample.timer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.000588"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alternatively, if available, use a conveniently implemented\n",
    "# get-only parameter to find out the actual value,\n",
    "# for example, for MIN value of `sample_timer` there is such\n",
    "# a convenient get-only parameter:\n",
    "dmm.sample.timer_minimum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Display state impacts command execution speed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To improve the execution speed of commands on the instrument, the user may disable the display's updates. When the display is not updating, it may show a static message of up to 40 characters. The `timetrace` parameter (see above) makes use of this functionality to execute faster and at the same time display a message that a measurement is in progress.\n",
    "\n",
    "The driver provides `display` submodule with `text` parameter that displays a given text on the insrturment, and a `clear` method that clears the text from display.\n",
    "\n",
    "The driver's `display` submodule also provides `enabled` parameter. When it is set to `False`, the state of the display is such that it does not show anything. Note, however, that displaying text is still possible when the `display.enabled` is `False` (when `display.enabled` is `False`, `display.clear` clears the text from the screen but does not enable it)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Displays the text\n",
    "dmm.display.text('Hello, World!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns display to its normal state\n",
    "dmm.display.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that a call to `display_clear` also updates \n",
    "# the value of the `display_text` parameter:\n",
    "assert dmm.display.text() == ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display can also be cleared by setting \n",
    "# `display_text` to an empty string\n",
    "dmm.display.text('some text')  # Displays some text\n",
    "time.sleep(0.5)\n",
    "dmm.display.text('')  # Returns display to its normal state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Disables the display, which makes it turn black\n",
    "dmm.display.enabled(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Shows some text on a disabled display\n",
    "dmm.display.text(\"I'm disabled but still showing text\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Enabling display in this state \n",
    "# won't change what's being displayed\n",
    "dmm.display.enabled(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ... but since the display is now enabled,\n",
    "# clearing the display will not only remove the text\n",
    "# but also show all the normal display indicators.\n",
    "dmm.display.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Error handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the following methods to read the error queue of the instrument. The instrument has an error queue of length up to 20 messages. The queue message retrieval is first-in-first-out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 'No error')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Retrieve the first (i.e. oldest) error message \n",
    "# in the queue (and thereby remove from the queue)\n",
    "dmm.error()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The entire queue can be flushed out\n",
    "# using `flush_error_queue` method.\n",
    "# Printing the messages in enabled by default\n",
    "# and can be disables with the `verbose` kwarg.\n",
    "\n",
    "# generate a few errors\n",
    "for _ in range(3):\n",
    "    dmm.write('produce an error!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-113 Undefined header\n",
      "-113 Undefined header\n",
      "-113 Undefined header\n",
      "0 No error\n"
     ]
    }
   ],
   "source": [
    "dmm.flush_error_queue(verbose=True)"
   ]
  },
  {
   "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.9"
  },
  "nbsphinx": {
   "execute": "never"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}