diff --git a/.napari/DESCRIPTION.md b/.napari/DESCRIPTION.md index 9e9c586..afe94e9 100644 --- a/.napari/DESCRIPTION.md +++ b/.napari/DESCRIPTION.md @@ -93,4 +93,4 @@ yt-napari provides plugins to help load data from [yt](https://yt-project.org/) ![](https://raw.githubusercontent.com/data-exp-lab/yt-napari/main/docs/_static/nb_iso_galaxy_T_rho.png) -See the [full documentation](https://yt-napari.readthedocs.io) for more details. +See the [full documentation](https://yt-napari.readthedocs.io/en/stable/) for more details. diff --git a/HISTORY.md b/HISTORY.md index 31a3213..97ece4c 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1,3 +1,16 @@ +## v0.2.0 + +This release includes some non-backwards compatible changes to the schema. Old +json files will need to be updated to use with yt-napari >= v0.2.0 + +### New Features +* timeseries loading: a new widget, yt-napari timeseries slicer, is available from the napari gui and json files can also specify timeseries selections. Additionally, there is a new `yt_napari.timeseries` module for jupyter notebook interaction. + +### Breaking changes + +Breaking schema updates: +* the top level `data` attribute has been renamed `datasets` to distinguish between loading selections from a single timestep and the new `timeseries` selection + ## v0.1.0 This release includes some non-backwards compatible changes to the schema. Old diff --git a/README.md b/README.md index ada7468..fc6e347 100644 --- a/README.md +++ b/README.md @@ -48,6 +48,9 @@ To install the latest development version of the plugin instead, use: pip install git+https://github.com/data-exp-lab/yt-napari.git +Note that if you are working off the development version, be sure to use the latest documentation +for reference: https://yt-napari.readthedocs.io/en/latest/ + ## Quick Start After [installation](#Installation), there are three modes of using `yt-napari`: @@ -93,7 +96,9 @@ nbscreenshot(viewer) ![Loading a subset of a yt dataset in napari from a Jupyter notebook](./assets/images/readme_ex_001.png) -`yt_scene.add_to_viewer` accepts any of the keyword arguments allowed by `viewer.add_image`. See the full documentation (https://yt-napari.readthedocs.io/en/stable/) for more examples, including additional helper methods for linking layer appearance. +`yt_scene.add_to_viewer` accepts any of the keyword arguments allowed by `viewer.add_image`. See the full documentation ([yt-napari.readthedocs.io]) for more examples, including additional helper methods for linking layer appearance. + +Additionally, with `yt_napari`>= v0.2.0, you can use the `yt_napari.timeseries` module to help sample and load in selections from across datasets. ### loading a selection from a yt dataset interactively @@ -107,6 +112,13 @@ To use the yt Reader plugin, click on `Plugins -> yt-napari: yt Reader`. From th You can add multiple selections and load them all at once or adjust values and click "Load" again. +#### using the yt Time Series Reader plugin + +To use the yt Time Series Reader plugin, click on `Plugins -> yt-napari: yt Time Series Reader`. Specify your file matching: use `file_pattern` to enter glob expressions or use `file_list` to enter a list of specific files. +Then add a slice or region to sample for each matched dataset file (note: be careful of memory here!): + +![Loading timeseries selections from the napari viewer](./assets/images/readme_ex_004_gui_timeseries.gif) + #### using a json file and schema `yt-napari` also provides the ability to load json that contain specifications for loading a file. Properly formatted files can be loaded from the napari GUI as you would load any image file (`File->Open`). The json file describes the selection process for a dataset as described by a json-schema. The following json file results in similar layers as the above examples: @@ -114,16 +126,16 @@ You can add multiple selections and load them all at once or adjust values and c ```json {"$schema": "https://raw.githubusercontent.com/data-exp-lab/yt-napari/main/src/yt_napari/schemas/yt-napari_0.0.1.json", - "data": [{"filename": "IsolatedGalaxy/galaxy0030/galaxy0030", - "selections": {"regions": [{ - "fields": [{"field_name": "Temperature", "field_type": "enzo", "take_log": true}, - {"field_name": "Density", "field_type": "enzo", "take_log": true}], - "left_edge": [460.0, 460.0, 460.0], - "right_edge": [560.0, 560.0, 560.0], - "resolution": [600, 600, 600] - }]}, - "edge_units": "kpc" - }] + "datasets": [{"filename": "IsolatedGalaxy/galaxy0030/galaxy0030", + "selections": {"regions": [{ + "fields": [{"field_name": "Temperature", "field_type": "enzo", "take_log": true}, + {"field_name": "Density", "field_type": "enzo", "take_log": true}], + "left_edge": [460.0, 460.0, 460.0], + "right_edge": [560.0, 560.0, 560.0], + "resolution": [600, 600, 600] + }]}, + "edge_units": "kpc" + }] } ``` @@ -244,7 +256,7 @@ https://napari.org/plugins/stable/index.html [Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0 [Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt [cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin -[yt-napari.readthedocs.io]: https://yt-napari.readthedocs.io/ +[yt-napari.readthedocs.io]: https://yt-napari.readthedocs.io/en/stable/ [file an issue]: https://github.com/data-exp-lab/yt-napari/issues diff --git a/assets/images/readme_ex_004_gui_timeseries.gif b/assets/images/readme_ex_004_gui_timeseries.gif new file mode 100644 index 0000000..100bc70 Binary files /dev/null and b/assets/images/readme_ex_004_gui_timeseries.gif differ diff --git a/codecov.yml b/codecov.yml index eb761e3..6da0fe7 100644 --- a/codecov.yml +++ b/codecov.yml @@ -4,3 +4,7 @@ coverage: default: target: 98% # the required coverage value threshold: 0.1% # the leniency in hitting the target + patch: + default: + target: 98% + threshold: 0.1% diff --git a/docs/_static/yt-napari_0.2.0.json b/docs/_static/yt-napari_0.2.0.json new file mode 100644 index 0000000..6ed4f9f --- /dev/null +++ b/docs/_static/yt-napari_0.2.0.json @@ -0,0 +1,406 @@ +{ + "title": "InputModel", + "type": "object", + "properties": { + "datasets": { + "title": "Datasets", + "description": "list of dataset containers to load", + "type": "array", + "items": { + "$ref": "#/definitions/DataContainer" + } + }, + "timeseries": { + "title": "Timeseries", + "description": "List of timeseries to load", + "type": "array", + "items": { + "$ref": "#/definitions/Timeseries" + } + } + }, + "definitions": { + "ytField": { + "title": "ytField", + "type": "object", + "properties": { + "field_type": { + "title": "Field Type", + "description": "a field type in the yt dataset", + "type": "string" + }, + "field_name": { + "title": "Field Name", + "description": "a field in the yt dataset", + "type": "string" + }, + "take_log": { + "title": "Take Log", + "description": "if true, will apply log10 to the selected data", + "default": true, + "type": "boolean" + } + } + }, + "Left_Edge": { + "title": "Left_Edge", + "type": "object", + "properties": { + "value": { + "title": "Value", + "description": "3-element unitful tuple.", + "default": [ + 0.0, + 0.0, + 0.0 + ], + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ] + }, + "unit": { + "title": "Unit", + "description": "the unit length string.", + "default": "code_length", + "type": "string" + } + } + }, + "Right_Edge": { + "title": "Right_Edge", + "type": "object", + "properties": { + "value": { + "title": "Value", + "description": "3-element unitful tuple.", + "default": [ + 1.0, + 1.0, + 1.0 + ], + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ] + }, + "unit": { + "title": "Unit", + "description": "the unit length string.", + "default": "code_length", + "type": "string" + } + } + }, + "Region": { + "title": "Region", + "type": "object", + "properties": { + "fields": { + "title": "Fields", + "description": "list of fields to load for this selection", + "type": "array", + "items": { + "$ref": "#/definitions/ytField" + } + }, + "left_edge": { + "title": "Left Edge", + "description": "the left edge (min x, min y, min z)", + "allOf": [ + { + "$ref": "#/definitions/Left_Edge" + } + ] + }, + "right_edge": { + "title": "Right Edge", + "description": "the right edge (max x, max y, max z)", + "allOf": [ + { + "$ref": "#/definitions/Right_Edge" + } + ] + }, + "resolution": { + "title": "Resolution", + "description": "the resolution at which to sample between the edges.", + "default": [ + 400, + 400, + 400 + ], + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "integer" + }, + { + "type": "integer" + }, + { + "type": "integer" + } + ] + } + } + }, + "Length_Tuple": { + "title": "Length_Tuple", + "type": "object", + "properties": { + "value": { + "title": "Value", + "description": "3-element unitful tuple.", + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ] + }, + "unit": { + "title": "Unit", + "description": "the unit length string.", + "default": "code_length", + "type": "string" + } + } + }, + "Length_Value": { + "title": "Length_Value", + "type": "object", + "properties": { + "value": { + "title": "Value", + "description": "Single unitful value.", + "type": "number" + }, + "unit": { + "title": "Unit", + "description": "the unit length string.", + "default": "code_length", + "type": "string" + } + } + }, + "Slice": { + "title": "Slice", + "type": "object", + "properties": { + "fields": { + "title": "Fields", + "description": "list of fields to load for this selection", + "type": "array", + "items": { + "$ref": "#/definitions/ytField" + } + }, + "normal": { + "title": "Normal", + "description": "the normal axis of the slice", + "type": "string" + }, + "center": { + "title": "Center", + "description": "The center point of the slice, default domain center", + "allOf": [ + { + "$ref": "#/definitions/Length_Tuple" + } + ] + }, + "slice_width": { + "title": "Slice Width", + "description": "The slice width, defaults to full domain", + "allOf": [ + { + "$ref": "#/definitions/Length_Value" + } + ] + }, + "slice_height": { + "title": "Slice Height", + "description": "The slice width, defaults to full domain", + "allOf": [ + { + "$ref": "#/definitions/Length_Value" + } + ] + }, + "resolution": { + "title": "Resolution", + "description": "the resolution at which to sample the slice", + "default": [ + 400, + 400 + ], + "type": "array", + "minItems": 2, + "maxItems": 2, + "items": [ + { + "type": "integer" + }, + { + "type": "integer" + } + ] + }, + "periodic": { + "title": "Periodic", + "description": "should the slice be periodic? default False.", + "default": false, + "type": "boolean" + } + } + }, + "SelectionObject": { + "title": "SelectionObject", + "type": "object", + "properties": { + "regions": { + "title": "Regions", + "description": "a list of regions to load", + "type": "array", + "items": { + "$ref": "#/definitions/Region" + } + }, + "slices": { + "title": "Slices", + "description": "a list of slices to load", + "type": "array", + "items": { + "$ref": "#/definitions/Slice" + } + } + } + }, + "DataContainer": { + "title": "DataContainer", + "type": "object", + "properties": { + "filename": { + "title": "Filename", + "description": "the filename for the dataset", + "type": "string" + }, + "selections": { + "title": "Selections", + "description": "selections to load in this dataset", + "allOf": [ + { + "$ref": "#/definitions/SelectionObject" + } + ] + }, + "store_in_cache": { + "title": "Store In Cache", + "description": "if enabled, will store references to yt datasets.", + "default": true, + "type": "boolean" + } + } + }, + "TimeSeriesFileSelection": { + "title": "TimeSeriesFileSelection", + "type": "object", + "properties": { + "directory": { + "title": "Directory", + "description": "The directory of the timseries", + "type": "string" + }, + "file_pattern": { + "title": "File Pattern", + "description": "The file pattern to match", + "type": "string" + }, + "file_list": { + "title": "File List", + "description": "List of files to load.", + "type": "array", + "items": { + "type": "string" + } + }, + "file_range": { + "title": "File Range", + "description": "Given files matched by file_pattern, this option will select a range. Argument orderis taken as start:stop:step.", + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "integer" + }, + { + "type": "integer" + }, + { + "type": "integer" + } + ] + } + } + }, + "Timeseries": { + "title": "Timeseries", + "type": "object", + "properties": { + "file_selection": { + "$ref": "#/definitions/TimeSeriesFileSelection" + }, + "selections": { + "title": "Selections", + "description": "selections to load in this dataset", + "allOf": [ + { + "$ref": "#/definitions/SelectionObject" + } + ] + }, + "load_as_stack": { + "title": "Load As Stack", + "description": "If True, will stack images along a new dimension.", + "default": false, + "type": "boolean" + } + }, + "required": [ + "file_selection" + ] + } + } +} diff --git a/docs/_static/yt-napari_latest.json b/docs/_static/yt-napari_latest.json index b328aeb..6ed4f9f 100644 --- a/docs/_static/yt-napari_latest.json +++ b/docs/_static/yt-napari_latest.json @@ -2,13 +2,21 @@ "title": "InputModel", "type": "object", "properties": { - "data": { - "title": "Data", - "description": "list of data containers to load", + "datasets": { + "title": "Datasets", + "description": "list of dataset containers to load", "type": "array", "items": { "$ref": "#/definitions/DataContainer" } + }, + "timeseries": { + "title": "Timeseries", + "description": "List of timeseries to load", + "type": "array", + "items": { + "$ref": "#/definitions/Timeseries" + } } }, "definitions": { @@ -324,6 +332,75 @@ "type": "boolean" } } + }, + "TimeSeriesFileSelection": { + "title": "TimeSeriesFileSelection", + "type": "object", + "properties": { + "directory": { + "title": "Directory", + "description": "The directory of the timseries", + "type": "string" + }, + "file_pattern": { + "title": "File Pattern", + "description": "The file pattern to match", + "type": "string" + }, + "file_list": { + "title": "File List", + "description": "List of files to load.", + "type": "array", + "items": { + "type": "string" + } + }, + "file_range": { + "title": "File Range", + "description": "Given files matched by file_pattern, this option will select a range. Argument orderis taken as start:stop:step.", + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "integer" + }, + { + "type": "integer" + }, + { + "type": "integer" + } + ] + } + } + }, + "Timeseries": { + "title": "Timeseries", + "type": "object", + "properties": { + "file_selection": { + "$ref": "#/definitions/TimeSeriesFileSelection" + }, + "selections": { + "title": "Selections", + "description": "selections to load in this dataset", + "allOf": [ + { + "$ref": "#/definitions/SelectionObject" + } + ] + }, + "load_as_stack": { + "title": "Load As Stack", + "description": "If True, will stack images along a new dimension.", + "default": false, + "type": "boolean" + } + }, + "required": [ + "file_selection" + ] } } } diff --git a/docs/conf.py b/docs/conf.py index 2e93e0f..03309c4 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -18,7 +18,7 @@ # -- Project information ----------------------------------------------------- project = "yt-napari" -copyright = "2022, Chris Havlin, Matthew Turk" +copyright = "2023, Chris Havlin, Matthew Turk" author = "Chris Havlin, Matthew Turk" diff --git a/docs/examples/resources/yt_napari_timeseries_reg_vid.gif b/docs/examples/resources/yt_napari_timeseries_reg_vid.gif new file mode 100644 index 0000000..b9e9c6c Binary files /dev/null and b/docs/examples/resources/yt_napari_timeseries_reg_vid.gif differ diff --git a/docs/examples/resources/yt_napari_timeseries_regdask_vid.gif b/docs/examples/resources/yt_napari_timeseries_regdask_vid.gif new file mode 100644 index 0000000..0d65c6d Binary files /dev/null and b/docs/examples/resources/yt_napari_timeseries_regdask_vid.gif differ diff --git a/docs/examples/resources/yt_napari_timeseries_slice_vid.gif b/docs/examples/resources/yt_napari_timeseries_slice_vid.gif new file mode 100644 index 0000000..b91208a Binary files /dev/null and b/docs/examples/resources/yt_napari_timeseries_slice_vid.gif differ diff --git a/docs/examples/resources/yt_napari_timeseries_slice_vid_Mpc_scales.gif b/docs/examples/resources/yt_napari_timeseries_slice_vid_Mpc_scales.gif new file mode 100644 index 0000000..22a6c3a Binary files /dev/null and b/docs/examples/resources/yt_napari_timeseries_slice_vid_Mpc_scales.gif differ diff --git a/docs/examples/ytnapari_scene_01_intro.ipynb b/docs/examples/ytnapari_scene_01_intro.ipynb index 5494bc0..07cedb4 100644 --- a/docs/examples/ytnapari_scene_01_intro.ipynb +++ b/docs/examples/ytnapari_scene_01_intro.ipynb @@ -292,7 +292,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.9.0" } }, "nbformat": 4, diff --git a/docs/examples/ytnapari_scene_04_timeseries.ipynb b/docs/examples/ytnapari_scene_04_timeseries.ipynb new file mode 100644 index 0000000..38a3bdc --- /dev/null +++ b/docs/examples/ytnapari_scene_04_timeseries.ipynb @@ -0,0 +1,1149 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "f8843809-188a-44a7-901b-3ec5916da72a", + "metadata": {}, + "source": [ + "## Timeseries analysis in yt_napari \n", + "\n", + "Similar to loading single datasets, `yt_napari` includes a number of ways to load in timeseries data: the `json` file reader, the napari widget and a jupyter notebook. From a jupyter notebook, you can use `yt_napari.timeseries.add_to_viewer` to specify a set of files to sequentially load and sample and add to an existing `napari.Viewer`. \n", + "\n", + "This notebook describes:\n", + "\n", + "* `yt_napari.timeseries` Selection objects\n", + "* using `yt_napari.timeries.add_to_viewer` to apply a selection to a series of files that you specify and then add those to a `napari.Viewer` instance\n", + "* loading timeseries samples as individual layers or a single image stack \n", + "* centering selections\n", + "\n", + "As a preview, here's a video showing the density field in a 15 Mpc wide region from the `enzo_tiny_cosmology` sample yt dataset centered on the location of the maximum density of the final timestep in the series:\n", + "\n", + "![](./resources/yt_napari_timeseries_reg_vid.gif)\n", + "\n", + "\n", + "## Quickstart\n", + "\n", + "Before diving into details, the following code blocks load a slice for each timestep of the `enzo_tiny_cosmology` sample dataset and adds it to a napari `Viewer` as a single 3D image stack with dimensions of (timestep, y, z). Note that it will take a bit of time to run the timestep sampling (around 30-60s depending on your machine). \n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "84b126c1-e7cd-4040-9fc5-4a9b3bd76025", + "metadata": {}, + "outputs": [], + "source": [ + "from yt_napari import timeseries\n", + "import yt\n", + "import napari \n", + "\n", + "yt.set_log_level(50) # disable logging to keep notebook output manageable\n", + "v = napari.Viewer()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "aa424da6-ee7c-4115-b71b-3d2df6e0ec20", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "s = timeseries.Slice(('enzo', 'Density'), 'x')\n", + "timeseries.add_to_viewer(v, s, file_pattern = \"enzo_tiny_cosmology/DD????/DD????\", \n", + " load_as_stack=True, \n", + " colormap='magma',\n", + " name='enzo_tiny_cosmo_density')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "555f505e-0781-4836-8a43-44eefd527605", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\"\"" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from napari.utils import nbscreenshot\n", + "nbscreenshot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "8fa10c5b-dc8f-4ec0-9944-7fac21cc32d5", + "metadata": {}, + "source": [ + "The slider beneath the main viewer will let you step through time. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5652e6af-cb59-480e-935b-d086dfbe1948", + "metadata": {}, + "outputs": [], + "source": [ + "v.close()" + ] + }, + { + "cell_type": "markdown", + "id": "b8861f0d-24b2-4765-8edd-545058ca86cf", + "metadata": {}, + "source": [ + "## Detailed Walkthrough \n", + "\n", + "### Selection objects \n", + "\n", + "One difference between `yt-napari` and `yt` proper is that when sampling a time series, you first specify a selection object **independently** from a dataset object to define the extents and field of selection. That selection is then applied across all specified timesteps.\n", + "\n", + "The currently available selection objects are a `Slice` or 3D gridded `Region`. The arguments follow the same convention as a usual `yt` dataset selection object (i.e., `ds.slice`, `ds.region`) for specifying the geometric bounds of the selection with the additional constraint that you must specify a single field and the resolution you want to sample at:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3447e17a-c726-42a0-9b8e-f117bf2aefe5", + "metadata": {}, + "outputs": [], + "source": [ + "from yt_napari import timeseries" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c1d9750f-7bd6-4d76-99d9-dead91fcda8f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mtimeseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSlice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfield\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnormal\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mcenter\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0munyt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munyt_array\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mwidth\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0munyt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munyt_quantity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mheight\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0munyt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munyt_quantity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mresolution\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m400\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m400\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mperiodic\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtake_log\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "A 2D axis-normal slice through a domain.\n", + "\n", + "Parameters\n", + "----------\n", + "field: (str, str)\n", + " a yt field present in all timeseries to load.\n", + "normal: int or str\n", + " the normal axis for slicing\n", + "center: unyt_array\n", + " (optional) a 3-element unyt_array defining the slice center, defaults\n", + " to the domain center of each active timestep.\n", + "width: unyt_quantity or (value, unit)\n", + " (optional) the slice width, defaults to the domain width of each active\n", + " timestep.\n", + "height: unyt_quantity or (value, unit)\n", + " (optional) the slice height, defaults to the domain height of each\n", + " active timestep.\n", + "resolution: (int, int)\n", + " (optional) 2-element tuple defining the resolution to sample at. Default\n", + " is (400, 400).\n", + "periodic: bool\n", + " (optional, default is False) If True, treat domain as periodic\n", + "take_log: bool\n", + " (optional) If True, take the log10 of the sampled field. Defaults to the\n", + " default behavior for the field in the dataset.\n", + "\u001b[0;31mFile:\u001b[0m ~/src/yt_general/napari_work/yt-napari/src/yt_napari/timeseries.py\n", + "\u001b[0;31mType:\u001b[0m ABCMeta\n", + "\u001b[0;31mSubclasses:\u001b[0m " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "timeseries.Slice?" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0990c03d-a908-4961-a445-80781f2b0261", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mtimeseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRegion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfield\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mleft_edge\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0munyt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munyt_array\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mright_edge\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0munyt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munyt_array\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mresolution\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m400\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m400\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m400\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtake_log\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "A 3D rectangular selection through a domain.\n", + "\n", + "Parameters\n", + "----------\n", + "field: (str, str)\n", + " a yt field present in all timeseries to load.\n", + "left_edge: unyt_array or (ndarray, str)\n", + " (optional) a 3-element unyt_array defining the left edge of the region,\n", + " defaults to the domain left_edge of each active timestep.\n", + "right_edge: unyt_array or (ndarray, str)\n", + " (optional) a 3-element unyt_array defining the right edge of the region,\n", + " defaults to the domain right_edge of each active timestep.\n", + "resolution: (int, int, int)\n", + " (optional) 3-element tuple defining the resolution to sample at. Default\n", + " is (400, 400, 400).\n", + "take_log: bool\n", + " (optional) If True, take the log10 of the sampled field. Defaults to the\n", + " default behavior for the field in the dataset.\n", + "\u001b[0;31mFile:\u001b[0m ~/src/yt_general/napari_work/yt-napari/src/yt_napari/timeseries.py\n", + "\u001b[0;31mType:\u001b[0m ABCMeta\n", + "\u001b[0;31mSubclasses:\u001b[0m " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "timeseries.Region?" + ] + }, + { + "cell_type": "markdown", + "id": "edd2babf-5aae-4d2f-8079-96a68b594b22", + "metadata": {}, + "source": [ + "Once you create a `Slice` or `Region`, you can pass that to `add_to_viewer` and it will be used to sample each timestep specified. \n", + "\n", + "## Slices through a timeseries\n", + "\n", + "The simplest case is when you want to extract the same 2D slice through a timeseries. \n", + "\n", + "To start, let's initialize a `napari` viewer:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "22fdc7c3-6e06-498e-8497-b6064bc9b910", + "metadata": {}, + "outputs": [], + "source": [ + "import napari " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f95a2b8b-769f-4ee6-91bb-744ae2953d4b", + "metadata": {}, + "outputs": [], + "source": [ + "v = napari.Viewer()" + ] + }, + { + "cell_type": "markdown", + "id": "f3ee393c-1bbe-40fc-b401-4d7862f899a8", + "metadata": {}, + "source": [ + "and let's build the `Slice` object that will get applied to each timestep. To do so, you need to at least specify the field to sample and the normal axis for the slice:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "70056566-50cd-4e21-b72c-0bf37a54d61f", + "metadata": {}, + "outputs": [], + "source": [ + "s = timeseries.Slice(('enzo', 'Density'), 'x') " + ] + }, + { + "cell_type": "markdown", + "id": "982830bd-5ce8-471f-a05b-697ecb8031ae", + "metadata": {}, + "source": [ + "### adding a timeseries to a viewer (`add_to_viewer`)\n", + "\n", + "From here, you pass the viewer and selection object to `timeseries.add_to_viewer` along with some options for specifying what files to load and some parameters controlling how the data is eventually loaded:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "939220c9-f4ff-4f3b-9e4f-1067fbf7d042", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mtimeseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_to_viewer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mviewer\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnapari\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mviewer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mViewer\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mselection\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0myt_napari\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtimeseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSlice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myt_napari\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtimeseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRegion\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfile_dir\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfile_pattern\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfile_list\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfile_range\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mload_as_stack\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0muse_dask\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mreturn_delayed\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mstack_scaling\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Sample a timeseries and add to a napari viewer\n", + "\n", + "Parameters\n", + "----------\n", + "viewer: napari.Viewer\n", + " a napari Viewer instance\n", + "selection: Slice or Region\n", + " the selection to apply to each matched dataset\n", + "file_dir: str\n", + " (optional) a file directory to prepend to either the file_pattern or\n", + " file_list argument.\n", + "file_pattern: str\n", + " (optional) a file pattern to match, not used if file_list is set. One of\n", + " file_pattern or file_list must be set.\n", + "file_list: str\n", + " (optional) a list of files to use. One of file_list or file_pattern must\n", + " be set.\n", + "file_range: (int, int, int)\n", + " (optional) A range to limit matched files in the form (start, stop, step).\n", + "load_as_stack: bool\n", + " (optional, default False) If True, the timeseries will be stacked to a\n", + " single image array\n", + "use_dask: bool\n", + " (optional, default False) If True, use dask to assemble the image array\n", + "return_delayed: bool\n", + " (optional, default True) If True and if use_dask=True, then the image\n", + " array will be a delayed array, resulting in lazy loading in napari. If\n", + " False and if use_dask=True, then dask will distribute sampling tasks\n", + " and assemble a final in-memory array.\n", + "stack_scaling: float\n", + " (optional, default 1.0) Applies a scaling to the effective image array\n", + " in the stacked (time) dimension if load_as_stack is True. If scale is\n", + " provided as a separate parameter, then stack_scaling is only used if\n", + " the len(scale) matches the dimensionality of the spatial selection.\n", + "**kwargs\n", + " any additional keyword arguments are passed to napari.Viewer().add_image()\n", + "\n", + "Examples\n", + "--------\n", + "\n", + ">>> import napari\n", + ">>> from yt_napari.timeseries import Slice, add_to_viewer\n", + ">>> viewer = napari.Viewer()\n", + ">>> slc = Slice((\"enzo\", \"Density\"), \"x\")\n", + ">>> enzo_files = \"enzo_tiny_cosmology/DD????/DD????\"\n", + ">>> add_to_viewer(viewer, slc, file_pattern=enzo_files, file_range=(0,47, 5),\n", + ">>> load_as_stack=True)\n", + "\u001b[0;31mFile:\u001b[0m ~/src/yt_general/napari_work/yt-napari/src/yt_napari/timeseries.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "timeseries.add_to_viewer?" + ] + }, + { + "cell_type": "markdown", + "id": "f45096ed-baab-493e-98da-26cede706f05", + "metadata": {}, + "source": [ + "### specifying the datasets \n", + "\n", + "Similar to the `yt` `DataSeries` object, you can specify the files corresponding to the timesteps of interest in a number of ways:\n", + "\n", + "* file_pattern : a glob pattern string to identify files, e.g., `\"DD????/DD????\"`. \n", + "* file_list: an explicit list of files \n", + "\n", + "Additionally, if you specify `file_dir`, then both the `file_pattern` and `file_list` arguments will be joined to `file_dir` so that you can specify, for example,\n", + "\n", + "```python\n", + "timeseries.add_to_viewer(v, s, file_list=[\"file_1\", \"file_2\", ...], file_dir='my/datset/dir')\n", + "```\n", + "rather than `file_list=[\"my/datset/dir/file_1\", \"my/datset/dir/file_2\", ...]`. \n", + "\n", + "If a file is not found in your current path, it will check the yt `test_data_dir` configuration directory.\n", + "\n", + "\n", + "**Finally**, you can also use the `file_range` parameter to limit the datasets picked up by `file_pattern` matches. The `file_range` parameter is a 3-element tuple representing a selection range with (start, end, step) so that you can, for example, select every 5th dataset matched by the `file_pattern`. " + ] + }, + { + "cell_type": "markdown", + "id": "ef833ed0-10af-490d-973f-881f8c506808", + "metadata": {}, + "source": [ + "### loading as a stack\n", + "So we're now ready to load our timeseries! If you just call `add_to_viewer`, each timestep will be added as a separate layer in napari. Since we're loading 47 timesteps here, we'll also supply the `load_as_stack=True` parameter so that the slices get added as a single image array:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "adcd6977-5d78-4789-863c-c69e4a91da95", + "metadata": {}, + "outputs": [], + "source": [ + "file_pattern = \"enzo_tiny_cosmology/DD????/DD????\"" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c6bbb063-7e71-467b-98be-9d6668b6a379", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 32.8 s, sys: 492 ms, total: 33.3 s\n", + "Wall time: 33.3 s\n" + ] + } + ], + "source": [ + "%%time\n", + "%%capture\n", + "yt.set_log_level(40)\n", + "timeseries.add_to_viewer(v,s,file_pattern=file_pattern, load_as_stack=True, colormap='magma');" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "1ef897d6-ff98-44d3-a67c-da8f31913937", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\"\"" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nbscreenshot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "c870bc58-8e78-4703-a920-0eb28cade01b", + "metadata": {}, + "source": [ + "### loading a range of matches \n", + "\n", + "In the case above, we are loading in 47 timesteps. We can also specify a `file_range` tuple in the form of `(start, stop, step)`, and the identified files will be subsampled from the full range of matched files. To extract every 10th, for example:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0b8fbdba-44c0-455c-ad85-53218afc7338", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 3.75 s, sys: 272 ms, total: 4.02 s\n", + "Wall time: 3.57 s\n" + ] + } + ], + "source": [ + "%%time\n", + "%%capture\n", + "v.layers.clear()\n", + "timeseries.add_to_viewer(v,s,file_pattern=file_pattern, file_range=(0, 50, 10), load_as_stack=True, colormap='magma');" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a369e197-6e84-4767-920c-be8635c1fde4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\"\"" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nbscreenshot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "091e5dd2-0c6a-4bf6-9d63-5f432f07633b", + "metadata": {}, + "source": [ + "### loading specific timesteps \n", + "\n", + "And finally, you can specify the exact files you want with `file_list`. If you also provide a `file_dir`, it will get pre-prended to the filenames in `file_list` to save you some typing. In this case, since only 3 timesteps are specified, we can omit the `load_as_stack` argument to instead load them as separate layers:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "616805e0-be59-4787-b0b8-a511ed2e5016", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2.4 s, sys: 312 ms, total: 2.72 s\n", + "Wall time: 2.2 s\n" + ] + } + ], + "source": [ + "%%time\n", + "%%capture\n", + "v.layers.clear()\n", + "flist = [\"DD0024/DD0024\", \"DD0034/DD0034\", \"DD0041/DD0041\"]\n", + "timeseries.add_to_viewer(v, s, file_dir=\"enzo_tiny_cosmology\", file_list=flist, \n", + " contrast_limits=(-1, 2), colormap='magma');" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1b22537c-29c3-4317-b388-ce2d8d34056f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\"\"" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nbscreenshot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "4970bb95-ebdf-4476-8597-557fc3b0dd8d", + "metadata": {}, + "source": [ + "## Sampling a Region through a timeseries\n", + "\n", + "The `yt_napari.timeseires.Region` selection object behaves much the same way. The `field` is the only required argument, with default bounds being taken from the full domain of each timestep loaded in (note that if the bounds of your simulation change over time you should specify edge values to load in). \n", + "\n", + "**Importantly**, you have to be careful loading in regions as it's very easy to exceed the available memory on your machine. The next notebook describes how to leverage dask for lazy loading of timeseries samples, but for now we'll just load in a small subset of timesteps. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "978b8946-224b-49c4-8728-562b3756b823", + "metadata": {}, + "outputs": [], + "source": [ + "reg = timeseries.Region((\"enzo\", \"Temperature\"))" + ] + }, + { + "cell_type": "markdown", + "id": "153426a3-de92-4196-9c9d-ad7f784c0334", + "metadata": {}, + "source": [ + "now when we supply `load_as_stack`, our 3D arrays will become 4D arrays!" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "5861f41c-3e7e-4729-94b3-8d00123b1f5d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 4.98 s, sys: 1.06 s, total: 6.04 s\n", + "Wall time: 5.56 s\n" + ] + } + ], + "source": [ + "%%time\n", + "%%capture\n", + "v.layers.clear()\n", + "flist = [\"DD0024/DD0024\", \"DD0034/DD0034\", \"DD0041/DD0041\"]\n", + "timeseries.add_to_viewer(v, reg, file_dir=\"enzo_tiny_cosmology\", file_list=flist, \n", + " colormap='magma', load_as_stack=True, name=\"Temp_series\");" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "0dd14d1f-b625-4f4b-b31a-fea17b14dd12", + "metadata": {}, + "outputs": [], + "source": [ + "v.dims.ndisplay=3\n", + "v.camera.angles = (15, 15, 75)\n", + "v.camera.zoom = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "2e4243fa-c6ea-4dd7-b85e-b705d05b8c28", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\"\"" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nbscreenshot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "0bc58d80-ae7f-4f72-9ae5-03dd089cf928", + "metadata": {}, + "source": [ + "The slider beneath the viewer will let you step through time." + ] + }, + { + "cell_type": "markdown", + "id": "cebeb7c6-9cd5-41ff-a662-d47a08dfcf6c", + "metadata": {}, + "source": [ + "## Positioning your selections \n", + "\n", + "The `Slice` and `Region` objects do not have any of `yt`'s helpful automatic centering functionality implemented at present. So if, for example, you want to center your `Region` on the maximum density of the final timestep, you'll want to first load in that timestep and find the position of the max value then use that to build your `Region`. \n", + "\n", + "The following walks through such an example. \n", + "\n", + "First, load in a single timestep as a standard `yt` dataset: " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8f9f2e7c-50b6-46d8-9f73-f701482b71eb", + "metadata": {}, + "outputs": [], + "source": [ + "ds = yt.load(\"enzo_tiny_cosmology/DD0046/DD0046\")" + ] + }, + { + "cell_type": "markdown", + "id": "7311f530-f8cc-4d9d-abaf-737379c9898f", + "metadata": {}, + "source": [ + "and then find the location of the maximum density value:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d73d0fb2-f9fc-4c66-87c2-e8c618cc0fa8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Parsing Hierarchy : 100%|███████████████████| 211/211 [00:00<00:00, 9782.66it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "[unyt_quantity(101654.2578125, 'code_mass/code_length**3'),\n", + " unyt_quantity(0.55517578, 'code_length'),\n", + " unyt_quantity(0.66357422, 'code_length'),\n", + " unyt_quantity(0.85888672, 'code_length')]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ad = ds.all_data()\n", + "max_dens = ad.quantities.max_location((\"enzo\", \"Density\"))\n", + "max_dens" + ] + }, + { + "cell_type": "markdown", + "id": "6745ca30-7398-4b8f-9738-9b0551a40024", + "metadata": {}, + "source": [ + "and store the max location as an array to use later:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "57a36906-645d-49fa-9409-924182606e99", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "unyt_array([0.55517578, 0.66357422, 0.85888672], 'code_length')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reg_c = ds.arr(max_dens[1:], 'code_length')\n", + "reg_c" + ] + }, + { + "cell_type": "markdown", + "id": "29c67189-d688-4d00-9ee2-fc46f5d291a1", + "metadata": {}, + "source": [ + "### centered Slice\n", + "\n", + "Now we can build a slice centered on the above array and sample that slice through the timeseries:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "a722b3ec-f7f8-4f32-8ef0-f02ccf1e1e12", + "metadata": {}, + "outputs": [], + "source": [ + "wid = ds.quan(15, 'Mpc')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "acc39bec-228e-406c-a4ef-b567b9ac57c3", + "metadata": {}, + "outputs": [], + "source": [ + "slc = timeseries.Slice((\"enzo\", \"Density\"), \"x\", center=reg_c, width=wid, height=wid, resolution=(400, 400))" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "4325790e-aabc-49d9-9980-d77a7d1f53c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 33.1 s, sys: 513 ms, total: 33.6 s\n", + "Wall time: 33.1 s\n" + ] + } + ], + "source": [ + "%%time\n", + "%%capture\n", + "v.layers.clear()\n", + "file_pattern = \"enzo_tiny_cosmology/DD????/DD????\"\n", + "timeseries.add_to_viewer(v, slc, file_pattern=file_pattern, \n", + " colormap='magma', load_as_stack=True, name=\"Density_slice_series\");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d77a9620-ee2a-48c4-84d4-7ed9364df5f3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "b5b3dd48-f1e0-4194-adfd-599fefe4c84e", + "metadata": {}, + "source": [ + "The following is a video of stepping through the timeseries:" + ] + }, + { + "cell_type": "markdown", + "id": "b4be8549-9e7b-4401-a0c1-216b0a4e560a", + "metadata": {}, + "source": [ + "![](./resources/yt_napari_timeseries_slice_vid.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "373b3619-efc4-47fd-914e-d8c4bee1a61f", + "metadata": {}, + "source": [ + "### centered Region" + ] + }, + { + "cell_type": "markdown", + "id": "b158d669-9985-41ba-bd1e-bbf6f333c0f3", + "metadata": {}, + "source": [ + "In order to be able to sample all of the timesteps in memory, the following sets a fairly low resolution 3D sample. We'll reuse the center location and calculate a left and right edge releative to that center:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "5173a0fa-6658-49de-ab90-99f27816baeb", + "metadata": {}, + "outputs": [], + "source": [ + "hwid = wid/2.\n", + "le = reg_c - hwid\n", + "re = reg_c + hwid\n", + "le, re\n", + "reg = timeseries.Region((\"enzo\", \"Density\"), left_edge=le, right_edge=re, \n", + " resolution=(50, 50, 50))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "390d1b5c-1a75-40cf-ace7-2fd544b0b170", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 33.3 s, sys: 522 ms, total: 33.8 s\n", + "Wall time: 33.2 s\n" + ] + } + ], + "source": [ + "%%time\n", + "%%capture\n", + "v.layers.clear()\n", + "file_pattern = \"enzo_tiny_cosmology/DD????/DD????\"\n", + "timeseries.add_to_viewer(v, reg, file_pattern=file_pattern, \n", + " colormap='magma', load_as_stack=True, name=\"Density_series\");" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "fef51cff-34c7-454a-8e4b-c2b1b7c40e16", + "metadata": {}, + "outputs": [], + "source": [ + "v.dims.ndisplay=3" + ] + }, + { + "cell_type": "markdown", + "id": "247ae530-8dbf-4c03-8bb2-e48d0b42b5d7", + "metadata": {}, + "source": [ + "![](./resources/yt_napari_timeseries_reg_vid.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "0d706d2e-9679-45b7-96c9-fa1a0e44a305", + "metadata": {}, + "source": [ + "## A note on spatial scales and unit registries\n", + "\n", + "In the previous two examples, we directly used the unyt array for the location of the max density (`reg_c` above) from one of our datasets. This particular simulation is a cosmological simulation in which the bounds of the domain actually change with time depending on what length unit you look at. In physical distance, `ds.domain_width('Mpc')` increases throughout the simulation. The co-moving distance, however, does not (`ds.domain_width('Mpccm')` is fixed through time). \n", + "\n", + "So depending on how you provide arguments to the `Slice` and `Region` objects, you can end up with different behaviors. \n", + "\n", + "In the previous `Slice` example, by provding both a center and width argument, the spatial extents of the slice are calculated immediately, so the extents of the slice will evaluate to:" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "c5ba3082-2991-4926-98df-1b2deae66d1f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(unyt_array([0.49904297, 0.69435547], 'code_length'),\n", + " unyt_array([0.82810547, 1.02341797], 'code_length'))" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wid = ds.quan(15, 'Mpc')\n", + "reg_c[1:] - wid/2, reg_c[1:] + wid/2" + ] + }, + { + "cell_type": "markdown", + "id": "2cbfb1fa-2448-45aa-999e-ba61d6b7c5b4", + "metadata": {}, + "source": [ + "so that for each time step, that `code_length` range is sampled and we are effectively supplying our slice extents in co-moving coordinates. \n", + "\n", + "If we instead specify the center and width as " + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "87ba91cb-2dfe-4d43-a3ec-95e5f0f4db99", + "metadata": {}, + "outputs": [], + "source": [ + "c = (reg_c.d, 'code_length')\n", + "wid = (15, 'Mpc')" + ] + }, + { + "cell_type": "markdown", + "id": "f9013a1f-bbac-464a-8e64-ca024663d613", + "metadata": {}, + "source": [ + "then for each time step, the slice will still be centered on the same co-moving coordinate location, but the extent of the slice will be re-calculate at each timestep, resulting in a slice extent that varies by timestep. Because the early steps of the simulation are much less than 15 Mpc wide, this results in a slice that grows in time:" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "1b71ad00-e553-4081-a51c-0a26c8b57938", + "metadata": {}, + "outputs": [], + "source": [ + "slc = timeseries.Slice((\"enzo\", \"Density\"), \"x\", center=c, width=wid, height=wid, resolution=(400, 400))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "57315300-b2ee-49d9-b545-2ce9000972ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 33.4 s, sys: 599 ms, total: 34 s\n", + "Wall time: 34.7 s\n" + ] + } + ], + "source": [ + "%%time\n", + "%%capture\n", + "v.layers.clear()\n", + "file_pattern = \"enzo_tiny_cosmology/DD????/DD????\"\n", + "timeseries.add_to_viewer(v, slc, file_pattern=file_pattern, \n", + " colormap='magma', load_as_stack=True, name=\"Density_slice_series\", \n", + " stack_scaling = 5.0\n", + " );" + ] + }, + { + "cell_type": "markdown", + "id": "49ae913d-f6a5-4279-927f-3c98e5066f18", + "metadata": {}, + "source": [ + "The following video shows how the slice now changes through time. In the final parts of the video, the viewer dimensionality is changed to 3D, resulting in a 2D spatial + 1D time view in which the time axis scaling is controlled by the above `stack_scaling` parameter. " + ] + }, + { + "cell_type": "markdown", + "id": "7ef1750d-d81e-4346-8af0-a278d97c855d", + "metadata": {}, + "source": [ + "![](resources/yt_napari_timeseries_slice_vid_Mpc_scales.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "a0a4fe40-e063-4bad-88d0-ff86d03a9ea7", + "metadata": {}, + "source": [ + "You can recover the original behavior by instead specifying the width in co-moving distance:" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "e9c238ac-427a-42b3-9cab-1ba894f4dde7", + "metadata": {}, + "outputs": [], + "source": [ + "c = (reg_c.d, 'code_length')\n", + "wid = (15, 'Mpccm')\n", + "slc = timeseries.Slice((\"enzo\", \"Density\"), \"x\", center=c, width=wid, height=wid, resolution=(400, 400))" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "91f97b17-09a4-40bd-86ca-82e1d92545a4", + "metadata": {}, + "outputs": [], + "source": [ + "v = napari.Viewer()" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "3ed3573d-c851-49d3-af13-19c45f7d38bf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 33.7 s, sys: 478 ms, total: 34.2 s\n", + "Wall time: 34.4 s\n" + ] + } + ], + "source": [ + "%%time\n", + "%%capture\n", + "v.layers.clear()\n", + "file_pattern = \"enzo_tiny_cosmology/DD????/DD????\"\n", + "timeseries.add_to_viewer(v, slc, file_pattern=file_pattern, \n", + " colormap='magma', load_as_stack=True, name=\"Density_slice_series\", \n", + " stack_scaling = 5.0\n", + " );" + ] + }, + { + "cell_type": "markdown", + "id": "eead99f9-5de8-4af7-9979-d34291da74ae", + "metadata": {}, + "source": [ + "## A note on high resolution samples and larger-than memory arrays\n", + "\n", + "Loading in 3D regions at higher resolutions can quickly exceed the available memory on your machine if you load more than a few timesteps. To handle those cases, you can lazily load data with the `use_dask` parameter of `timeseries.add_to_viewer()`. The next notebook walks through its usage." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "30c6176c-332d-4d79-906f-2884cfff58d2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/ytnapari_scene_05_timeseries_dask.ipynb b/docs/examples/ytnapari_scene_05_timeseries_dask.ipynb new file mode 100644 index 0000000..d31145e --- /dev/null +++ b/docs/examples/ytnapari_scene_05_timeseries_dask.ipynb @@ -0,0 +1,694 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "09edeb95-5173-4c68-b406-b23e8101db09", + "metadata": {}, + "source": [ + "## Leveraging Dask for timeseries sampling\n", + "\n", + "When loading timeseries selections that would be too large to fit in memory, or to speed up timeseries slicing, you can leverage dask to return lazy arrays to napari to point to yt datasets of a timeseries. The two relevant parameters to `yt_napari.timeseries.add_to_viewer()` are `use_dask` and `return_delayed`. \n", + "\n", + "But first, we'll spin up a dask client. \n", + "\n", + "As a side note -- `yt` is generally not guaranteed to be threadsafe. But in practice, the sampling in `yt_napari` does tend to be thread safe as long as you disable `yt`'s logging, which `timeseries.add_to_viewer` does internally. \n", + "\n", + "With that said, we'll spin up a dask client with 5 workers and 5 threads per worker:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "603c648a-95a7-48a9-bf1a-54919a273955", + "metadata": {}, + "outputs": [], + "source": [ + "from dask.distributed import Client " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1ed33f93-3ef5-407f-b3d1-8a6e03d3fe70", + "metadata": {}, + "outputs": [], + "source": [ + "c = Client(n_workers=5, threads_per_worker=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4cea9a5b-2552-4ba0-82b3-2ce38d984d5f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + "

Client

\n", + "

Client-2d8dc34d-387b-11ee-9086-9d370e7ce927

\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
Connection method: Cluster objectCluster type: distributed.LocalCluster
\n", + " Dashboard: http://127.0.0.1:8787/status\n", + "
\n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "

Cluster Info

\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

LocalCluster

\n", + "

c1666a68

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + "
\n", + " Dashboard: http://127.0.0.1:8787/status\n", + " \n", + " Workers: 5\n", + "
\n", + " Total threads: 25\n", + " \n", + " Total memory: 31.18 GiB\n", + "
Status: runningUsing processes: True
\n", + "\n", + "
\n", + " \n", + "

Scheduler Info

\n", + " \n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

Scheduler

\n", + "

Scheduler-5a7d3503-49f5-4332-82e8-b154d3eafca2

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Comm: tcp://127.0.0.1:35003\n", + " \n", + " Workers: 5\n", + "
\n", + " Dashboard: http://127.0.0.1:8787/status\n", + " \n", + " Total threads: 25\n", + "
\n", + " Started: Just now\n", + " \n", + " Total memory: 31.18 GiB\n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "

Workers

\n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 0

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:35913\n", + " \n", + " Total threads: 5\n", + "
\n", + " Dashboard: http://127.0.0.1:35249/status\n", + " \n", + " Memory: 6.24 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:33663\n", + "
\n", + " Local directory: /tmp/dask-scratch-space/worker-7h4d23b0\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 1

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:33403\n", + " \n", + " Total threads: 5\n", + "
\n", + " Dashboard: http://127.0.0.1:45843/status\n", + " \n", + " Memory: 6.24 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:40573\n", + "
\n", + " Local directory: /tmp/dask-scratch-space/worker-m13_1ufj\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 2

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:38589\n", + " \n", + " Total threads: 5\n", + "
\n", + " Dashboard: http://127.0.0.1:44207/status\n", + " \n", + " Memory: 6.24 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:35659\n", + "
\n", + " Local directory: /tmp/dask-scratch-space/worker-01k1x21b\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 3

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:46161\n", + " \n", + " Total threads: 5\n", + "
\n", + " Dashboard: http://127.0.0.1:35787/status\n", + " \n", + " Memory: 6.24 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:34299\n", + "
\n", + " Local directory: /tmp/dask-scratch-space/worker-mb2cnhta\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "

Worker: 4

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + " Comm: tcp://127.0.0.1:39687\n", + " \n", + " Total threads: 5\n", + "
\n", + " Dashboard: http://127.0.0.1:42663/status\n", + " \n", + " Memory: 6.24 GiB\n", + "
\n", + " Nanny: tcp://127.0.0.1:43027\n", + "
\n", + " Local directory: /tmp/dask-scratch-space/worker-vtv_1v28\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c" + ] + }, + { + "cell_type": "markdown", + "id": "f009382d-ac3c-4a01-a810-18c6d48fa79a", + "metadata": {}, + "source": [ + "and let's import our packages and initialize a napari viewer:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "398d22f7-de0b-407f-8f3b-ba58e83b2d2f", + "metadata": {}, + "outputs": [], + "source": [ + "import napari \n", + "from yt_napari import timeseries\n", + "v = napari.Viewer()" + ] + }, + { + "cell_type": "markdown", + "id": "90ea8450-3fda-447c-a0b7-0dac243e930c", + "metadata": {}, + "source": [ + "## Delayed image stacks \n", + "\n", + "When supplying `use_dask`, it is recommended that you also use `load_as_stack`, which results in a napari image layer where only the active slice is loaded in memory. Note that it's good to provide the `contrast_limits` here as well so that the image is normalized across timesteps. \n", + "\n", + "For 2D slices:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "971adebb-aa63-42d8-a553-63df627e815c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Parsing Hierarchy : 100%|██████████| 2/2 [00:00<00:00, 17119.61it/s]\n", + "Parsing Hierarchy : 100%|██████████| 120/120 [00:00<00:00, 17126.02it/s]\n" + ] + } + ], + "source": [ + "%%capture\n", + "slc = timeseries.Slice((\"enzo\", \"Density\"), \"x\", resolution=(800, 800))\n", + "file_pattern = \"enzo_tiny_cosmology/DD????/DD????\"\n", + "timeseries.add_to_viewer(v, slc, file_pattern=file_pattern, load_as_stack=True, \n", + " use_dask=True, \n", + " contrast_limits=(-1, 2),\n", + " colormap = 'magma',\n", + " name=\"Lazy density\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d01aaecb-5083-45f2-bade-b4cb271ded38", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\"\"" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from napari.utils import nbscreenshot\n", + "nbscreenshot(v)" + ] + }, + { + "cell_type": "markdown", + "id": "5c8a6f04-3760-4d2e-8e69-96346129bc2a", + "metadata": {}, + "source": [ + "Now, as you drag the slider through, each timestep will be loaded on demand. While this adds a few seconds of processing time, it does allow you to load data that would not fit fully into memory. While less of a problem for slices, the following demonstrates a case that would result in an array roughly 22 Gb in size when loaded in memory:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "6122bc9f-6ef8-4af8-b5d5-2e94916fb760", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Parsing Hierarchy : 100%|██████████| 2/2 [00:00<00:00, 16912.52it/s]\n", + "Parsing Hierarchy : 100%|██████████| 2/2 [00:00<00:00, 16131.94it/s]\n", + "Parsing Hierarchy : 100%|██████████| 120/120 [00:00<00:00, 4619.24it/s]\n", + "Parsing Hierarchy : 100%|██████████| 2/2 [00:00<00:00, 17623.13it/s]\n", + "Parsing Hierarchy : 100%|██████████| 41/41 [00:00<00:00, 1803.40it/s]\n", + "Parsing Hierarchy : 100%|██████████| 86/86 [00:00<00:00, 2899.93it/s]\n", + "Parsing Hierarchy : 100%|██████████| 189/189 [00:00<00:00, 6309.63it/s]\n", + "Parsing Hierarchy : 100%|██████████| 187/187 [00:00<00:00, 6255.16it/s]\n", + "Parsing Hierarchy : 100%|██████████| 194/194 [00:00<00:00, 6509.09it/s]\n", + "Parsing Hierarchy : 100%|██████████| 214/214 [00:00<00:00, 6973.94it/s]\n" + ] + } + ], + "source": [ + "%%capture\n", + "reg = timeseries.Region((\"enzo\", \"Density\"), resolution=(400, 400, 400))\n", + "v.layers.clear()\n", + "timeseries.add_to_viewer(v, reg, file_pattern=file_pattern, load_as_stack=True, \n", + " use_dask=True, \n", + " contrast_limits=(-1, 2),\n", + " colormap='magma',\n", + " name='Lazy region',)\n", + "v.dims.ndisplay = 3" + ] + }, + { + "cell_type": "markdown", + "id": "c727e7f1-ab28-4c44-8d75-e3de93098878", + "metadata": {}, + "source": [ + "and now clicking through timesteps loads a new 3D region on demand:" + ] + }, + { + "cell_type": "markdown", + "id": "ce7b8633-4911-4a8c-8850-9fb9491e4a20", + "metadata": {}, + "source": [ + "![](./resources/yt_napari_timeseries_regdask_vid.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "22e0c1d3-2552-45ad-99d5-f0136d98e5af", + "metadata": {}, + "source": [ + "## Using dask, returning in-memory image array \n", + "\n", + "Finally, for the case where you **can** fit the whole image array in memory, you can set `returned_delayed` to False and dask will be used to fetch the selections. This works best for slices, where you **probably** can safely fit all those slices in memory. " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "47a56288-42fd-4c93-93c7-3d89338fda4d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Parsing Hierarchy : 100%|██████████| 2/2 [00:00<00:00, 15279.80it/s]\n", + "Parsing Hierarchy : 100%|██████████| 120/120 [00:00<00:00, 4467.13it/s]\n", + "Parsing Hierarchy : 0%| | 0/143 [00:00 yt-napari The reader plugin does its best to align new selections of data with existing yt-napari image layers and should be able to properly align selections from different yt datasets (please submit a bug report if it fails!). +The yt-napari yt Time Series Reader: +#################################### + +This reader will apply a spatial selection to a set of files, similar to working with a yt `DataSeries` object. You specify +the spatial selections and a list of files or file pattern to match. Note that while the operation is in a non-blocking +thread, if your simulation data is large it may take a few minutes to load in your selections. Also note that 3D region +selections can easily exceed available memory if you're not careful... for improving load times and working with +bigger-than-memory arrays, you can instead use the jupyter notebook interface for napari with the `yt_napari.timeseries` +module of helper functions to distribute the timestep selections using dask. See the example notebooks for usage. + .. _configfile: Configuring yt-napari diff --git a/docs/schema.rst b/docs/schema.rst index 7bbba85..6eb18bd 100644 --- a/docs/schema.rst +++ b/docs/schema.rst @@ -17,6 +17,8 @@ The following versions are available (latest first): .. schemalistanchor! the following table is auto-generated by repo_utilites/update_schema_docs.py, Do not edit below this line. +yt-napari_0.2.0.json : `view <_static/yt-napari_0.2.0.json>`_ , :download:`download <_static/yt-napari_0.2.0.json>` + yt-napari_0.1.0.json : `view <_static/yt-napari_0.1.0.json>`_ , :download:`download <_static/yt-napari_0.1.0.json>` yt-napari_0.0.1.json : `view <_static/yt-napari_0.0.1.json>`_ , :download:`download <_static/yt-napari_0.0.1.json>` diff --git a/docs/source/modules.rst b/docs/source/modules.rst index a369a2b..2f91243 100644 --- a/docs/source/modules.rst +++ b/docs/source/modules.rst @@ -4,4 +4,5 @@ yt_napari .. toctree:: :maxdepth: 4 - yt_napari + yt_napari.viewer + yt_napari.timeseries diff --git a/docs/source/yt_napari.rst b/docs/source/yt_napari.rst index cf950e5..4aee0cc 100644 --- a/docs/source/yt_napari.rst +++ b/docs/source/yt_napari.rst @@ -1,16 +1,8 @@ yt\_napari package ================== -Subpackages ------------ - -.. toctree:: - :maxdepth: 4 - - yt_napari.schemas - Submodules ----------- +********** yt\_napari.viewer module ------------------------ @@ -20,10 +12,10 @@ yt\_napari.viewer module :undoc-members: :show-inheritance: -Module contents ---------------- +yt\_napari.timeseries module +------------------------ -.. automodule:: yt_napari +.. automodule:: yt_napari.timeseries :members: :undoc-members: :show-inheritance: diff --git a/docs/source/yt_napari.schemas.rst b/docs/source/yt_napari.schemas.rst deleted file mode 100644 index 3b3e04f..0000000 --- a/docs/source/yt_napari.schemas.rst +++ /dev/null @@ -1,10 +0,0 @@ -yt\_napari.schemas package -========================== - -Module contents ---------------- - -.. automodule:: yt_napari.schemas - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/yt_napari.timeseries.rst b/docs/source/yt_napari.timeseries.rst new file mode 100644 index 0000000..75da1fe --- /dev/null +++ b/docs/source/yt_napari.timeseries.rst @@ -0,0 +1,9 @@ +yt\_napari.timeseries module +------------------------ + +This module contains helper functions for working with timeseries data. + +.. automodule:: yt_napari.timeseries + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/yt_napari.viewer.rst b/docs/source/yt_napari.viewer.rst new file mode 100644 index 0000000..f4c505d --- /dev/null +++ b/docs/source/yt_napari.viewer.rst @@ -0,0 +1,8 @@ +yt\_napari.viewer module +------------------------ + +This module contains helper functions for sampling yt datasets and adding to napari. +.. automodule:: yt_napari.viewer + :members: + :undoc-members: + :show-inheritance: diff --git a/requirements.txt b/requirements.txt index 438e906..eebc537 100644 --- a/requirements.txt +++ b/requirements.txt @@ -7,6 +7,7 @@ nbsphinx<0.8.8 sphinx-jsonschema<1.19.0 Jinja2<3.1.0 magicgui +pytest pytest-qt platformdirs taskipy diff --git a/setup.cfg b/setup.cfg index 9313df7..f9ab3db 100644 --- a/setup.cfg +++ b/setup.cfg @@ -50,6 +50,10 @@ where = src napari.manifest = yt-napari = yt_napari:napari.yaml +[options.extras_require] +full = + dask[distributed,array] + [options.package_data] yt_napari = napari.yaml diff --git a/src/yt_napari/_data_model.py b/src/yt_napari/_data_model.py index f7e61cb..ec9cdac 100644 --- a/src/yt_napari/_data_model.py +++ b/src/yt_napari/_data_model.py @@ -101,10 +101,37 @@ class DataContainer(BaseModel): ) +class TimeSeriesFileSelection(BaseModel): + directory: str = Field(None, description="The directory of the timseries") + file_pattern: Optional[str] = Field(None, description="The file pattern to match") + file_list: Optional[List[str]] = Field(None, description="List of files to load.") + file_range: Optional[Tuple[int, int, int]] = Field( + None, + description="Given files matched by file_pattern, " + "this option will select a range. Argument order" + "is taken as start:stop:step.", + ) + + +class Timeseries(BaseModel): + + file_selection: TimeSeriesFileSelection + selections: SelectionObject = Field( + None, description="selections to load in this dataset" + ) + load_as_stack: Optional[bool] = Field( + False, description="If True, will stack images along a new dimension." + ) + # process_in_parallel: Optional[bool] = Field( + # False, description="If True, will attempt to load selections in parallel." + # ) + + class InputModel(BaseModel): - data: List[DataContainer] = Field( - None, description="list of data containers to load" + datasets: List[DataContainer] = Field( + None, description="list of dataset containers to load" ) + timeseries: List[Timeseries] = Field(None, description="List of timeseries to load") _schema_prefix = "yt-napari" diff --git a/src/yt_napari/_ds_cache.py b/src/yt_napari/_ds_cache.py index f06711e..882850f 100644 --- a/src/yt_napari/_ds_cache.py +++ b/src/yt_napari/_ds_cache.py @@ -38,7 +38,7 @@ def rm_all(self): self.available = {} self._most_recent = None - def check_then_load(self, filename: str): + def check_then_load(self, filename: str, cache_if_not_found: bool = True): if self.exists(filename): ytnapari_log.info(f"loading {filename} from cache.") return self.get_ds(filename) @@ -51,7 +51,7 @@ def check_then_load(self, filename: str): else: ds = yt.load(filename) - if ytcfg.get("yt_napari", "in_memory_cache"): + if ytcfg.get("yt_napari", "in_memory_cache") and cache_if_not_found: self.add_ds(ds, filename) return ds diff --git a/src/yt_napari/_gui_utilities.py b/src/yt_napari/_gui_utilities.py index 3cec857..7c79ca7 100644 --- a/src/yt_napari/_gui_utilities.py +++ b/src/yt_napari/_gui_utilities.py @@ -218,6 +218,13 @@ def embed_in_list(widget_instance) -> list: return returnval +def split_comma_sep_string(widget_instance) -> List[str]: + files = widget_instance.value + for ch in " []": + files = files.replace(ch, "") + return files.split(",") + + def _get_pydantic_model_field(py_model, field: str) -> pydantic.fields.ModelField: return py_model.__fields__[field] @@ -251,17 +258,31 @@ def _register_yt_data_model(translator: MagicPydanticRegistry): pydantic_attr_factory=embed_in_list, ) + translator.register( + _data_model.TimeSeriesFileSelection, + "file_list", + magicgui_factory=get_magicguidefault, + magicgui_args=(_data_model.TimeSeriesFileSelection.__fields__["file_list"],), + pydantic_attr_factory=split_comma_sep_string, + ) + translator = MagicPydanticRegistry() _register_yt_data_model(translator) def get_yt_data_container( - ignore_attrs: Optional[Union[str, List[str]]] = None + ignore_attrs: Optional[Union[str, List[str]]] = None, + pydantic_model_class: Optional[ + Union[pydantic.BaseModel, pydantic.main.ModelMetaclass] + ] = None, ) -> widgets.Container: + if pydantic_model_class is None: + pydantic_model_class = _data_model.DataContainer + data_container = widgets.Container() translator.add_pydantic_to_container( - _data_model.DataContainer, + pydantic_model_class, data_container, ignore_attrs=ignore_attrs, ) diff --git a/src/yt_napari/_model_ingestor.py b/src/yt_napari/_model_ingestor.py index d455c6d..0b66996 100644 --- a/src/yt_napari/_model_ingestor.py +++ b/src/yt_napari/_model_ingestor.py @@ -1,9 +1,21 @@ +import os +from collections import defaultdict from typing import List, Optional, Tuple, Union import numpy as np +import yt from unyt import unit_object, unit_registry, unyt_array, unyt_quantity -from yt_napari._data_model import DataContainer, InputModel +from yt_napari import _special_loaders +from yt_napari._data_model import ( + DataContainer, + InputModel, + Region, + SelectionObject, + Slice, + Timeseries, + TimeSeriesFileSelection, +) from yt_napari._ds_cache import dataset_cache @@ -174,6 +186,82 @@ def align_sanitize_layers(self, layer_list: List[SpatialLayer]) -> List[Layer]: return [self.align_sanitize_layer(layer) for layer in layer_list] +def selections_match(sel_1: Union[Slice, Region], sel_2: Union[Slice, Region]) -> bool: + # compare selections, ignoring fields + if not type(sel_2) == type(sel_1): + return False + + for attr in sel_1.__fields__.keys(): + if attr != "fields": + val_1 = getattr(sel_1, attr) + val_2 = getattr(sel_2, attr) + if val_2 != val_1: + return False + + return True + + +class TimeseriesContainer: + # for storing image layers across timesteps by selections + def __init__(self): + self.layers_in_selections = defaultdict(lambda: []) + self.selection_objs = {} + self.selection_field = {} + + def check_for_selection( + self, selection: Union[Slice, Region], current_field: Tuple[str, str] + ) -> int: + for sel_id, sel_obj in self.selection_objs.items(): + sel_field = self.selection_field[sel_id] + if selections_match(sel_obj, selection) and current_field == sel_field: + return sel_id + + # does not exist yet, add it + sel_id = len(self.selection_objs) + self.selection_objs[sel_id] = selection + self.selection_field[sel_id] = current_field + return sel_id + + def add( + self, + selection: Union[Slice, Region], + current_field: Tuple[str, str], + new_layer: SpatialLayer, + ): + sel_id = self.check_for_selection(selection, current_field) + + (im, im_kwargs, im_label, layer_domain) = new_layer + if layer_domain.requires_scale: + im_kwargs["scale"] = 1.0 / layer_domain.aspect_ratio + new_layer = (im, im_kwargs, im_label, layer_domain) + + self.layers_in_selections[sel_id].append(new_layer) + + def concat_by_selection_id(self, id: int) -> Layer: + the_layers = self.layers_in_selections[id] + if len(the_layers) == 1: + return the_layers[0] + if len(the_layers) == 0: + return None + + # assuming that im_kwargs, layer_type do not change. also dr + _, im_kwargs, layer_type, domain = the_layers[0] + im_arrays = [im[0] for im in the_layers] + im = np.stack(im_arrays, axis=0) # this operation will preserve dask arrays + return im, im_kwargs, layer_type + + def concat_by_selection(self): + return [self.concat_by_selection_id(id) for id in self.selection_objs.keys()] + + @property + def layer_list(self) -> List[Layer]: + layer_list = [] + for layers in self.layers_in_selections.values(): + for im_data, im_kwargs, layer_type, _ in layers: + layer_list.append((im_data, im_kwargs, layer_type)) + return layer_list + + def create_metadata_dict( data: np.ndarray, layer_domain: LayerDomain, @@ -343,9 +431,14 @@ def update_width_and_center(self): self.center, self.width = center_wid -def _load_3D_regions(ds, m_data: DataContainer, layer_list: list) -> list: +def _load_3D_regions( + ds, + selections: SelectionObject, + layer_list: list, + timeseries_container: Optional[TimeseriesContainer] = None, +) -> list: - for sel in m_data.selections.regions: + for sel in selections.regions: # get the left, right edge as a unitful array, initialize the layer # domain tracking for this layer and update the global domain extent if sel.left_edge is None: @@ -380,7 +473,10 @@ def _load_3D_regions(ds, m_data: DataContainer, layer_list: list) -> list: add_kwargs = {"name": fieldname, "metadata": md} layer_type = "image" - layer_list.append((data, add_kwargs, layer_type, layer_domain)) + new_layer = (data, add_kwargs, layer_type, layer_domain) + layer_list.append(new_layer) + if timeseries_container is not None: + timeseries_container.add(sel, field, new_layer) return layer_list @@ -435,9 +531,14 @@ def _process_slice( return frb, layer_domain -def _load_2D_slices(ds, m_data: DataContainer, layer_list: list) -> list: +def _load_2D_slices( + ds, + selections: SelectionObject, + layer_list: list, + timeseries_container: Optional[TimeseriesContainer] = None, +) -> list: - for slice in m_data.selections.slices: + for slice in selections.slices: if slice.center is None: c = None @@ -476,50 +577,176 @@ def _load_2D_slices(ds, m_data: DataContainer, layer_list: list) -> list: md = create_metadata_dict(data, layer_domain, field_container.take_log) add_kwargs = {"name": fieldname, "metadata": md} layer_type = "image" + new_layer = (data, add_kwargs, layer_type, layer_domain) + layer_list.append(new_layer) + if timeseries_container is not None: + timeseries_container.add(slice, field, new_layer) + + return layer_list - layer_list.append((data, add_kwargs, layer_type, layer_domain)) +def _load_selections_from_ds( + ds, + selections: SelectionObject, + layer_list: List[SpatialLayer], + timeseries_container: Optional[TimeseriesContainer] = None, +) -> List[SpatialLayer]: + if selections.regions is not None: + layer_list = _load_3D_regions( + ds, selections, layer_list, timeseries_container=timeseries_container + ) + if selections.slices is not None: + layer_list = _load_2D_slices( + ds, selections, layer_list, timeseries_container=timeseries_container + ) return layer_list -def _process_validated_model(model: InputModel) -> List[SpatialLayer]: +def _load_dataset_selections( + m_data: DataContainer, layer_list: List[SpatialLayer] +) -> List[SpatialLayer]: + ds = dataset_cache.check_then_load(m_data.filename) + return _load_selections_from_ds(ds, m_data.selections, layer_list) + + +def _validate_files(files): + + valid_files = [f for f in files if os.path.isfile(f)] + + if len(valid_files) == 0: + # try the yt directory + yt_data_dir = yt.config.ytcfg.get("yt", "test_data_dir") + test_files = [os.path.join(yt_data_dir, f) for f in files] + valid_files = [f for f in test_files if os.path.isfile(f)] + + return valid_files + + +def _generate_file_list(fpat, fdir=None): + import glob + + # try with + match_this = fpat + if fdir is not None: + match_this = os.path.join(fdir, match_this) + + files = glob.glob(match_this) + if len(files) == 0: + yt_data_dir = yt.config.ytcfg.get("yt", "test_data_dir") + files = glob.glob(os.path.join(yt_data_dir, match_this)) + + files.sort() + return files + + +def _find_timeseries_files(file_selection: TimeSeriesFileSelection): + + fdir = file_selection.directory + fpat = file_selection.file_pattern + frange = file_selection.file_range + + if file_selection.file_list is not None: + # we have a list of files, load them explicitly as dataseries + files = file_selection.file_list + if fdir is not None: + files = [os.path.join(fdir, fi) for fi in files] + return _validate_files(files) + + if fpat is None: + fpat = "*" + + files = _generate_file_list(fpat, fdir) + if frange is not None: + # limit the selected files + f1, f2, f3 = frange + if f2 > len(files): + f2 = len(files) + picked_files = [files[fileid] for fileid in range(f1, f2, f3)] + return picked_files + + return files + + +def _load_timeseries(m_data: Timeseries, layer_list: list) -> list: + + files = _find_timeseries_files(m_data.file_selection) + + # process_in_parallel = False # future model attribute + + tc = TimeseriesContainer() + temp_list = [] + for file in files: + # note: managing the files independently makes parallel approaches + # without MPI feasible. in some limited testing, this actually + # was thread safe with logging disabled, so it is possible to + # build dask arrays pretty easily for single regions and single + # fields. + ds = _load_with_timeseries_specials_check(file) + sels = m_data.selections + temp_list = _load_selections_from_ds( + ds, sels, temp_list, timeseries_container=tc + ) + + if m_data.load_as_stack is False: + new_layers = tc.layer_list + else: + new_layers = tc.concat_by_selection() + + for layer in new_layers: + layer_list.append(layer) + return layer_list + + +def _process_validated_model( + model: InputModel, +) -> Tuple[List[SpatialLayer], List[Layer]]: # return a list of layer tuples with domain information + if model.datasets is None: + model.datasets = [] + + if model.timeseries is None: + model.timeseries = [] + layer_list = [] # our model is already validated, so we can assume the field exist with # their correct types. This is all the yt-specific code required to load a # dataset and return a plain numpy array - for m_data in model.data: + for m_data in model.datasets: + layer_list = _load_dataset_selections(m_data, layer_list) - ds = dataset_cache.check_then_load(m_data.filename) - if m_data.selections.regions is not None: - layer_list = _load_3D_regions(ds, m_data, layer_list) - if m_data.selections.slices is not None: - layer_list = _load_2D_slices(ds, m_data, layer_list) + timeseries_layers = [] + for m_data in model.timeseries: + timeseries_layers = _load_timeseries(m_data, timeseries_layers) - return layer_list + return layer_list, timeseries_layers def load_from_json(json_paths: List[str]) -> List[Layer]: layer_lists = [] # we will concatenate layers across json paths - + timeseries_layers = [] # timeseries layers handled separately for json_path in json_paths: # InputModel is a pydantic class, the following will validate the json model = InputModel.parse_file(json_path) # now that we have a validated model, we can use the model attributes # to execute the code that will return our array for the image - layer_lists += _process_validated_model(model) + layer_lists_j, timeseries_layers_j = _process_validated_model(model) + timeseries_layers += timeseries_layers_j + layer_lists += layer_lists_j # now we need to align all our layers! # choose a reference layer -- using the first in the list at present, could # make this user configurable and/or use the layer with highest pixel density # as the reference so that high density layers do not lose resolution - ref_layer = _choose_ref_layer(layer_lists) - layer_lists = ref_layer.align_sanitize_layers(layer_lists) + if len(layer_lists) > 0: + ref_layer = _choose_ref_layer(layer_lists) + layer_lists = ref_layer.align_sanitize_layers(layer_lists) - return layer_lists + # timeseries layers are internally aligned + out_layers = layer_lists + timeseries_layers + return out_layers def _choose_ref_layer( @@ -544,3 +771,21 @@ def _choose_ref_layer( raise ValueError(f"method must be one of {vmeths}, found {method}") return ReferenceLayer(layer_list[ref_layer_id][3]) + + +def _load_with_timeseries_specials_check(file): + fname = os.path.basename(file) + if fname.startswith("_ytnapari") and "-" in fname: + # check form of, e.g., _ytnapari_load_grid-001 + loader, _ = str(fname).split("-") + if hasattr(_special_loaders, loader): + ds = getattr(_special_loaders, loader)() + else: + msg = ( + f"The special loader function, yt_napari._special_loaders.{loader} " + f"does not exist." + ) + raise AttributeError(msg) + else: + ds = yt.load(file) + return ds diff --git a/src/yt_napari/_schema_version.py b/src/yt_napari/_schema_version.py new file mode 100644 index 0000000..04279d8 --- /dev/null +++ b/src/yt_napari/_schema_version.py @@ -0,0 +1,3 @@ +schema_version = "0.2.0" +schema_version_tuple = (0, 2, 0) +schema_name = "yt-napari_" + schema_version + ".json" diff --git a/src/yt_napari/_special_loaders.py b/src/yt_napari/_special_loaders.py index 5453ec1..259c491 100644 --- a/src/yt_napari/_special_loaders.py +++ b/src/yt_napari/_special_loaders.py @@ -1,3 +1,5 @@ +from pathlib import Path + import numpy as np import yt @@ -8,3 +10,18 @@ def _ytnapari_load_grid(): bbox = np.array([[-1.5, 1.5], [-1.5, 1.5], [-1.5, 1.5]]) shp = arr.shape return yt.load_uniform_grid(d, shp, length_unit="Mpc", bbox=bbox, nprocs=64) + + +def _construct_ugrid_timeseries(top_dir: Path, nfiles: int): + ts_dir = top_dir / "output_dir" + ts_dir.mkdir() + + flist_actual = [] + for tstep in range(0, nfiles): + tstepstr = str(tstep).zfill(4) + fname = f"_ytnapari_load_grid-{tstepstr}" + newfi = ts_dir / fname + newfi.touch() + + flist_actual.append(str(newfi)) + return str(ts_dir), flist_actual diff --git a/src/yt_napari/_tests/_test_json.json b/src/yt_napari/_tests/_test_json.json index 776c272..d6da465 100644 --- a/src/yt_napari/_tests/_test_json.json +++ b/src/yt_napari/_tests/_test_json.json @@ -1,5 +1,5 @@ -{"$schema": "yt-napari_0.1.0.json", - "data": [{"filename": "IsolatedGalaxy/galaxy0030/galaxy0030", +{"$schema": "yt-napari_0.2.0.json", + "dataset": [{"filename": "IsolatedGalaxy/galaxy0030/galaxy0030", "selections": { "regions": [ { diff --git a/src/yt_napari/_tests/_test_json_slice.json b/src/yt_napari/_tests/_test_json_slice.json index 2c22b1e..92ef496 100644 --- a/src/yt_napari/_tests/_test_json_slice.json +++ b/src/yt_napari/_tests/_test_json_slice.json @@ -1,5 +1,5 @@ -{"$schema": "yt-napari_0.1.0.json", - "data": [{"filename": "IsolatedGalaxy/galaxy0030/galaxy0030/", +{"$schema": "yt-napari_0.2.0.json", + "datasets": [{"filename": "IsolatedGalaxy/galaxy0030/galaxy0030/", "selections": { "slices": [ { diff --git a/src/yt_napari/_tests/_test_json_timeseries.json b/src/yt_napari/_tests/_test_json_timeseries.json new file mode 100644 index 0000000..5b33d0f --- /dev/null +++ b/src/yt_napari/_tests/_test_json_timeseries.json @@ -0,0 +1,55 @@ +{ + "$schema": "yt-napari_0.2.0.json", + "datasets": [], + "timeseries": [ + { + "file_selection": { + "directory": "enzo_tiny_cosmology/", + "file_pattern": null, + "file_list": [ + "DD0030/DD0030", + "DD0045/DD0045" + ], + "file_range": null + }, + "selections": { + "regions": null, + "slices": [ + { + "fields": [ + { + "field_type": "enzo", + "field_name": "Density", + "take_log": true + } + ], + "normal": "x", + "center": { + "value": [ + 0.5, + 0.5, + 0.5 + ], + "unit": "code_length" + }, + "slice_width": { + "value": 0.25, + "unit": "code_length" + }, + "slice_height": { + "value": 0.25, + "unit": "code_length" + }, + "resolution": [ + 400, + 400 + ], + "periodic": false + } + ] + }, + "load_as_stack": false, + "process_in_parallel": false + } + ] +} diff --git a/src/yt_napari/_tests/_test_json_timeseries_stack.json b/src/yt_napari/_tests/_test_json_timeseries_stack.json new file mode 100644 index 0000000..8bd31f1 --- /dev/null +++ b/src/yt_napari/_tests/_test_json_timeseries_stack.json @@ -0,0 +1,52 @@ +{ + "$schema": "yt-napari_0.2.0.json", + "datasets": [], + "timeseries": [ + { + "file_selection": { + "directory": "", + "file_pattern": "enzo_tiny_cosmology/DD????/DD????", + "file_list": null, + "file_range": [0, 50, 10] + }, + "selections": { + "regions": null, + "slices": [ + { + "fields": [ + { + "field_type": "enzo", + "field_name": "Density", + "take_log": true + } + ], + "normal": "x", + "center": { + "value": [ + 0.5, + 0.5, + 0.5 + ], + "unit": "code_length" + }, + "slice_width": { + "value": 1.0, + "unit": "code_length" + }, + "slice_height": { + "value": 0.5, + "unit": "code_length" + }, + "resolution": [ + 800, + 800 + ], + "periodic": false + } + ] + }, + "load_as_stack": true, + "process_in_parallel": false + } + ] +} diff --git a/src/yt_napari/_tests/test_model_ingestor.py b/src/yt_napari/_tests/test_model_ingestor.py index 171669d..62de672 100644 --- a/src/yt_napari/_tests/test_model_ingestor.py +++ b/src/yt_napari/_tests/test_model_ingestor.py @@ -3,8 +3,9 @@ import numpy as np import pytest import unyt +from yt.config import ytcfg -from yt_napari import _model_ingestor as _mi +from yt_napari import _data_model as _dm, _model_ingestor as _mi # indirect testing happens via test_reader, so the tests here focus on explicit # testing of the domain tracking and alignment @@ -315,3 +316,183 @@ def test_2d_3d_mix(): sp_layer = (np.random.random(res), {}, "testname", layer_2d) new_layer_2d = ref.align_sanitize_layer(sp_layer) assert "scale" not in new_layer_2d[1] # no scale when it is all 1 + + +@pytest.fixture +def selection_objs(): + slc_1 = _dm.Slice( + flds=[ + _dm.ytField(field_type="enzo", field_name="density"), + ], + normal="x", + center=_dm.Length_Tuple(value=[0.5, 0.5, 0.5]), + slice_width=_dm.Length_Value(value=0.25), + slice_height=_dm.Length_Value(value=0.25), + ) + slc_2 = _dm.Slice( + flds=[ + _dm.ytField(field_type="enzo", field_name="density"), + ], + normal="x", + center=_dm.Length_Tuple(value=[0.5, 0.5, 0.5]), + slice_width=_dm.Length_Value(value=0.25), + slice_height=_dm.Length_Value(value=0.25), + resolution=(10, 10), + ) + + slc_3 = _dm.Slice( + flds=[ + _dm.ytField(field_type="enzo", field_name="temperature"), + ], + normal="x", + center=_dm.Length_Tuple(value=[0.5, 0.5, 0.5]), + slice_width=_dm.Length_Value(value=0.25), + slice_height=_dm.Length_Value(value=0.25), + ) + + reg_1 = _dm.Region( + flds=[ + _dm.ytField(field_type="enzo", field_name="temperature"), + ], + left_edge=_dm.Left_Edge(value=[0.0, 0.0, 0.0]), + right_edge=_dm.Right_Edge(value=[1.0, 1.0, 1.0]), + ) + + reg_2 = _dm.Region( + flds=[ + _dm.ytField(field_type="enzo", field_name="temperature"), + ], + left_edge=_dm.Left_Edge(value=[0.0, 0.0, 0.0]), + right_edge=_dm.Right_Edge(value=[0.8, 1.0, 1.0]), + ) + + reg_3 = _dm.Region( + flds=[ + _dm.ytField(field_type="enzo", field_name="density"), + ], + left_edge=_dm.Left_Edge(value=[0.0, 0.0, 0.0]), + right_edge=_dm.Right_Edge(value=[1.0, 1.0, 1.0]), + ) + return slc_1, slc_2, slc_3, reg_1, reg_2, reg_3 + + +def test_selection_comparison(selection_objs): + slc_1, slc_2, slc_3, reg_1, reg_2, reg_3 = selection_objs + assert _mi.selections_match(slc_1, slc_2) is False + assert _mi.selections_match(slc_1, slc_3) + assert _mi.selections_match(slc_1, reg_1) is False + assert _mi.selections_match(reg_1, reg_2) is False + assert _mi.selections_match(reg_1, reg_3) is True + + +def test_timeseries_container(selection_objs): + slc_1, slc_2, slc_3, reg_1, reg_2, reg_3 = selection_objs + tc = _mi.TimeseriesContainer() + + im_kwargs = {} + shp = (10, 10, 10) + # note: domain here is a placeholder, not actually used in tc + domain = _mi.LayerDomain( + unyt.unyt_array([0, 0, 0], "m"), unyt.unyt_array([1.0, 1.0, 1.0], "m"), shp + ) + im = np.random.random(shp) + + print("what what") + for _ in range(3): + tc.add(reg_1, ("enzo", "temperature"), (im, im_kwargs, "image", domain)) + + assert len(tc.layers_in_selections[0]) == 3 + + shp = (10, 10) + # note: domain here is a placeholder, not actually used in tc + domain = _mi.LayerDomain( + unyt.unyt_array([0, 0], "m"), + unyt.unyt_array([1.0, 1.0], "m"), + shp, + n_d=2, + ) + im = np.random.random(shp) + + for _ in range(2): + tc.add(slc_1, ("enzo", "temperature"), (im, im_kwargs, "image", domain)) + for _ in range(2): + tc.add(slc_3, ("enzo", "temperature"), (im, im_kwargs, "image", domain)) + + assert len(tc.layers_in_selections[1]) == 4 + + for _ in range(2): + tc.add(slc_2, ("enzo", "temperature"), (im, im_kwargs, "image", domain)) + + assert len(tc.layers_in_selections[2]) == 2 + + for _ in range(2): + tc.add(slc_2, ("enzo", "density"), (im, im_kwargs, "image", domain)) + + assert len(tc.layers_in_selections[3]) == 2 + + concatd = tc.concat_by_selection() + assert len(concatd) == 4 + assert concatd[0][0].shape == (3, 10, 10, 10) + assert concatd[1][0].shape == (4, 10, 10) + assert concatd[2][0].shape == (2, 10, 10) + assert concatd[3][0].shape == (2, 10, 10) + + +file_sel_dicts = [ + {"file_pattern": "test_fi_???"}, + {}, # just the directory + {"file_list": ["test_fi_001", "test_fi_002"]}, + { + "file_pattern": "test_fi_???", + "file_range": (0, 100, 1), + }, +] + + +@pytest.mark.parametrize("file_sel_dict", file_sel_dicts) +def test_find_timeseries_file_selection(tmp_path, file_sel_dict): + + fdir = tmp_path / "output" + fdir.mkdir() + + base_name = "test_fi_" + nfiles = 10 + for ifile in range(0, nfiles): + fname = base_name + str(ifile).zfill(3) + newfi = fdir / fname + newfi.touch() + + fdir = str(fdir) + file_sel_dict["directory"] = fdir + + tsfs = _mi.TimeSeriesFileSelection.parse_obj(file_sel_dict) + + files = _mi._find_timeseries_files(tsfs) + if "file_list" not in file_sel_dict: + assert len(files) == nfiles + + +def test_yt_data_dir_check(tmp_path): + + fdir = tmp_path / "output" + fdir.mkdir() + + init_dir = ytcfg.get("yt", "test_data_dir") + + fname_list = [] + base_name = "test_fi_blah_" + nfiles = 7 + for ifile in range(0, nfiles): + fname = base_name + str(ifile).zfill(3) + newfi = fdir / fname + newfi.touch() + fname_list.append(fname) + + ytcfg.set("yt", "test_data_dir", str(fdir.absolute())) + + files = _mi._validate_files(fname_list) + assert len(files) == nfiles + + files = _mi._generate_file_list("test_fi_blah_???") + assert len(files) == nfiles + ytcfg.set("yt", "test_data_dir", init_dir) diff --git a/src/yt_napari/_tests/test_reader.py b/src/yt_napari/_tests/test_reader.py index 606d896..bf720fb 100644 --- a/src/yt_napari/_tests/test_reader.py +++ b/src/yt_napari/_tests/test_reader.py @@ -7,8 +7,8 @@ from yt_napari import napari_get_reader valid_jdict = { - "$schema": "yt-napari_0.1.0.json", - "data": [ + "$schema": "yt-napari_0.2.0.json", + "datasets": [ { "filename": None, "selections": { @@ -40,7 +40,7 @@ def json_file_fixture(tmp_path, yt_ugrid_ds_fn): # this fixture is the json file for napari to load, with # reference to the session-wide yt dataset - valid_jdict["data"][0]["filename"] = yt_ugrid_ds_fn + valid_jdict["datasets"][0]["filename"] = yt_ugrid_ds_fn json_file = str(tmp_path / "valid_json.json") with open(json_file, "w") as fp: diff --git a/src/yt_napari/_tests/test_slices_json.py b/src/yt_napari/_tests/test_slices_json.py index 49749ea..cea9c73 100644 --- a/src/yt_napari/_tests/test_slices_json.py +++ b/src/yt_napari/_tests/test_slices_json.py @@ -2,12 +2,13 @@ from yt_napari._data_model import InputModel from yt_napari._model_ingestor import _choose_ref_layer, _process_validated_model +from yt_napari._schema_version import schema_name jdicts = [] jdicts.append( { - "$schema": "yt-napari_0.1.0.json", - "data": [ + "$schema": schema_name, + "datasets": [ { "filename": "_ytnapari_load_grid", "selections": { @@ -28,8 +29,8 @@ ) jdicts.append( { - "$schema": "yt-napari_0.1.0.json", - "data": [ + "$schema": schema_name, + "datasets": [ { "filename": "_ytnapari_load_grid", "selections": { @@ -54,6 +55,6 @@ def test_basic_slice_validation(jdict): @pytest.mark.parametrize("jdict", jdicts) def test_slice_load(yt_ugrid_ds_fn, jdict): im = InputModel.parse_obj(jdict) - layer_lists = _process_validated_model(im) + layer_lists, _ = _process_validated_model(im) ref_layer = _choose_ref_layer(layer_lists) _ = ref_layer.align_sanitize_layers(layer_lists) diff --git a/src/yt_napari/_tests/test_timeseries.py b/src/yt_napari/_tests/test_timeseries.py new file mode 100644 index 0000000..196469b --- /dev/null +++ b/src/yt_napari/_tests/test_timeseries.py @@ -0,0 +1,261 @@ +import os.path +import sys + +import numpy as np +import pytest +import yt +from yt.config import ytcfg + +from yt_napari import _data_model as dm, _model_ingestor as mi, timeseries as ts +from yt_napari._special_loaders import _construct_ugrid_timeseries + + +@pytest.fixture(scope="module") +def yt_ds_0(): + # this fixture generates a random yt dataset saved to disk that can be + # re-loaded and sampled. + arr = np.random.random(size=(16, 16, 16)) + d = dict(density=(arr, "g/cm**3"), temperature=(arr, "K")) + bbox = np.array([[-1.5, 1.5], [-1.5, 1.5], [-1.5, 1.5]]) + shp = arr.shape + ds = yt.load_uniform_grid(d, shp, length_unit="Mpc", bbox=bbox, nprocs=64) + return ds + + +def test_timeseries_file_collection(tmp_path): + + nfiles = 8 + file_dir, flist_actual = _construct_ugrid_timeseries(tmp_path, nfiles) + + tfs = dm.TimeSeriesFileSelection( + file_pattern="_ytnapari_load_grid-????", + directory=file_dir, + # file_list=file_list, + # file_range=file_range, + ) + files = mi._find_timeseries_files(tfs) + assert len(files) == nfiles + assert all([fi in flist_actual for fi in files]) + + tfs = dm.TimeSeriesFileSelection( + directory=file_dir, + file_list=flist_actual, + ) + files = mi._find_timeseries_files(tfs) + assert len(files) == nfiles + assert all([fi in flist_actual for fi in files]) + + tfs = dm.TimeSeriesFileSelection( + file_pattern="_ytnapari_load_grid-????", + directory=file_dir, + file_range=(0, nfiles, 2), + ) + files = mi._find_timeseries_files(tfs) + assert len(files) == nfiles / 2 + + +_field = ("stream", "density") + + +def test_region(yt_ds_0): + sample_res = (20, 20, 20) + reg = ts.Region(_field, resolution=sample_res) + data = reg.sample_ds(yt_ds_0) + assert data.shape == sample_res + + reg2 = ts.Region( + _field, + left_edge=yt_ds_0.domain_left_edge, + right_edge=yt_ds_0.domain_right_edge, + resolution=sample_res, + ) + + data2 = reg2.sample_ds(yt_ds_0) + assert np.all(data == data2) + + le = np.array([-1.5, -1.5, -1.5]) + re = np.array([1.5, 1.5, 1.5]) + + reg3 = ts.Region( + _field, left_edge=(le, "Mpc"), right_edge=(re, "Mpc"), resolution=sample_res + ) + + data3 = reg3.sample_ds(yt_ds_0) + assert np.all(data == data3) + + assert reg3._requires_scale is False + assert np.all(reg3._scale == 1.0) + + reg4 = ts.Region(_field, resolution=sample_res, take_log=False) + data4 = reg4.sample_ds(yt_ds_0) + assert np.all(np.log10(data4) == data) + + +def test_slice(yt_ds_0): + sample_res = (20, 20) + slc = ts.Slice(_field, "x", resolution=sample_res) + + data = slc.sample_ds(yt_ds_0) + assert data.shape == sample_res + + slc2 = ts.Slice( + _field, + "x", + resolution=sample_res, + center=(np.zeros((3,)), "Mpc"), + width=(3.0, "Mpc"), + height=(3.0, "Mpc"), + ) + data2 = slc2.sample_ds(yt_ds_0) + assert np.all(data2 == data) + + slc3 = ts.Slice( + _field, + "x", + resolution=sample_res, + center=yt_ds_0.domain_center, + width=yt_ds_0.domain_width[1], + height=yt_ds_0.domain_width[2], + ) + data3 = slc3.sample_ds(yt_ds_0) + assert np.all(data3 == data) + + +@pytest.mark.parametrize( + "selection", + [ + ts.Region(_field, resolution=(20, 20, 20)), + ts.Slice(_field, "x", resolution=(20, 20)), + ], +) +def test_timseries_selection(tmp_path, selection): + + nfiles = 4 + file_dir, flist_actual = _construct_ugrid_timeseries(tmp_path, nfiles) + + data = ts._load_and_sample(flist_actual[0], selection, False) + assert data.shape == selection.resolution + + im_data, _, _ = ts._get_im_data( + selection, + file_dir=file_dir, + file_pattern="_ytnapari_load_grid-????", + load_as_stack=False, + ) + + assert len(im_data) == nfiles + + im_data, _, _ = ts._get_im_data( + selection, + file_dir=file_dir, + file_pattern="_ytnapari_load_grid-????", + load_as_stack=True, + ) + + assert im_data.shape == (nfiles,) + selection.resolution + + +@pytest.mark.parametrize( + "selection", + [ + ts.Region( + _field, + left_edge=(np.array([-1, -1, -1]), "km"), + right_edge=(np.array([1, 2, 2]), "km"), + ), + ts.Slice(_field, "x", width=(2.0, "km"), height=(1.0, "km")), + ], +) +def test_validate_scale(selection): + + # check that we pick up the scale + kwargdict = {} + ts._validate_scale(selection, kwargdict, False, 1.0) + assert len(kwargdict["scale"]) == selection.nd + assert np.any(kwargdict["scale"] != 1.0) + + # check that stacked dim scale is applied + kwargdict = {} + ts._validate_scale(selection, kwargdict, True, 10.0) + assert len(kwargdict["scale"]) == selection.nd + 1 + assert np.any(kwargdict["scale"] != 1.0) + assert kwargdict["scale"][0] == 10.0 + + # check that existing scale is not over-ridden + sc_scale = np.random.random((selection.nd,)) + kwargdict = {"scale": sc_scale} + ts._validate_scale(selection, kwargdict, False, 1.0) + assert np.all(kwargdict["scale"] == sc_scale) + + kwargdict = {"scale": sc_scale} + ts._validate_scale(selection, kwargdict, True, 1.0) + assert np.all(kwargdict["scale"][1:] == sc_scale) + + +@pytest.mark.parametrize( + "selection", + [ + ts.Region(_field, resolution=(20, 20, 20)), + ts.Slice(_field, "x", resolution=(20, 20)), + ], +) +def test_dask_selection(tmp_path, selection): + ytcfg.set("yt", "store_parameter_files", False) + nfiles = 4 + file_dir, flist_actual = _construct_ugrid_timeseries(tmp_path, nfiles) + + file_dir = os.path.abspath(file_dir) + im_data2, _, _ = ts._get_im_data( + selection, + file_dir=file_dir, + file_pattern="_ytnapari_load_grid-????", + load_as_stack=True, + use_dask=True, + ) + + # actually computing seems to have problems? + # assert np.all(im_data2.compute() == im_data) + + +def test_add_to_viewer(make_napari_viewer, tmp_path): + nfiles = 4 + file_dir, _ = _construct_ugrid_timeseries(tmp_path, nfiles) + viewer = make_napari_viewer() + + sel = ts.Slice(_field, "x", resolution=(10, 10)) + file_pat = "_ytnapari_load_grid-????" + + ts.add_to_viewer(viewer, sel, file_dir=file_dir, file_pattern=file_pat) + assert len(viewer.layers) == nfiles + assert all([layer.data.shape == sel.resolution for layer in viewer.layers]) + viewer.layers.clear() + + ts.add_to_viewer( + viewer, sel, file_dir=file_dir, file_pattern=file_pat, load_as_stack=True + ) + assert len(viewer.layers) == 1 + expected = (nfiles,) + sel.resolution + assert all([layer.data.shape == expected for layer in viewer.layers]) + viewer.layers.clear() + + ts.add_to_viewer( + viewer, sel, file_dir=file_dir, file_pattern=file_pat, name="myname" + ) + assert "myname" in viewer.layers[0].name + + +def test_dask_missing(tmp_path, monkeypatch): + monkeypatch.setitem(sys.modules, "dask", None) + + nfiles = 4 + file_dir, flist_actual = _construct_ugrid_timeseries(tmp_path, nfiles) + + selection = ts.Slice(_field, "x", resolution=(20, 20)) + with pytest.raises(ImportError, match="This functionality requires dask"): + _ = ts._get_im_data( + selection, + file_dir=file_dir, + file_pattern="_ytnapari_load_grid-????", + load_as_stack=False, + use_dask=True, + ) diff --git a/src/yt_napari/_tests/test_timeseries_json.py b/src/yt_napari/_tests/test_timeseries_json.py new file mode 100644 index 0000000..74083d9 --- /dev/null +++ b/src/yt_napari/_tests/test_timeseries_json.py @@ -0,0 +1,159 @@ +import numpy as np +import pytest + +from yt_napari import _model_ingestor as mi +from yt_napari._data_model import InputModel +from yt_napari._schema_version import schema_name +from yt_napari._special_loaders import _construct_ugrid_timeseries + +f_sel_dict = { + "directory": "enzo_tiny_cosmology/", + "file_list": ["DD0030/DD0030", "DD0045/DD0045"], + "file_range": (0, 10, 1), +} + +fields_to_load = [ + { + "field_type": "stream", + "field_name": "density", + }, + { + "field_type": "stream", + "field_name": "temperature", + }, +] + +slice_dict = { + "fields": fields_to_load, + "normal": "x", + "center": {"value": [0.5, 0.5, 0.5], "unit": "code_length"}, + "slice_width": {"value": 0.25, "unit": "code_length"}, + "slice_height": {"value": 0.25, "unit": "code_length"}, + "resolution": [10, 10], +} + +reg_dict = { + "fields": fields_to_load, + "resolution": [10, 10, 10], +} + +jdicts = [] +jdicts.append( + { + "$schema": schema_name, + "timeseries": [ + { + "file_selection": f_sel_dict, + "selections": { + "slices": [ + slice_dict, + ] + }, + "load_as_stack": True, + } + ], + } +) +jdicts.append( + { + "$schema": schema_name, + "datasets": [], + "timeseries": [ + { + "file_selection": f_sel_dict, + "selections": { + "regions": [ + reg_dict, + ] + }, + "load_as_stack": True, + } + ], + } +) + + +@pytest.mark.parametrize("jdict", jdicts) +def test_basic_validation(jdict): + _ = InputModel.parse_obj(jdict) + + +@pytest.mark.parametrize("jdict,expected_res", zip(jdicts, [(10, 10), (10, 10, 10)])) +def test_full_load(tmp_path, jdict, expected_res): + + nfiles = 4 + + fdir, flist = _construct_ugrid_timeseries(tmp_path, nfiles) + + f_dict = {"directory": fdir, "file_pattern": "_ytnapari_load_grid-????"} + + jdict_new = jdict.copy() + jdict_new["timeseries"][0]["file_selection"] = f_dict + im = InputModel.parse_obj(jdict_new) + + files = mi._find_timeseries_files(im.timeseries[0].file_selection) + assert all([file in files for file in flist]) + + _, ts_layers = mi._process_validated_model(im) + assert ts_layers[0][0].shape == (nfiles,) + expected_res + assert len(ts_layers) == 2 # two fields + + +@pytest.mark.parametrize("jdict", jdicts) +def test_unstacked_load(tmp_path, jdict): + + nfiles = 4 + fdir, flist = _construct_ugrid_timeseries(tmp_path, nfiles) + + f_dict = {"directory": fdir, "file_pattern": "_ytnapari_load_grid-????"} + + jdict_new = jdict.copy() + jdict_new["timeseries"][0]["file_selection"] = f_dict + jdict_new["timeseries"][0]["load_as_stack"] = False + + im = InputModel.parse_obj(jdict_new) + _, ts_layers = mi._process_validated_model(im) + assert len(ts_layers) == 2 * nfiles # two fields per file + + +def test_load_with_timeseries_specials_check(yt_ugrid_ds_fn, tmp_path): + nfiles = 4 + fdir, flist = _construct_ugrid_timeseries(tmp_path, nfiles) + + ds = mi._load_with_timeseries_specials_check(flist[0]) + assert hasattr(ds, "domain_center") + + with pytest.raises(AttributeError, match="The special loader"): + _ = mi._load_with_timeseries_specials_check("_ytnapari_load_what-01") + + ds = mi._load_with_timeseries_specials_check(yt_ugrid_ds_fn) + assert hasattr(ds, "domain_center") + + +def test_aspect_rat(tmp_path): + nfiles = 4 + fdir, flist = _construct_ugrid_timeseries(tmp_path, nfiles) + + slice_1 = slice_dict.copy() + slice_1["slice_width"] = {"value": 1.0, "unit": "code_length"} + f_dict = {"directory": fdir, "file_pattern": "_ytnapari_load_grid-????"} + jdict_ar = { + "$schema": schema_name, + "timeseries": [ + { + "file_selection": f_dict, + "selections": { + "slices": [ + slice_1, + ] + }, + "load_as_stack": True, + } + ], + } + + im = InputModel.parse_obj(jdict_ar) + _, ts_layers = mi._process_validated_model(im) + for _, im_kwargs, _ in ts_layers: + print(im_kwargs) + assert np.sum(im_kwargs["scale"] != 1.0) > 0 diff --git a/src/yt_napari/_tests/test_widget_reader.py b/src/yt_napari/_tests/test_widget_reader.py index 72d4fcf..a92a353 100644 --- a/src/yt_napari/_tests/test_widget_reader.py +++ b/src/yt_napari/_tests/test_widget_reader.py @@ -2,9 +2,11 @@ import numpy as np +from yt_napari import _widget_reader as _wr from yt_napari._ds_cache import dataset_cache -from yt_napari._widget_reader import ReaderWidget, SelectionEntry -from yt_napari.viewer import Scene + +# import ReaderWidget, SelectionEntry, TimeSeriesReader +from yt_napari._special_loaders import _construct_ugrid_timeseries # note: the cache is disabled for all the tests in this file due to flakiness # in github CI. It may be that loading from a true file, rather than the @@ -13,11 +15,11 @@ def test_widget_reader_add_selections(make_napari_viewer, yt_ugrid_ds_fn): viewer = make_napari_viewer() - r = ReaderWidget(napari_viewer=viewer) + r = _wr.ReaderWidget(napari_viewer=viewer) r.add_new_button.click() assert len(r.active_selections) == 1 sel = list(r.active_selections.values())[0] - assert isinstance(sel, SelectionEntry) + assert isinstance(sel, _wr.SelectionEntry) assert sel.selection_type == "Region" sel.expand() sel.expand() @@ -28,9 +30,11 @@ def test_widget_reader_add_selections(make_napari_viewer, yt_ugrid_ds_fn): r.add_new_button.click() assert len(r.active_selections) == 1 sel = list(r.active_selections.values())[0] - assert isinstance(sel, SelectionEntry) + assert isinstance(sel, _wr.SelectionEntry) assert sel.selection_type == "Slice" + r.deleteLater() + def _rebuild_data(final_shape, data): # the yt file thats being loaded from the pytest fixture is a saved @@ -44,12 +48,12 @@ def _rebuild_data(final_shape, data): def test_widget_reader(make_napari_viewer, yt_ugrid_ds_fn): viewer = make_napari_viewer() - r = ReaderWidget(napari_viewer=viewer) + r = _wr.ReaderWidget(napari_viewer=viewer) r.ds_container.filename.value = yt_ugrid_ds_fn r.ds_container.store_in_cache.value = False r.add_new_button.click() sel = list(r.active_selections.values())[0] - assert isinstance(sel, SelectionEntry) + assert isinstance(sel, _wr.SelectionEntry) mgui_region = sel.selection_container_raw mgui_region.fields.field_type.value = "gas" @@ -59,18 +63,19 @@ def test_widget_reader(make_napari_viewer, yt_ugrid_ds_fn): rebuild = partial(_rebuild_data, mgui_region.resolution.value) r._post_load_function = rebuild r.load_data() + r.deleteLater() def test_subsequent_load(make_napari_viewer, yt_ugrid_ds_fn): viewer = make_napari_viewer() - r = ReaderWidget(napari_viewer=viewer) + r = _wr.ReaderWidget(napari_viewer=viewer) r.ds_container.filename.value = yt_ugrid_ds_fn r.ds_container.store_in_cache.value = False r.add_new_button.click() sel = list(r.active_selections.values())[0] - assert isinstance(sel, SelectionEntry) + assert isinstance(sel, _wr.SelectionEntry) mgui_region = sel.selection_container_raw mgui_region.fields.field_type.value = "gas" @@ -96,6 +101,42 @@ def test_subsequent_load(make_napari_viewer, yt_ugrid_ds_fn): r.clear_cache() assert len(dataset_cache.available) == 0 - _ = r.yt_scene - yt_scene = r.yt_scene - assert isinstance(yt_scene, Scene) + r.deleteLater() + + +def test_timeseries_widget_reader(make_napari_viewer, tmp_path): + viewer = make_napari_viewer() + _wr._use_threading = False + nfiles = 4 + file_dir, flist_actual = _construct_ugrid_timeseries(tmp_path, nfiles) + + tsr = _wr.TimeSeriesReader(napari_viewer=viewer) + + tsr.ds_container.file_selection.directory.value = file_dir + tsr.ds_container.file_selection.file_pattern.value = "_ytnapari_load_grid-????" + tsr.ds_container.load_as_stack.value = True + tsr.add_new_button.click() + sel = list(tsr.active_selections.values())[0] + assert isinstance(sel, _wr.SelectionEntry) + + mgui_region = sel.selection_container_raw + mgui_region.fields.field_type.value = "stream" + mgui_region.fields.field_name.value = "density" + mgui_region.resolution.value = (10, 10, 10) + + tsr.load_data() + assert len(viewer.layers) == 1 + + viewer.layers.clear() + tsr.ds_container.load_as_stack.value = False + tsr.load_data() + assert len(viewer.layers) == nfiles + + viewer.layers.clear() + filestr_list = "_ytnapari_load_grid-0001, _ytnapari_load_grid-0002" + tsr.ds_container.file_selection.file_list.value = filestr_list + tsr.ds_container.file_selection.file_pattern.value = "" + tsr.load_data() + assert len(viewer.layers) == 2 + + tsr.deleteLater() diff --git a/src/yt_napari/_widget_reader.py b/src/yt_napari/_widget_reader.py index 01df74d..b0a8850 100644 --- a/src/yt_napari/_widget_reader.py +++ b/src/yt_napari/_widget_reader.py @@ -3,25 +3,36 @@ import napari from magicgui import widgets +from napari.qt.threading import thread_worker from qtpy import QtCore from qtpy.QtWidgets import QComboBox, QHBoxLayout, QPushButton, QVBoxLayout, QWidget from yt_napari import _data_model, _gui_utilities, _model_ingestor from yt_napari._ds_cache import dataset_cache -from yt_napari.viewer import Scene, _check_for_reference_layer +from yt_napari.viewer import _check_for_reference_layer -class ReaderWidget(QWidget): +class YTReader(QWidget): + + _pydantic_model = None + def __init__(self, napari_viewer: "napari.viewer.Viewer", parent=None): super().__init__(parent) self.setLayout(QVBoxLayout()) self.viewer = napari_viewer + self._post_load_function: Optional[Callable] = None + self.add_dataset_selection_widget() + self.add_spatial_selection_widgets() + self.add_load_group_widgets() + + def add_dataset_selection_widget(self): self.ds_container = _gui_utilities.get_yt_data_container( - ignore_attrs="selections" + ignore_attrs="selections", pydantic_model_class=self._pydantic_model ) self.layout().addWidget(self.ds_container.native) + def add_spatial_selection_widgets(self): # click button to add layer addition_group_layout = QHBoxLayout() add_new_button = widgets.PushButton(text="Click to add new selection") @@ -57,17 +68,8 @@ def __init__(self, napari_viewer: "napari.viewer.Viewer", parent=None): self.layout().addLayout(removal_group_layout) - # the load and clear buttons - load_group = QHBoxLayout() - self._post_load_function: Optional[Callable] = None - pb = widgets.PushButton(text="Load Selections") - pb.clicked.connect(self.load_data) - load_group.addWidget(pb.native) - - cc = widgets.PushButton(text="Clear cache") - cc.clicked.connect(self.clear_cache) - load_group.addWidget(cc.native) - self.layout().addLayout(load_group) + def add_load_group_widgets(self): + pass def add_a_selection(self): selection_type = self.new_selection_type.currentText() @@ -90,13 +92,21 @@ def remove_selection(self): self.active_sel_list.clear() self.active_sel_list.insertItems(0, list(self.active_selections.keys())) - _yt_scene: Scene = None # will persist across widget calls - @property - def yt_scene(self): - if self._yt_scene is None: - self._yt_scene = Scene() - return self._yt_scene +class ReaderWidget(YTReader): + + _pydantic_model = _data_model.DataContainer + + def add_load_group_widgets(self): + load_group = QHBoxLayout() + pb = widgets.PushButton(text="Load Selections") + pb.clicked.connect(self.load_data) + load_group.addWidget(pb.native) + + cc = widgets.PushButton(text="Clear cache") + cc.clicked.connect(self.clear_cache) + load_group.addWidget(cc.native) + self.layout().addLayout(load_group) def clear_cache(self): dataset_cache.rm_all() @@ -117,7 +127,7 @@ def load_data(self): py_kwargs = {} _gui_utilities.translator.get_pydantic_kwargs( self.ds_container, - _data_model.DataContainer, + self._pydantic_model, py_kwargs, ignore_attrs="selections", ) @@ -127,14 +137,14 @@ def load_data(self): # now ready to instantiate the base model py_kwargs = { - "data": [ + "datasets": [ py_kwargs, ] } model = _data_model.InputModel.parse_obj(py_kwargs) # process each layer - layer_list = _model_ingestor._process_validated_model(model) + layer_list, _ = _model_ingestor._process_validated_model(model) # align all layers after checking for or setting the reference layer ref_layer = _check_for_reference_layer(self.viewer.layers) @@ -198,3 +208,82 @@ def get_current_pydantic_kwargs(self) -> dict: mgui_sel, pydantic_model, py_kwargs ) return py_kwargs + + +_use_threading = True + + +class TimeSeriesReader(YTReader): + _pydantic_model = _data_model.Timeseries + + def add_load_group_widgets(self): + + # the load and clear buttons + load_group = QHBoxLayout() + + pb = widgets.PushButton(text="Load Selections") + pb.clicked.connect(self.load_data) + load_group.addWidget(pb.native) + self.layout().addLayout(load_group) + + def load_data(self): + + # first, get the pydantic args for each selection type, embed in lists + selections_by_type = defaultdict(list) + for selection in self.active_selections.values(): + py_kwargs = selection.get_current_pydantic_kwargs() + sel_key = selection.selection_type.lower() + "s" + selections_by_type[sel_key].append(py_kwargs) + + # next, process remaining arguments (skipping selections): + py_kwargs = {} + _gui_utilities.translator.get_pydantic_kwargs( + self.ds_container, + self._pydantic_model, + py_kwargs, + ignore_attrs="selections", + ) + + if py_kwargs["file_selection"]["file_pattern"] == "": + py_kwargs["file_selection"]["file_pattern"] = None + + if py_kwargs["file_selection"]["file_list"] == [""]: + py_kwargs["file_selection"]["file_list"] = None + + if py_kwargs["file_selection"]["file_range"] == (0, 0, 0): + py_kwargs["file_selection"]["file_range"] = None + + # add selections in + py_kwargs["selections"] = selections_by_type + + # now ready to instantiate the base model + py_kwargs = { + "timeseries": [ + py_kwargs, + ] + } + + model = _data_model.InputModel.parse_obj(py_kwargs) + + if _use_threading: + worker = time_series_load(model) + worker.returned.connect(self.process_timeseries_layers) + worker.start() + else: + _, layer_list = _model_ingestor._process_validated_model(model) + self.process_timeseries_layers(layer_list) + + def process_timeseries_layers(self, layer_list): + for new_layer in layer_list: + im_arr, im_kwargs, _ = new_layer + # probably can remove since the _special_loaders can be used + # if self._post_load_function is not None: + # im_arr = self._post_load_function(im_arr) + # add the new layer + self.viewer.add_image(im_arr, **im_kwargs) + + +@thread_worker(progress=True) +def time_series_load(model): + _, layer_list = _model_ingestor._process_validated_model(model) + return layer_list diff --git a/src/yt_napari/napari.yaml b/src/yt_napari/napari.yaml index 197be9a..3e05518 100644 --- a/src/yt_napari/napari.yaml +++ b/src/yt_napari/napari.yaml @@ -8,6 +8,9 @@ contributions: - id: yt-napari.reader_widget title: Read in a selection of data from yt python_name: yt_napari._widget_reader:ReaderWidget + - id: yt-napari.timeseries_widget + title: Read 2D selections from yt timeseries + python_name: yt_napari._widget_reader:TimeSeriesReader readers: - command: yt-napari.get_reader accepts_directories: false @@ -15,3 +18,5 @@ contributions: widgets: - command: yt-napari.reader_widget display_name: yt Reader + - command: yt-napari.timeseries_widget + display_name: yt Time Series Reader diff --git a/src/yt_napari/schemas/yt-napari_0.2.0.json b/src/yt_napari/schemas/yt-napari_0.2.0.json new file mode 100644 index 0000000..6ed4f9f --- /dev/null +++ b/src/yt_napari/schemas/yt-napari_0.2.0.json @@ -0,0 +1,406 @@ +{ + "title": "InputModel", + "type": "object", + "properties": { + "datasets": { + "title": "Datasets", + "description": "list of dataset containers to load", + "type": "array", + "items": { + "$ref": "#/definitions/DataContainer" + } + }, + "timeseries": { + "title": "Timeseries", + "description": "List of timeseries to load", + "type": "array", + "items": { + "$ref": "#/definitions/Timeseries" + } + } + }, + "definitions": { + "ytField": { + "title": "ytField", + "type": "object", + "properties": { + "field_type": { + "title": "Field Type", + "description": "a field type in the yt dataset", + "type": "string" + }, + "field_name": { + "title": "Field Name", + "description": "a field in the yt dataset", + "type": "string" + }, + "take_log": { + "title": "Take Log", + "description": "if true, will apply log10 to the selected data", + "default": true, + "type": "boolean" + } + } + }, + "Left_Edge": { + "title": "Left_Edge", + "type": "object", + "properties": { + "value": { + "title": "Value", + "description": "3-element unitful tuple.", + "default": [ + 0.0, + 0.0, + 0.0 + ], + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ] + }, + "unit": { + "title": "Unit", + "description": "the unit length string.", + "default": "code_length", + "type": "string" + } + } + }, + "Right_Edge": { + "title": "Right_Edge", + "type": "object", + "properties": { + "value": { + "title": "Value", + "description": "3-element unitful tuple.", + "default": [ + 1.0, + 1.0, + 1.0 + ], + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ] + }, + "unit": { + "title": "Unit", + "description": "the unit length string.", + "default": "code_length", + "type": "string" + } + } + }, + "Region": { + "title": "Region", + "type": "object", + "properties": { + "fields": { + "title": "Fields", + "description": "list of fields to load for this selection", + "type": "array", + "items": { + "$ref": "#/definitions/ytField" + } + }, + "left_edge": { + "title": "Left Edge", + "description": "the left edge (min x, min y, min z)", + "allOf": [ + { + "$ref": "#/definitions/Left_Edge" + } + ] + }, + "right_edge": { + "title": "Right Edge", + "description": "the right edge (max x, max y, max z)", + "allOf": [ + { + "$ref": "#/definitions/Right_Edge" + } + ] + }, + "resolution": { + "title": "Resolution", + "description": "the resolution at which to sample between the edges.", + "default": [ + 400, + 400, + 400 + ], + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "integer" + }, + { + "type": "integer" + }, + { + "type": "integer" + } + ] + } + } + }, + "Length_Tuple": { + "title": "Length_Tuple", + "type": "object", + "properties": { + "value": { + "title": "Value", + "description": "3-element unitful tuple.", + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ] + }, + "unit": { + "title": "Unit", + "description": "the unit length string.", + "default": "code_length", + "type": "string" + } + } + }, + "Length_Value": { + "title": "Length_Value", + "type": "object", + "properties": { + "value": { + "title": "Value", + "description": "Single unitful value.", + "type": "number" + }, + "unit": { + "title": "Unit", + "description": "the unit length string.", + "default": "code_length", + "type": "string" + } + } + }, + "Slice": { + "title": "Slice", + "type": "object", + "properties": { + "fields": { + "title": "Fields", + "description": "list of fields to load for this selection", + "type": "array", + "items": { + "$ref": "#/definitions/ytField" + } + }, + "normal": { + "title": "Normal", + "description": "the normal axis of the slice", + "type": "string" + }, + "center": { + "title": "Center", + "description": "The center point of the slice, default domain center", + "allOf": [ + { + "$ref": "#/definitions/Length_Tuple" + } + ] + }, + "slice_width": { + "title": "Slice Width", + "description": "The slice width, defaults to full domain", + "allOf": [ + { + "$ref": "#/definitions/Length_Value" + } + ] + }, + "slice_height": { + "title": "Slice Height", + "description": "The slice width, defaults to full domain", + "allOf": [ + { + "$ref": "#/definitions/Length_Value" + } + ] + }, + "resolution": { + "title": "Resolution", + "description": "the resolution at which to sample the slice", + "default": [ + 400, + 400 + ], + "type": "array", + "minItems": 2, + "maxItems": 2, + "items": [ + { + "type": "integer" + }, + { + "type": "integer" + } + ] + }, + "periodic": { + "title": "Periodic", + "description": "should the slice be periodic? default False.", + "default": false, + "type": "boolean" + } + } + }, + "SelectionObject": { + "title": "SelectionObject", + "type": "object", + "properties": { + "regions": { + "title": "Regions", + "description": "a list of regions to load", + "type": "array", + "items": { + "$ref": "#/definitions/Region" + } + }, + "slices": { + "title": "Slices", + "description": "a list of slices to load", + "type": "array", + "items": { + "$ref": "#/definitions/Slice" + } + } + } + }, + "DataContainer": { + "title": "DataContainer", + "type": "object", + "properties": { + "filename": { + "title": "Filename", + "description": "the filename for the dataset", + "type": "string" + }, + "selections": { + "title": "Selections", + "description": "selections to load in this dataset", + "allOf": [ + { + "$ref": "#/definitions/SelectionObject" + } + ] + }, + "store_in_cache": { + "title": "Store In Cache", + "description": "if enabled, will store references to yt datasets.", + "default": true, + "type": "boolean" + } + } + }, + "TimeSeriesFileSelection": { + "title": "TimeSeriesFileSelection", + "type": "object", + "properties": { + "directory": { + "title": "Directory", + "description": "The directory of the timseries", + "type": "string" + }, + "file_pattern": { + "title": "File Pattern", + "description": "The file pattern to match", + "type": "string" + }, + "file_list": { + "title": "File List", + "description": "List of files to load.", + "type": "array", + "items": { + "type": "string" + } + }, + "file_range": { + "title": "File Range", + "description": "Given files matched by file_pattern, this option will select a range. Argument orderis taken as start:stop:step.", + "type": "array", + "minItems": 3, + "maxItems": 3, + "items": [ + { + "type": "integer" + }, + { + "type": "integer" + }, + { + "type": "integer" + } + ] + } + } + }, + "Timeseries": { + "title": "Timeseries", + "type": "object", + "properties": { + "file_selection": { + "$ref": "#/definitions/TimeSeriesFileSelection" + }, + "selections": { + "title": "Selections", + "description": "selections to load in this dataset", + "allOf": [ + { + "$ref": "#/definitions/SelectionObject" + } + ] + }, + "load_as_stack": { + "title": "Load As Stack", + "description": "If True, will stack images along a new dimension.", + "default": false, + "type": "boolean" + } + }, + "required": [ + "file_selection" + ] + } + } +} diff --git a/src/yt_napari/timeseries.py b/src/yt_napari/timeseries.py new file mode 100644 index 0000000..6333ec4 --- /dev/null +++ b/src/yt_napari/timeseries.py @@ -0,0 +1,471 @@ +import abc +import os.path +from typing import List, Optional, Tuple, Union + +import numpy as np +import yt +from napari import Viewer +from unyt import unyt_array, unyt_quantity + +from yt_napari import _data_model as _dm, _model_ingestor as _mi + + +class _Selection(abc.ABC): + nd: int = None + + def __init__(self, field: Tuple[str, str], take_log: Optional[bool] = None): + self.field = field + self._take_log = take_log + self._aspect_ratio = None + + @abc.abstractmethod + def sample_ds(self, ds): + """sample a yt dataset with the selection object""" + + @property + def _requires_scale(self): + return any(self._aspect_ratio != 1.0) + + @property + def _scale(self): + return 1.0 / self._aspect_ratio + + def take_log(self, ds): + if self._take_log is None: + self._take_log = ds._get_field_info(self.field).take_log + return self._take_log + + def _finalize_array(self, ds, sample): + if self.take_log(ds) is True: + return np.log10(sample) + return sample + + @staticmethod + def _validate_unit_tuple(val): + if isinstance(val, tuple): + return val[0], val[1] + return None, None + + +class Region(_Selection): + """ + A 3D rectangular selection through a domain. + + Parameters + ---------- + field: (str, str) + a yt field present in all timeseries to load. + left_edge: unyt_array or (ndarray, str) + (optional) a 3-element unyt_array defining the left edge of the region, + defaults to the domain left_edge of each active timestep. + right_edge: unyt_array or (ndarray, str) + (optional) a 3-element unyt_array defining the right edge of the region, + defaults to the domain right_edge of each active timestep. + resolution: (int, int, int) + (optional) 3-element tuple defining the resolution to sample at. Default + is (400, 400, 400). + take_log: bool + (optional) If True, take the log10 of the sampled field. Defaults to the + default behavior for the field in the dataset. + """ + + nd = 3 + + def __init__( + self, + field: Tuple[str, str], + left_edge: Optional[Union[unyt_array, Tuple[np.ndarray, str]]] = None, + right_edge: Optional[Union[unyt_array, Tuple[np.ndarray, str]]] = None, + resolution: Optional[Tuple[int, int, int]] = (400, 400, 400), + take_log: Optional[bool] = None, + ): + + super().__init__(field, take_log=take_log) + self.left_edge = left_edge + self.right_edge = right_edge + self.resolution = resolution + self._le, self._le_units = self._validate_unit_tuple(left_edge) + self._re, self._re_units = self._validate_unit_tuple(right_edge) + + if self.left_edge is not None and self.right_edge is not None: + if self._le is not None: + LE = self._le + else: + LE = self.left_edge + + if self._re is not None: + RE = self._re + else: + RE = self.right_edge + self._calc_aspect_ratio(LE, RE) + + def _calc_aspect_ratio(self, LE, RE): + wid = RE - LE + self._aspect_ratio = wid / wid[0] + + def sample_ds(self, ds): + """ + return a fixed resolution sample of a field in a yt dataset. + + Parameters + ---------- + ds : yt dataset + the yt dataset to sample + + Examples + -------- + + >>> import yt + >>> import numpy as np + >>> from yt_napari.timeseries import Region + >>> ds = yt.load_sample("IsolatedGalaxy") + >>> le = np.array([0.4, 0.4, 0.4], 'Mpc') + >>> re = np.array([0.6, 0.6, 0.6], 'Mpc') + >>> reg = Region(("enzo", "Density"), left_edge=le, right_edge=re) + >>> reg_data = reg.sample_ds(ds) + + Notes + ----- + This is equivalent to `ds.r[...,...,..][field]`, but is a useful + abstraction for applying the same selection to a series of datasets. + """ + if self.left_edge is None: + LE = ds.domain_left_edge + elif self._le is not None: + LE = ds.arr(self._le, self._le_units) + else: + LE = self.left_edge + + if self.right_edge is None: + RE = ds.domain_right_edge + elif self._re is not None: + RE = ds.arr(self._re, self._re_units) + else: + RE = self.right_edge + + res = self.resolution + if self._aspect_ratio is None: + self._calc_aspect_ratio(LE, RE) + + # create the fixed resolution buffer + frb = ds.r[ + LE[0] : RE[0] : complex(0, res[0]), # noqa: E203 + LE[1] : RE[1] : complex(0, res[1]), # noqa: E203 + LE[2] : RE[2] : complex(0, res[2]), # noqa: E203 + ] + + data = frb[self.field] + return self._finalize_array(ds, data) + + +class Slice(_Selection): + """ + A 2D axis-normal slice through a domain. + + Parameters + ---------- + field: (str, str) + a yt field present in all timeseries to load. + normal: int or str + the normal axis for slicing + center: unyt_array + (optional) a 3-element unyt_array defining the slice center, defaults + to the domain center of each active timestep. + width: unyt_quantity or (value, unit) + (optional) the slice width, defaults to the domain width of each active + timestep. + height: unyt_quantity or (value, unit) + (optional) the slice height, defaults to the domain height of each + active timestep. + resolution: (int, int) + (optional) 2-element tuple defining the resolution to sample at. Default + is (400, 400). + periodic: bool + (optional, default is False) If True, treat domain as periodic + take_log: bool + (optional) If True, take the log10 of the sampled field. Defaults to the + default behavior for the field in the dataset. + """ + + nd = 2 + + def __init__( + self, + field: Tuple[str, str], + normal: Union[str, int], + center: Optional[Union[unyt_array, Tuple[np.ndarray, str]]] = None, + width: Optional[Union[unyt_quantity, Tuple[float, str]]] = None, + height: Optional[Union[unyt_quantity, Tuple[float, str]]] = None, + resolution: Optional[Tuple[int, int]] = (400, 400), + periodic: Optional[bool] = False, + take_log: Optional[bool] = None, + ): + super().__init__(field, take_log=take_log) + + self.normal = normal + self.center = center + self.height = height + self.width = width + self.resolution = resolution + self.periodic = periodic + + # handle the case where the length arrays are value-unit tuples + self._center_ndarray, self._center_units = self._validate_unit_tuple(center) + self._width_val, self._width_units = self._validate_unit_tuple(width) + self._height_val, self._height_units = self._validate_unit_tuple(height) + + if self.width is not None and self.height is not None: + if self._width_val is not None: + width = self._width_val + else: + width = self.width + if self._height_val is not None: + height = self._height_val + else: + height = self.height + self._calc_aspect_ratio(width, height) + + def _calc_aspect_ratio(self, width, height): + self._aspect_ratio = np.array([1.0, height / width]) + + def sample_ds(self, ds): + """ + return a fixed resolution slice of a field in a yt dataset. + + Parameters + ---------- + ds : yt dataset + the yt dataset to sample + + Examples + -------- + + >>> import yt + >>> from unyt import unyt_quantity + >>> from yt_napari.timeseries import Slice + >>> ds = yt.load_sample("IsolatedGalaxy") + >>> w = unyt_quantity(0.2, 'Mpc') + >>> slc = Slice(("enzo", "Density"), "x", width=w, height=w) + >>> slc_data = slc.sample_ds(ds) + + Notes + ----- + This is equivalent to `ds.slice(...).to_frb()[field]`, but is a useful + abstraction for applying the same selection to a series of datasets. + """ + if self.center is None: + center = ds.domain_center + elif self._center_ndarray is not None: + center = ds.arr(self._center_ndarray, self._center_units) + else: + center = self.center + + axid = ds.coordinates.axis_id + if self.width is None: + x_ax = axid[ds.coordinates.image_axis_name[self.normal][0]] + width = ds.domain_width[x_ax] + elif self._width_val is not None: + width = ds.arr(self._width_val, self._width_units) + else: + width = self.width + + if self.height is None: + y_ax = axid[ds.coordinates.image_axis_name[self.normal][1]] + height = ds.domain_width[y_ax] + elif self._height_val is not None: + height = ds.arr(self._height_val, self._height_units) + else: + height = self.height + + if self._aspect_ratio is None: + self._calc_aspect_ratio(width, height) + + frb, _ = _mi._process_slice( + ds, + self.normal, + center=center, + width=width, + height=height, + resolution=self.resolution, + periodic=self.periodic, + ) + + data = frb[self.field] # extract the field (the slow part) + return self._finalize_array(ds, data) + + +def _load_and_sample(file, selection: Union[Slice, Region], is_dask): + if is_dask: + yt.set_log_level(40) # errors and critical only + ds = _mi._load_with_timeseries_specials_check(file) + return selection.sample_ds(ds) + + +def _get_im_data( + selection: Union[Slice, Region], + file_dir: Optional[str] = None, + file_pattern: Optional[str] = None, + file_list: Optional[List[str]] = None, + file_range: Optional[Tuple[int, int, int]] = None, + load_as_stack: Optional[bool] = False, + use_dask: Optional[bool] = False, + return_delayed: Optional[bool] = True, + stack_scaling: Optional[float] = 1.0, + **kwargs, +): + + tfs = _dm.TimeSeriesFileSelection( + file_pattern=file_pattern, + directory=file_dir, + file_list=file_list, + file_range=file_range, + ) + files = _mi._find_timeseries_files(tfs) + + im_data = [] + if use_dask is False: + for file in files: + im_data.append(_load_and_sample(file, selection, use_dask)) + else: + try: + from dask import array as da, delayed + except ImportError: + msg = ( + "This functionality requires dask: " + 'pip install "dask[distributed, array]"' + ) + raise ImportError(msg) + for file in files: + data = delayed(_load_and_sample)(file, selection, use_dask) + im_data.append(da.from_delayed(data, selection.resolution, dtype=float)) + + # note: scale validation modifies kwargs in place + _validate_scale(selection, kwargs, load_as_stack, stack_scaling) + + if load_as_stack: + im_data = np.stack(im_data) + + if use_dask and return_delayed is False: + im_data = im_data.compute() + + return im_data, kwargs, files + + +def _validate_scale( + selection: Union[Slice, Region], + kwargdict: dict, + load_as_stack: bool, + stack_scaling: float, +): + + if "scale" in kwargdict: + # always use provided + sc = np.asarray(kwargdict.pop("scale")) + elif selection._aspect_ratio is not None: + # with dask, might not know the aspect ratio until after computation + sc = selection._scale + else: + sc = np.ones((selection.nd,)) + + if len(sc) == selection.nd and load_as_stack: + sc = np.concatenate( + [ + [ + stack_scaling, + ], + sc, + ] + ) + + kwargdict["scale"] = sc + + +def add_to_viewer( + viewer: Viewer, + selection: Union[Slice, Region], + file_dir: Optional[str] = None, + file_pattern: Optional[str] = None, + file_list: Optional[List[str]] = None, + file_range: Optional[Tuple[int, int, int]] = None, + load_as_stack: Optional[bool] = False, + use_dask: Optional[bool] = False, + return_delayed: Optional[bool] = True, + stack_scaling: Optional[float] = 1.0, + **kwargs, +): + """ + Sample a timeseries and add to a napari viewer + + Parameters + ---------- + viewer: napari.Viewer + a napari Viewer instance + selection: Slice or Region + the selection to apply to each matched dataset + file_dir: str + (optional) a file directory to prepend to either the file_pattern or + file_list argument. + file_pattern: str + (optional) a file pattern to match, not used if file_list is set. One of + file_pattern or file_list must be set. + file_list: str + (optional) a list of files to use. One of file_list or file_pattern must + be set. + file_range: (int, int, int) + (optional) A range to limit matched files in the form (start, stop, step). + load_as_stack: bool + (optional, default False) If True, the timeseries will be stacked to a + single image array + use_dask: bool + (optional, default False) If True, use dask to assemble the image array + return_delayed: bool + (optional, default True) If True and if use_dask=True, then the image + array will be a delayed array, resulting in lazy loading in napari. If + False and if use_dask=True, then dask will distribute sampling tasks + and assemble a final in-memory array. + stack_scaling: float + (optional, default 1.0) Applies a scaling to the effective image array + in the stacked (time) dimension if load_as_stack is True. If scale is + provided as a separate parameter, then stack_scaling is only used if + the len(scale) matches the dimensionality of the spatial selection. + **kwargs + any additional keyword arguments are passed to napari.Viewer().add_image() + + Examples + -------- + + >>> import napari + >>> from yt_napari.timeseries import Slice, add_to_viewer + >>> viewer = napari.Viewer() + >>> slc = Slice(("enzo", "Density"), "x") + >>> enzo_files = "enzo_tiny_cosmology/DD????/DD????" + >>> add_to_viewer(viewer, slc, file_pattern=enzo_files, file_range=(0,47, 5), + >>> load_as_stack=True) + """ + + im_data, im_kwargs, files = _get_im_data( + selection, + file_dir=file_dir, + file_pattern=file_pattern, + file_list=file_list, + file_range=file_range, + load_as_stack=load_as_stack, + use_dask=use_dask, + return_delayed=return_delayed, + stack_scaling=stack_scaling, + **kwargs, + ) + if load_as_stack: + viewer.add_image(im_data, **im_kwargs) + else: + basename = None + if "name" in im_kwargs: + basename = im_kwargs.pop("name") + + for im_id, im in enumerate(im_data): + if basename is not None: + name = f"{basename}_{im_id}" + else: + name = os.path.basename(files[im_id]) + name = f"{name}_{selection.field}" + viewer.add_image(im, name=name, **im_kwargs)