{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Area Detector with default HDF5 File Name" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "**Objective**\n", "\n", "Demonstrate and explain the setup of an [EPICS area detector](https://areadetector.github.io/master/index.html) to acquire an image with [bluesky](https://blueskyproject.io/) and write it to an [HDF5](https://www.hdfgroup.org/solutions/hdf5) file. Use the standard [ophyd conventions](https://blueskyproject.io/ophyd) for file naming and other setup. Show how to retrieve the image using the [databroker](https://blueskyproject.io/databroker).\n", "\n", "**Contents**\n", "\n", "- [EPICS Area Detector IOC](#EPICS-Area-Detector-IOC) is pre-built\n", "- [File Directories](#File-Directories) are different on IOC and bluesky workstation\n", "- [ophyd](#ophyd) to describe the hardware\n", "- [bluesky](#bluesky) for the measurement\n", "- [databroker](#databroker) to view the image\n", "- [punx](#punx) (not part of Bluesky) to look at the HDF5 file\n", "- [Recapitulation](#Recapitulation) - rendition with no explanations" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## EPICS Area Detector IOC\n", "\n", "This notebook uses an EPICS server (IOC), with prefix `\"ad:\"`. The IOC provides a simulated EPICS area detector.\n", "\n", "
\n", "IOC details\n", "\n", "The IOC is a prebuilt [ADSimDetector](https://areadetector.github.io/master/ADSimDetector/simDetector.html) driver, packaged in a [docker](https://www.docker.com/) image\n", "([prjemian/synapps](https://hub.docker.com/r/prjemian/synapps/tags)). The [EPICS IOC](https://docs.epics-controls.org/projects/how-tos/en/latest/getting-started/creating-ioc.html) is configured with prefix `ad:` using the [bash shell script](https://raw.githubusercontent.com/prjemian/epics-docker/main/resources/iocmgr.sh):\n", "\n", "
\n",
    "$ iocmgr.sh start ADSIM ad\n",
    "
\n", "\n", "
" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "IOC = \"ad:\"" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## File Directories\n", "\n", "The area detector IOC and the bluesky workstation should see the same directory where image files will be written by the IOC. However, the directory may be mounted on one path in the IOC and a different path in the bluesky workstation. That's the case for the IOC and workstation here. The paths are shown in the next table.\n", "\n", "system | file directory\n", "--- | ---\n", "area detector IOC | `/tmp`\n", "bluesky | `/tmp/docker_ioc/iocad/tmp`\n", "\n", "

\n", "

\n", "\n", "Typically, the file system is mounted on both the IOC and the workstation at the\n", "time of acquisition. Each may mount the filesystem at different mount points.\n", "But mounting the filesystems is not _strictly necessary_ at the time the images\n", "area acquired.\n", "\n", "An alternative (to mounting the file directory on both IOC & workstation) is to\n", "_copy the file(s)_ written by the IOC to a directory on the workstation.\n", "\n", "The only time bluesky needs access to the image file is when a Python process\n", "(usually via databroker) has requested the image data from the file.\n", "\n", "
\n", "\n", "For convenience now and later, define these two directories using [pathlib](https://docs.python.org/3/library/pathlib.html), from the Python standard library." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import pathlib\n", "\n", "AD_IOC_MOUNT_PATH = pathlib.Path(\"/tmp\")\n", "BLUESKY_MOUNT_PATH = pathlib.Path(\"/tmp/docker_ioc/iocad/tmp\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Image files are written to a subdirectory (*image directory*) of the mount path.\n", "\n", "***details***\n", "\n", "In this case, we use a feature of the area detector [HDF5 file writer](https://areadetector.github.io/master/ADCore/NDFileHDF5.html) plugin that accepts [time format codes](https://cplusplus.com/reference/ctime/strftime/), such as `%Y` for 4-digit year, to build the image directory path based on the current date. (For reference, Python's [datetime](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes) package uses these same codes.)\n", "\n", "Here, we create an `example` directory with subdirectory for year, month, and day (such as: `example/2022/07/04`):" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "IMAGE_DIR = \"example/%Y/%m/%d\"" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Using the two pathlib objects created above, create two string objects for configuration of the HDF5 plugin.\n", "\n", "***details***\n", "\n", "The area detector IOC expects each string to end with a `/` character but will add it if it is not provided. But ophyd requires the value sent to EPICS to match exactly the value that the IOC reports, thus we make the correct ending here." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# MUST end with a `/`, pathlib will NOT provide it\n", "WRITE_PATH_TEMPLATE = f\"{AD_IOC_MOUNT_PATH / IMAGE_DIR}/\"\n", "READ_PATH_TEMPLATE = f\"{BLUESKY_MOUNT_PATH / IMAGE_DIR}/\"" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## ophyd\n", "\n", "In ophyd, the support for hardware involving multiple PVs is constructed as a subclass of `ophyd.Device`.\n", "\n", "***details***\n", "\n", "The EPICS area detector is described with a special `Device` subclass called `ophyd.areadetector.DetectorBase`. An area detector has a detector driver, called a `cam` in the ophyd support, which is another subclass.\n", "\n", "Before you can create an ophyd object for your ADSimDetector detector, you'll need to create an ophyd class that describes the features of the EPICS Area Detector interface you plan to use, such as the camera (*ADSimDetector*, in this case) and any plugins such as computations or file writers.\n", "\n", "Each of the plugins (image, PVA, HDF5, ...) has its own subclass. The general structure is:\n", "\n", "```\n", "DetectorBase\n", " CamBase\n", " ImagePlugin\n", " HDF5Plugin\n", " PvaPlugin\n", " ...\n", "```\n", "\n", "***Which plugins are needed by bluesky?***\n", "\n", "In this example, we must define:\n", "\n", "name | subclass of | why?\n", "--- | --- | ---\n", "`cam` | `CamBase` | generates the image data\n", "`hdf1` | `HDF5Plugin` | output to an HDF5 file\n", "`image1` | `ImagePlugin` | make the image viewable\n", "\n", "The component name `hdf1`, the `1` is customary, referring to the `HDF1:` part of the EPICS PV name for the *first* HDF5 file writer plugin in the EPICS IOC. (It is possible to create an IOC with more than one HDF5 file writer plugin.) Similar for the `image1` component.\n", "\n", "In EPICS Area Detector, an [NDArray](https://areadetector.github.io/master/ADCore/NDArray.html) is the data passed from a detector `cam` to plugins. Each plugin references its input NDArray by the port name of the source.\n", "\n", "> To connect plugin `downstream` to plugin `upstream`, set `downstream.nd_array_port` (**Port**) to `upstream.port_name` (**Plugin name**).\n", "\n", "In this example screen view, using the ADSimDetector, all the plugins shown are\n", "configured to receive their input from `SIM1` which is the `cam`. (While the\n", "screen view shows the PVA1 plugin enabled, we will not enable that in this example.)\n", "\n", "![](./2022-08-03-commonPlugins-snapshot.png)\n", "\n", "Each [port](https://blueskyproject.io/ophyd/explanations/area-detector.html?highlight=singletrigger#ports) named by the detector ***must*** have its plugin (or `cam`) defined in the ophyd detector class. \n", "\n", "You can check if you missed any plugins once you have created your detector object by calling its `.missing_plugins()` method. For example, where our example ADSimDetector IOC uses the `ad:` PV prefix:\n", "\n", "```py\n", "from ophyd.areadetector import SimDetector\n", "det = SimDetector(\"ad:\", name=\"det\")\n", "det.missing_plugins()\n", "```\n", "\n", "We expect to see an empty list, `[]`, as the result of this last command. Otherwise, the list will describe the plugins needed." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### cam\n", "\n", "The `cam` Device describes the EPICS area detector camera driver for this detector.\n", "\n", "***details***\n", "\n", "The [ophyd package](https://blueskyproject.io/ophyd/explanations/area-detector.html#specific-hardware) has support for many of the area detector drivers. A complete list is available in the [ophyd source code](https://github.com/bluesky/ophyd/blob/master/ophyd/areadetector/cam.py). The principle difference between area detector drivers is the `cam` support, which is specific to the detector driver being configured. All the other plugin support is independent of the `cam` support. Use steps similar to these to implement for a different detector driver.\n", "\n", "The ADSimDetector driver is in this list, as `SimDetectorCam`. But the ophyd support is out of date for the EPICS area detector release 3.10 used here, so we need to make modifications with a subclass, as is typical. The changes we see are current since ADSimDetector v3.1.1.\n", "\n", "In the [apstools](https://bcda-aps.github.io/apstools/latest/) package, `apstools.devices.CamMixin_V34` provides the updates needed. (Eventually, these updates will be *hoisted* into the ophyd package.)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "from apstools.devices import CamMixin_V34\n", "from ophyd.areadetector import SimDetectorCam\n", "from ophyd import ADComponent\n", "\n", "class SimDetectorCam_V34(CamMixin_V34, SimDetectorCam):\n", " \"\"\"Revise SimDetectorCam for ADCore revisions.\"\"\"" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### HDF5\n", "\n", "The `hdf1` Device describes the HDF5 File Writing plugin for this detector.\n", "\n", "***details***\n", "\n", "Support for writing images to HDF5 files using the area detector [HDF5 File Writer plugin](https://github.com/bluesky/ophyd/blob/master/ophyd/areadetector/plugins.py) comes from the `ophyd.areadetector.HDF5Plugin`. This plugin comes in different versions for different versions of area detector `ADCore`. The `HDF5Plugin` ophyd support was written for an older version of the HDF5 File Writer plugin, but there is a `HDF5Plugin_V34` version that may be used with Area Detector release 3.4 and above. Our IOC uses release 3.10.\n", "\n", "The plugin provides supports writing HDF5 files. Some modification is needed, via a mixin class, for the manner of acquisition.\n", "\n", "Here we build a custom HDF5 plugin class with `FileStoreHDF5IterativeWrite`. This mixin class configures the HDF5 plugin to collect one or more images with the IOC, then writes file name and path and HDF5 address information of each frame in the data stream from the bluesky RunEngine.\n", "\n", "We make one modification to the `stage()` method, to move the setting of `capture` to be last in the list. If it is not last, then any HDF5 plugin settings coming after might not succeed, since they cannot be done in capture mode." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from ophyd.areadetector.filestore_mixins import FileStoreHDF5IterativeWrite\n", "from ophyd.areadetector.plugins import HDF5Plugin_V34 as HDF5Plugin\n", "\n", "class MyHDF5Plugin(FileStoreHDF5IterativeWrite, HDF5Plugin):\n", " \"\"\"\n", " Add data acquisition methods to HDF5Plugin.\n", "\n", " * ``stage()`` - prepare device PVs befor data acquisition\n", " * ``unstage()`` - restore device PVs after data acquisition\n", " * ``generate_datum()`` - coordinate image storage metadata\n", " \"\"\"\n", "\n", " def stage(self):\n", " self.stage_sigs.move_to_end(\"capture\", last=True)\n", " super().stage()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### detector\n", "\n", "The detector class, a subclass of `DetectorBase`, brings together the detector driver `cam` and plugins.\n", "\n", "***details***\n", "\n", "This class will be used to build the Python object for the detector. In addition to the `cam` and HDF5 plugin, we'll enable the image plugin (`ImagePlugin`) so that a client viewer can view the image.\n", "\n", "The `SingleTrigger` mixin class configures the `cam` for data acquisition as [explained](https://blueskyproject.io/ophyd/explanations/area-detector.html?highlight=singletrigger#callbacks). As with the `HDF5Plugin` above, the ophyd support is not up to date with more recent developments in EPICS Area Detector. The updates are available from `apstools.devices.SingleTrigger_V34`.\n", "\n", "When configuring the custom `MyHDF5Plugin` class, we apply the two strings defined above for the file paths on the IOC (write) and on the bluesky workstation (read).\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "from apstools.devices import SingleTrigger_V34\n", "from ophyd.areadetector import DetectorBase\n", "from ophyd.areadetector.plugins import ImagePlugin_V34 as ImagePlugin\n", "\n", "class SimDetector_V34(SingleTrigger_V34, DetectorBase):\n", " \"\"\"\n", " ADSimDetector\n", "\n", " SingleTrigger:\n", "\n", " * stop any current acquisition\n", " * sets image_mode to 'Multiple'\n", " \"\"\"\n", "\n", " cam = ADComponent(SimDetectorCam_V34, \"cam1:\")\n", " hdf1 = ADComponent(\n", " MyHDF5Plugin,\n", " \"HDF1:\",\n", " write_path_template=WRITE_PATH_TEMPLATE,\n", " read_path_template=READ_PATH_TEMPLATE,\n", " )\n", " image = ADComponent(ImagePlugin, \"image1:\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "With all the above setup, create the Python detector object, `adsimdet` and wait for it to connect with EPICS." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "adsimdet = SimDetector_V34(IOC, name=\"adsimdet\")\n", "adsimdet.wait_for_connection(timeout=15)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Check that all plugins used by the IOC have been defined in the Python structure. Expect that this function returns an empty list: `[]`." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "adsimdet.missing_plugins()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We must configure `adsimdet` so the HDF5 plugin (by its attribute name `hdf1`) will be called during `adsimdet.read()`, as used by data acquisition. This plugin is already `enabled` (above) but we must change the [`kind`](https://blueskyproject.io/ophyd/user_v1/reference/signals.html#kind) attribute. Ophyd support will check this attribute to see if the plugin should be [`read`](https://blueskyproject.io/ophyd/user_v1/tutorials/device.html#assign-a-kind-to-components) during data acquisition. If we don't change this, the area detector image(s) will not be reported in the run's documents.\n", "\n", "**Note**: Here, we assign the `kind` attribute by number `3`, a shorthand which is interpreted by ophyd as `ophyd.Kind.config | ophyd.Kind.normal`." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "adsimdet.hdf1.kind = 3 # config | normal" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Configure the HDF5 plugin so it will create up to 5 subdirectories for the image directory.\n", "\n", "***details***\n", "\n", "We *must* do this step before staging so the IOC is prepared when the `FilePath` PV is set during `adsimdet.stage()`." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "adsimdet.hdf1.create_directory.put(-5)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Wait for all plugins to finish.\n", "\n", "***details***\n", "\n", "One of the [changes for the SingleTrigger mixin](https://blueskyproject.io/ophyd/explanations/area-detector.html?highlight=singletrigger#callbacks) adds the `adsimdet.cam.wait_for_plugins` signal. This enables clients to know, via the `adsimdet.cam.acquire_busy` signal, when the camera and *all* enabled plugins are finished. For this to work, each plugin has `blocking_callbacks` set to `\"No\"` and the cam has `wait_for_plugins` set to `\"Yes\"`. Then, `cam.acquire_busy` will remain `\"Acquiring\"` (or `1`) until all plugins have finished processing, then it goes to `\"Done\"` (or `0`)." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# override default setting from ophyd\n", "adsimdet.hdf1.stage_sigs[\"blocking_callbacks\"] = \"No\"\n", "adsimdet.cam.stage_sigs[\"wait_for_plugins\"] = \"Yes\"" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "For good measure, also make sure the `image` plugin does not block." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "adsimdet.image.stage_sigs[\"blocking_callbacks\"] = \"No\"" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Consider enabling and setting any of these additional configurations, or others as appropriate to your situation.\n", "\n", "***details***\n", "\n", "Here, we accept the default acquisition time, but acquire 5 frames with `zlib` data compression.\n", "\n", "The `\"LZ4\"` compression is good for speed and compression but requires the [hdf5plugin](https://github.com/silx-kit/hdf5plugin) package to read the compressed data from the HDF5 file.\n", "\n", "But since our [last step](#punx) uses a tool that does not yet have this package, we'll use `zlib` compression." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "adsimdet.cam.stage_sigs[\"acquire_period\"] = 0.015\n", "adsimdet.cam.stage_sigs[\"acquire_time\"] = 0.01\n", "adsimdet.cam.stage_sigs[\"num_images\"] = 5\n", "adsimdet.hdf1.stage_sigs[\"num_capture\"] = 0 # capture ALL frames received\n", "adsimdet.hdf1.stage_sigs[\"compression\"] = \"zlib\" # LZ4\n", "# adsimdet.hdf1.stage_sigs[\"queue_size\"] = 20" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "*Prime* the HDF5 plugin, if necessary.\n", "\n", "***details***\n", "\n", "Even though area detector has a `LazyOpen` feature, ophyd needs to know how to describe the image structure before it starts saving data. If the file writing (HDF5) plugin does not have the dimensions, bit depth, color mode, ... of the expected image, then ophyd does not have access to the metadata it needs.\n", "\n", "NOTE: The `adsimdet.hdf1.lazy_open` signal should remain `\"No\"` if data is to be read later from the databroker. Attempts to read the data (via `run.primary.read()`) will see this exception raised:\n", "\n", "> `event_model.EventModelError: Error instantiating handler class `\n", "\n", "This code checks if the plugin is ready and, if not, makes the plugin ready by acquiring (a.k.a. *priming*) a single image into the plugin." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Priming hdf1\n" ] } ], "source": [ "from apstools.devices import ensure_AD_plugin_primed\n", "\n", "# this step is needed for ophyd\n", "ensure_AD_plugin_primed(adsimdet.hdf1, True)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Print some values as diagnostics." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['hdf1']" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "adsimdet.read_attrs" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "OrderedDict([('cam.acquire', 0), ('cam.image_mode', 1)])" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "adsimdet.stage_sigs" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "OrderedDict([('wait_for_plugins', 'Yes'),\n", " ('acquire_period', 0.015),\n", " ('acquire_time', 0.01),\n", " ('num_images', 5)])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "adsimdet.cam.stage_sigs" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "OrderedDict([('enable', 1),\n", " ('blocking_callbacks', 'No'),\n", " ('parent.cam.array_callbacks', 1),\n", " ('create_directory', -3),\n", " ('auto_increment', 'Yes'),\n", " ('array_counter', 0),\n", " ('auto_save', 'Yes'),\n", " ('num_capture', 0),\n", " ('file_template', '%s%s_%6.6d.h5'),\n", " ('file_write_mode', 'Stream'),\n", " ('capture', 1),\n", " ('compression', 'zlib')])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "adsimdet.hdf1.stage_sigs" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## bluesky\n", "\n", "Within the [Bluesky framework](https://blueskyproject.io/), [bluesky](https://blueskyproject.io/bluesky) is the package that orchestrates the data acquisition steps, including where to direct acquired data for storage. [Later](#databroker), we'll use [databroker](https://blueskyproject.io/databroker) to access the image data.\n", "\n", "As a first step, configure the notebook for graphics. (While `%matplotlib inline` works well for documentation, you might prefer the additional interactive features possible by changing to `%matplotlib widget`.)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Import matplotlib for inline graphics\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "\n", "plt.ion()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We'll use a temporary databroker catalog for this example and setup the RunEngine object `RE`.\n", "\n", "***details***\n", "\n", "You may wish to use your own catalog:\n", "\n", "```py\n", "cat = databroker.catalog[YOUR_CATALOG_NAME]\n", "```\n", "\n", "Then setup the bluesky run engine `RE`, connect it with the databroker catalog, and enable (via `BestEffortCallback`) some screen output during data collection." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "from bluesky import plans as bp\n", "from bluesky import RunEngine\n", "from bluesky import SupplementalData\n", "from bluesky.callbacks.best_effort import BestEffortCallback\n", "import databroker\n", "\n", "cat = databroker.temp().v2\n", "RE = RunEngine({})\n", "RE.subscribe(cat.v1.insert)\n", "RE.subscribe(BestEffortCallback())\n", "RE.preprocessors.append(SupplementalData())" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "***Take an image with the area detector***\n", "\n", "***details***\n", "\n", "Also, capture the list of identifiers (there will be only one item). Add custom metadata to identify the imaging run.\n", "\n", "Note that the HDF plugin will report, briefly before acquisition, (in its `WriteMessage` PV):\n", "\n", "> ERROR: capture is not permitted in Single mode\n", "\n", "Ignore that." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "Transient Scan ID: 1 Time: 2023-04-10 09:37:15\n", "Persistent Unique Scan ID: '2ef5ca0d-7296-448d-a132-fa35de7e439d'\n", "New stream: 'primary'\n", "+-----------+------------+\n", "| seq_num | time |\n", "+-----------+------------+\n", "| 1 | 09:37:15.6 |\n", "+-----------+------------+\n", "generator count ['2ef5ca0d'] (scan num: 1)\n", "\n", "\n", "\n" ] } ], "source": [ "uids = RE(bp.count([adsimdet], md=dict(title=\"Area Detector with default HDF5 File Name\", purpose=\"image\")))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## databroker\n", "\n", "To emphasize the decisions associated with each step to get the image data, the procedure is shown in parts.\n", "\n", "***Get the run from the catalog***\n", "\n", "The run data comes from the databroker catalog.\n", "\n", "***details***\n", "\n", "We *could* assume we want the most recent run in the catalog (`run = cat.v2[-1]`). But, since we have a list of run *uid* strings, let's use that instead. If we wanted to access this run later, when neither of those two choices are possible, then the run could be access by its *Transient Scan ID* as reported above: `run = cat.v2[1]`\n", "\n", "There are three ways to reference a run in the catalog:\n", "\n", "argument | example | description\n", "--- | --- | ---\n", "negative integer | `cat.v2[-1]` | ***list*-like**, `-1` is most recent, `-2` is 2nd most recent, ...\n", "positive integer | `cat.v2[1]` | argument is the **Scan ID** (if search is not unique, returns most recent)\n", "string | `cat.v2[\"a1b2c3d\"]` | argument is a **`uid`** (just the first few characters that make the catalog search unique are needed)\n", "\n", "We called the `RE` with `bp.count()`, which only generates a single run, so there is no assumption here using the `uids` list from this session." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "BlueskyRun\n", " uid='2ef5ca0d-7296-448d-a132-fa35de7e439d'\n", " exit_status='success'\n", " 2023-04-10 09:37:15.549 -- 2023-04-10 09:37:15.692\n", " Streams:\n", " * primary\n" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run = cat.v2[uids[0]]\n", "run" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "***Get the image frame from the run***\n", "\n", "From the run, we know the image data is in the primary stream.\n", "\n", "***details***\n", "\n", "(In fact, that is the only stream in this run.) Get the run's data as an [xarray Dataset](https://docs.xarray.dev/en/stable/generated/xarray.Dataset.html) object.\n", "\n", "Recall, above, we said that the `LZ4` compression needs help from the `hdf5plugin` package, all we have to do is `import` it. The package installs entry points to assist the h5py library to uncompress the data.\n", "\n", "Since we used `zlib` above, we comment the import for now." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:         (time: 1, dim_0: 5, dim_1: 1024, dim_2: 1024)\n",
       "Coordinates:\n",
       "  * time            (time) float64 1.681e+09\n",
       "Dimensions without coordinates: dim_0, dim_1, dim_2\n",
       "Data variables:\n",
       "    adsimdet_image  (time, dim_0, dim_1, dim_2) uint8 198 199 200 ... 199 200
" ], "text/plain": [ "\n", "Dimensions: (time: 1, dim_0: 5, dim_1: 1024, dim_2: 1024)\n", "Coordinates:\n", " * time (time) float64 1.681e+09\n", "Dimensions without coordinates: dim_0, dim_1, dim_2\n", "Data variables:\n", " adsimdet_image (time, dim_0, dim_1, dim_2) uint8 198 199 200 ... 199 200" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# import hdf5plugin # required for LZ4, Blosc, and other compression codecs\n", "\n", "dataset = run.primary.read()\n", "dataset" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "The image is recorded under the name `\"adsimdet_image\"`.\n", "\n", "***details***\n", "\n", "This `image` object has rank of 4 (1 timestamp and 5 frames of 1k x 1k)." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "image = dataset[\"adsimdet_image\"]\n", "# image is an xarray.DataArray with 1 timestamp and 5 frames of 1k x 1k" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We just want the `image` frame (the last two indices).\n", "\n", "***details***\n", "\n", "Select the first item of each of the first two indices (time, frame number)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "frame = image[0][0]\n", "# frame is an xarray.DataArray of 1k x 1k" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "***Visualize the image***\n", "\n", "The `frame` is an [xarray Dataset](https://docs.xarray.dev/en/stable/generated/xarray.Dataset.html), which has a method to visualize the data as shown here:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "frame.plot.pcolormesh()" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[Resource({'path_semantics': 'posix',\n", " 'resource_kwargs': {'frame_per_point': 5},\n", " 'resource_path': 'tmp/docker_ioc/iocad/tmp/example/2023/04/10/0a859a72-11eb-4dd7-80a1_000000.h5',\n", " 'root': '/',\n", " 'run_start': '2ef5ca0d-7296-448d-a132-fa35de7e439d',\n", " 'spec': 'AD_HDF5',\n", " 'uid': '22cf9e31-22d7-4320-a42f-1f6465f37ca8'})]" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run.primary._resources" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "***Find the image file on local disk***\n", "\n", "Get the name of the image file on the bluesky (local) workstation from the `adsimdet` object." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "local_file_name.exists()=True\n", "local_file_name=PosixPath('/tmp/docker_ioc/iocad/tmp/example/2023/04/10/0a859a72-11eb-4dd7-80a1_000000.h5')\n" ] } ], "source": [ "from apstools.devices import AD_full_file_name_local\n", "\n", "local_file_name = AD_full_file_name_local(adsimdet.hdf1)\n", "print(f\"{local_file_name.exists()=}\\n{local_file_name=}\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Alternatively, we might get the name of the file from the run stream." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "fname.exists()=True\n", "fname=PosixPath('/tmp/docker_ioc/iocad/tmp/example/2023/04/10/0a859a72-11eb-4dd7-80a1_000000.h5')\n", "(local_file_name == fname)=True\n" ] } ], "source": [ "rsrc = run.primary._resources[0]\n", "fname = pathlib.Path(f\"{rsrc['root']}{rsrc['resource_path']}\")\n", "print(f\"{fname.exists()=}\\n{fname=}\")\n", "\n", "# confirm they are the same\n", "print(f\"{(local_file_name == fname)=}\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## punx\n", "\n", "Next, we demonstrate access to the HDF5 image file using the [punx](https://punx.readthedocs.io) program.\n", "\n", "***details***\n", "\n", "We run `punx` from within the notebook to read this HDF5 file and shows its tree structure. (Since we can't easily pass a Python object to the notebook magic command `!` which executes a shell command, we'll call a library routine from [apstools](https://apstools.readthedocs.io/en/latest/api/_utils.html?highlight=unix#apstools.utils.misc.unix) to make this work.)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "!!! WARNING: this program is not ready for distribution.\n", "\n", "/tmp/docker_ioc/iocad/tmp/example/2023/04/10/0a859a72-11eb-4dd7-80a1_000000.h5 : NeXus data file\n", " entry:NXentry\n", " @NX_class = \"NXentry\"\n", " data:NXdata\n", " @NX_class = \"NXdata\"\n", " data:NX_UINT8[5,1024,1024] = __array\n", " __array = [\n", " [\n", " [198, 199, 200, '...', 197]\n", " [199, 200, 201, '...', 198]\n", " [200, 201, 202, '...', 199]\n", " ...\n", " [197, 198, 199, '...', 196]\n", " ]\n", " [\n", " [199, 200, 201, '...', 198]\n", " [200, 201, 202, '...', 199]\n", " [201, 202, 203, '...', 200]\n", " ...\n", " [198, 199, 200, '...', 197]\n", " ]\n", " [\n", " [200, 201, 202, '...', 199]\n", " [201, 202, 203, '...', 200]\n", " [202, 203, 204, '...', 201]\n", " ...\n", " [199, 200, 201, '...', 198]\n", " ]\n", " [\n", " [201, 202, 203, '...', 200]\n", " [202, 203, 204, '...', 201]\n", " [203, 204, 205, '...', 202]\n", " ...\n", " [200, 201, 202, '...', 199]\n", " ]\n", " [\n", " [202, 203, 204, '...', 201]\n", " [203, 204, 205, '...', 202]\n", " [204, 205, 206, '...', 203]\n", " ...\n", " [201, 202, 203, '...', 200]\n", " ]\n", " ]\n", " @NDArrayDimBinning = [1 1]\n", " @NDArrayDimOffset = [0 0]\n", " @NDArrayDimReverse = [0 0]\n", " @NDArrayNumDims = 2\n", " @signal = 1\n", " instrument:NXinstrument\n", " @NX_class = \"NXinstrument\"\n", " NDAttributes:NXcollection\n", " @NX_class = \"NXcollection\"\n", " @hostname = \"zap\"\n", " NDArrayEpicsTSSec:NX_UINT32[5] = [1049985435, 1049985435, 1049985435, 1049985435, 1049985435]\n", " @NDAttrDescription = \"The NDArray EPICS timestamp seconds past epoch\"\n", " @NDAttrName = \"NDArrayEpicsTSSec\"\n", " @NDAttrSource = \"Driver\"\n", " @NDAttrSourceType = \"NDAttrSourceDriver\"\n", " NDArrayEpicsTSnSec:NX_UINT32[5] = [604497411, 619772589, 635844558, 650919763, 666040904]\n", " @NDAttrDescription = \"The NDArray EPICS timestamp nanoseconds\"\n", " @NDAttrName = \"NDArrayEpicsTSnSec\"\n", " @NDAttrSource = \"Driver\"\n", " @NDAttrSourceType = \"NDAttrSourceDriver\"\n", " NDArrayTimeStamp:NX_FLOAT64[5] = [1049985435.5943798, 1049985435.6095004, 1049985435.6256955, 1049985435.6408099, 1049985435.6558784]\n", " @NDAttrDescription = \"The timestamp of the NDArray as float64\"\n", " @NDAttrName = \"NDArrayTimeStamp\"\n", " @NDAttrSource = \"Driver\"\n", " @NDAttrSourceType = \"NDAttrSourceDriver\"\n", " NDArrayUniqueId:NX_INT32[5] = [1735, 1736, 1737, 1738, 1739]\n", " @NDAttrDescription = \"The unique ID of the NDArray\"\n", " @NDAttrName = \"NDArrayUniqueId\"\n", " @NDAttrSource = \"Driver\"\n", " @NDAttrSourceType = \"NDAttrSourceDriver\"\n", " detector:NXdetector\n", " @NX_class = \"NXdetector\"\n", " data:NX_UINT8[5,1024,1024] = __array\n", " __array = [\n", " [\n", " [198, 199, 200, '...', 197]\n", " [199, 200, 201, '...', 198]\n", " [200, 201, 202, '...', 199]\n", " ...\n", " [197, 198, 199, '...', 196]\n", " ]\n", " [\n", " [199, 200, 201, '...', 198]\n", " [200, 201, 202, '...', 199]\n", " [201, 202, 203, '...', 200]\n", " ...\n", " [198, 199, 200, '...', 197]\n", " ]\n", " [\n", " [200, 201, 202, '...', 199]\n", " [201, 202, 203, '...', 200]\n", " [202, 203, 204, '...', 201]\n", " ...\n", " [199, 200, 201, '...', 198]\n", " ]\n", " [\n", " [201, 202, 203, '...', 200]\n", " [202, 203, 204, '...', 201]\n", " [203, 204, 205, '...', 202]\n", " ...\n", " [200, 201, 202, '...', 199]\n", " ]\n", " [\n", " [202, 203, 204, '...', 201]\n", " [203, 204, 205, '...', 202]\n", " [204, 205, 206, '...', 203]\n", " ...\n", " [201, 202, 203, '...', 200]\n", " ]\n", " ]\n", " @NDArrayDimBinning = [1 1]\n", " @NDArrayDimOffset = [0 0]\n", " @NDArrayDimReverse = [0 0]\n", " @NDArrayNumDims = 2\n", " @signal = 1\n", " NDAttributes:NXcollection\n", " @NX_class = \"NXcollection\"\n", " ColorMode:NX_INT32[5] = [0, 0, 0, 0, 0]\n", " @NDAttrDescription = \"Color mode\"\n", " @NDAttrName = \"ColorMode\"\n", " @NDAttrSource = \"Driver\"\n", " @NDAttrSourceType = \"NDAttrSourceDriver\"\n", " performance\n", " timestamp:NX_FLOAT64[5,5] = __array\n", " __array = [\n", " [0.002630463, 0.148994861, 1049963466.6087971, 53.693127040133284, 0.0]\n", " [0.023401726, 0.035369701, 0.023408677, 226.18229088224408, 341.75361555033635]\n", " [0.012312513, 0.01237443, 0.035783107, 646.4944243896487, 447.13836615696897]\n", " [0.008425541, 0.008463056, 0.044246163, 945.2850128842347, 542.4199155981051]\n", " [0.006898131, 0.007997728, 0.052243891, 1000.2840806789127, 612.5118054472628]\n", " ]\n", "\n" ] } ], "source": [ "from apstools.utils import unix\n", "\n", "for line in unix(f\"punx tree {local_file_name}\"):\n", " print(line.decode().strip())" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Recapitulation\n", "\n", "Let's gather the above parts together as one would usually write code. First, all the imports, constants, and classes." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "# matplotlib graphics, choices include: inline, notebook, auto\n", "%matplotlib inline\n", "\n", "from apstools.devices import AD_full_file_name_local\n", "from apstools.devices import ensure_AD_plugin_primed\n", "from apstools.devices import CamMixin_V34\n", "from apstools.devices import SingleTrigger_V34\n", "from bluesky.callbacks.best_effort import BestEffortCallback\n", "from ophyd import ADComponent\n", "from ophyd.areadetector import DetectorBase\n", "from ophyd.areadetector import SimDetectorCam\n", "from ophyd.areadetector.filestore_mixins import FileStoreHDF5IterativeWrite\n", "from ophyd.areadetector.plugins import HDF5Plugin_V34 as HDF5Plugin\n", "from ophyd.areadetector.plugins import ImagePlugin_V34 as ImagePlugin\n", "import bluesky\n", "import bluesky.plans as bp\n", "import databroker\n", "import hdf5plugin # for LZ4, Blosc, or other compression codecs (not already in h5py)\n", "import matplotlib.pyplot as plt\n", "import pathlib\n", "\n", "plt.ion() # turn on matplotlib plots\n", "IOC = \"ad:\"\n", "\n", "AD_IOC_MOUNT_PATH = pathlib.Path(\"/tmp\")\n", "BLUESKY_MOUNT_PATH = pathlib.Path(\"/tmp/docker_ioc/iocad/tmp\")\n", "IMAGE_DIR = \"example/%Y/%m/%d\"\n", "\n", "# MUST end with a `/`, pathlib will NOT provide it\n", "WRITE_PATH_TEMPLATE = f\"{AD_IOC_MOUNT_PATH / IMAGE_DIR}/\"\n", "READ_PATH_TEMPLATE = f\"{BLUESKY_MOUNT_PATH / IMAGE_DIR}/\"\n", "\n", "class SimDetectorCam_V34(CamMixin_V34, SimDetectorCam):\n", " \"\"\"Revise SimDetectorCam for ADCore revisions.\"\"\"\n", "\n", "class MyHDF5Plugin(FileStoreHDF5IterativeWrite, HDF5Plugin):\n", " \"\"\"\n", " Add data acquisition methods to HDF5Plugin.\n", "\n", " * ``stage()`` - prepare device PVs befor data acquisition\n", " * ``unstage()`` - restore device PVs after data acquisition\n", " * ``generate_datum()`` - coordinate image storage metadata\n", " \"\"\"\n", "\n", " def stage(self):\n", " self.stage_sigs.move_to_end(\"capture\", last=True)\n", " super().stage()\n", "\n", "class SimDetector_V34(SingleTrigger_V34, DetectorBase):\n", " \"\"\"\n", " ADSimDetector\n", "\n", " SingleTrigger:\n", "\n", " * stop any current acquisition\n", " * sets image_mode to 'Multiple'\n", " \"\"\"\n", "\n", " cam = ADComponent(SimDetectorCam_V34, \"cam1:\")\n", " hdf1 = ADComponent(\n", " MyHDF5Plugin,\n", " \"HDF1:\",\n", " write_path_template=WRITE_PATH_TEMPLATE,\n", " read_path_template=READ_PATH_TEMPLATE,\n", " )\n", " image = ADComponent(ImagePlugin, \"image1:\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Next, create and configure the Python object for the detector:" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "adsimdet = SimDetector_V34(IOC, name=\"adsimdet\")\n", "adsimdet.wait_for_connection(timeout=15)\n", "adsimdet.missing_plugins() # confirm all plugins are defined\n", "\n", "adsimdet.read_attrs.append(\"hdf1\") # include `hdf1` plugin with 'adsimdet.read()'\n", "adsimdet.hdf1.create_directory.put(-5) # IOC may create up to 5 new subdirectories, as needed\n", "\n", "# override default settings from ophyd\n", "adsimdet.cam.stage_sigs[\"wait_for_plugins\"] = \"Yes\"\n", "adsimdet.hdf1.stage_sigs[\"blocking_callbacks\"] = \"No\"\n", "adsimdet.image.stage_sigs[\"blocking_callbacks\"] = \"No\"\n", "\n", "# apply some of our own customizations\n", "NUM_FRAMES = 5\n", "adsimdet.cam.stage_sigs[\"acquire_period\"] = 0.002\n", "adsimdet.cam.stage_sigs[\"acquire_time\"] = 0.001\n", "adsimdet.cam.stage_sigs[\"num_images\"] = NUM_FRAMES\n", "adsimdet.hdf1.stage_sigs[\"num_capture\"] = 0 # capture ALL frames received\n", "adsimdet.hdf1.stage_sigs[\"compression\"] = \"zlib\" # LZ4\n", "# adsimdet.hdf1.stage_sigs[\"queue_size\"] = 20\n", "\n", "# this step is needed for ophyd\n", "ensure_AD_plugin_primed(adsimdet.hdf1, True)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Prepare for data acquisition." ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "cat = databroker.temp().v2 # or use your own catalog: databroker.catalog[\"CATALOG_NAME\"]\n", "RE = bluesky.RunEngine({})\n", "RE.subscribe(cat.v1.insert)\n", "RE.subscribe(BestEffortCallback())\n", "RE.preprocessors.append(bluesky.SupplementalData())" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Take an image." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "Transient Scan ID: 1 Time: 2023-04-10 09:37:18\n", "Persistent Unique Scan ID: '9adfbe2b-2fd6-4ede-b50a-282fb6f3b7d3'\n", "New stream: 'primary'\n", "+-----------+------------+\n", "| seq_num | time |\n", "+-----------+------------+\n", "| 1 | 09:37:18.4 |\n", "+-----------+------------+\n", "generator count ['9adfbe2b'] (scan num: 1)\n", "\n", "\n", "\n", "local_file_name.exists()=True local_file_name=PosixPath('/tmp/docker_ioc/iocad/tmp/example/2023/04/10/8e5dad67-f838-412c-888c_000000.h5')\n" ] } ], "source": [ "uids = RE(\n", " bp.count(\n", " [adsimdet],\n", " md=dict(\n", " title=\"Area Detector with default HDF5 File Name\",\n", " purpose=\"image\",\n", " image_file_name_style=\"ophyd(uid)\",\n", " )\n", " )\n", ")\n", "\n", "# confirm the plugin captured the expected number of frames\n", "assert adsimdet.hdf1.num_captured.get() == NUM_FRAMES\n", "\n", "# Show the image file name on the bluesky (local) workstation\n", "# Use information from the 'adsimdet' object\n", "local_file_name = AD_full_file_name_local(adsimdet.hdf1)\n", "print(f\"{local_file_name.exists()=} {local_file_name=}\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "View the image using databroker." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "fname.exists()=True\n", "fname=PosixPath('/tmp/docker_ioc/iocad/tmp/example/2023/04/10/8e5dad67-f838-412c-888c_000000.h5')\n", "(local_file_name == fname)=True\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "run = cat.v2[uids[0]]\n", "dataset = run.primary.read()\n", "dataset[\"adsimdet_image\"][0][0].plot.pcolormesh()\n", "\n", "# Show the image file name on the bluesky (local) workstation\n", "# Use information from the databroker run\n", "_r = run.primary._resources[0]\n", "fname = pathlib.Path(f\"{_r['root']}{_r['resource_path']}\")\n", "print(f\"{fname.exists()=}\\n{fname=}\")\n", "\n", "# confirm the name above () is the same\n", "print(f\"{(local_file_name == fname)=}\")" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3.9.13 ('base')", "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.4" }, "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "f38aef175fb08dfc130a7d9bb9234f0792dc9ad861f95b6c05aedd1b380356e2" } } }, "nbformat": 4, "nbformat_minor": 2 }