From b8450e2aea5470ce25550ec5e3cf4e3a5614fd37 Mon Sep 17 00:00:00 2001 From: BrianMichell Date: Wed, 23 Apr 2025 21:04:02 +0000 Subject: [PATCH 1/4] Copy documentation from unification to docs branch --- .readthedocs.yml | 4 +- docs/{reference.md => api_reference.md} | 2 +- docs/{usage.md => cli_usage.md} | 2 +- docs/conf.py | 59 +- docs/data_models/chunk_grids.md | 154 ++ docs/data_models/compressors.md | 100 ++ docs/data_models/data_types.md | 259 +++ docs/data_models/dimensions.md | 33 + docs/data_models/index.md | 9 + docs/data_models/v0.md | 52 + docs/data_models/v1.md | 118 ++ docs/index.md | 49 +- docs/notebooks/creation.ipynb | 822 ---------- docs/notebooks/quickstart.ipynb | 1389 ---------------- docs/notebooks/rechunking.ipynb | 564 ------- docs/requirements.txt | 2 + .../compression.ipynb | 7 + docs/tutorials/index.md | 8 + docs/tutorials/quickstart.ipynb | 1406 +++++++++++++++++ docs/tutorials/rechunking.ipynb | 514 ++++++ pyproject.toml | 2 +- src/mdio/__main__.py | 5 +- src/mdio/api/accessor.py | 4 + src/mdio/commands/segy.py | 4 + src/mdio/converters/mdio.py | 4 + src/mdio/converters/segy.py | 2 +- src/mdio/core/dimension.py | 5 + src/mdio/core/grid.py | 3 + src/mdio/segy/blocked_io.py | 2 +- 29 files changed, 2785 insertions(+), 2799 deletions(-) rename docs/{reference.md => api_reference.md} (98%) rename docs/{usage.md => cli_usage.md} (99%) create mode 100644 docs/data_models/chunk_grids.md create mode 100644 docs/data_models/compressors.md create mode 100644 docs/data_models/data_types.md create mode 100644 docs/data_models/dimensions.md create mode 100644 docs/data_models/index.md create mode 100644 docs/data_models/v0.md create mode 100644 docs/data_models/v1.md delete mode 100644 docs/notebooks/creation.ipynb delete mode 100644 docs/notebooks/quickstart.ipynb delete mode 100644 docs/notebooks/rechunking.ipynb rename docs/{notebooks => tutorials}/compression.ipynb (99%) create mode 100644 docs/tutorials/index.md create mode 100644 docs/tutorials/quickstart.ipynb create mode 100644 docs/tutorials/rechunking.ipynb diff --git a/.readthedocs.yml b/.readthedocs.yml index b405b0c6..d8fb7424 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -1,8 +1,8 @@ version: 2 build: - os: ubuntu-20.04 + os: ubuntu-22.04 tools: - python: "3.11" + python: "3.12" sphinx: configuration: docs/conf.py formats: all diff --git a/docs/reference.md b/docs/api_reference.md similarity index 98% rename from docs/reference.md rename to docs/api_reference.md index 9a3f7880..0ceba4f5 100644 --- a/docs/reference.md +++ b/docs/api_reference.md @@ -1,4 +1,4 @@ -# Reference +# API Reference ## Readers / Writers diff --git a/docs/usage.md b/docs/cli_usage.md similarity index 99% rename from docs/usage.md rename to docs/cli_usage.md index b11f5fda..6d75aa59 100644 --- a/docs/usage.md +++ b/docs/cli_usage.md @@ -1,4 +1,4 @@ -# Usage +# CLI Usage ## Ingestion and Export diff --git a/docs/conf.py b/docs/conf.py index 535bdb6d..6d104401 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -1,34 +1,85 @@ """Sphinx configuration.""" +# -- Project information ----------------------------------------------------- + project = "MDIO" author = "TGS" -copyright = "2023, TGS" +copyright = "2023, TGS" # noqa: A001 + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. + extensions = [ "sphinx.ext.autodoc", "sphinx.ext.napoleon", + "sphinx.ext.intersphinx", + "sphinx.ext.autosummary", + "sphinxcontrib.autodoc_pydantic", "sphinx.ext.autosectionlabel", "sphinx_click", "sphinx_copybutton", "myst_nb", + "sphinx_design", ] +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = [ + "_build", + "Thumbs.db", + "jupyter_execute", + ".DS_Store", + "**.ipynb_checkpoints", +] + +html_theme = "furo" +pygments_style = "vs" +pygments_dark_style = "material" + +# -- Intersphinx configuration ----------------------------------------------- + +intersphinx_mapping = { + "python": ("https://docs.python.org/3", None), + "numpy": ("https://numpy.org/doc/stable/", None), + "pydantic": ("https://docs.pydantic.dev/latest/", None), + "zarr": ("https://zarr.readthedocs.io/en/stable/", None), +} + +# -- Autodoc configuration --------------------------------------------------- + autodoc_typehints = "description" autodoc_typehints_format = "short" autodoc_member_order = "groupwise" -autoclass_content = "both" +autoclass_content = "class" autosectionlabel_prefix_document = True -html_theme = "furo" +autodoc_pydantic_field_list_validators = False +autodoc_pydantic_field_swap_name_and_alias = True +autodoc_pydantic_field_show_alias = False +autodoc_pydantic_model_show_config_summary = False +autodoc_pydantic_model_show_validator_summary = False +autodoc_pydantic_model_show_validator_members = False +autodoc_pydantic_model_show_field_summary = False + +# -- MyST configuration ------------------------------------------------------ myst_number_code_blocks = ["python"] myst_heading_anchors = 2 +myst_words_per_minute = 80 myst_enable_extensions = [ + "colon_fence", "linkify", "replacements", "smartquotes", + "attrs_inline", ] -# sphinx-copybutton configurations +# -- Sphinx Copybutton configuration ----------------------------------------- + copybutton_prompt_text = r">>> |\.\.\. |\$ |In \[\d*\]: | {2,5}\.\.\.: | {5,8}: " copybutton_line_continuation_character = "\\" copybutton_prompt_is_regexp = True diff --git a/docs/data_models/chunk_grids.md b/docs/data_models/chunk_grids.md new file mode 100644 index 00000000..38fe0115 --- /dev/null +++ b/docs/data_models/chunk_grids.md @@ -0,0 +1,154 @@ +```{eval-rst} +:tocdepth: 3 +``` + +```{currentModule} mdio.schema.chunk_grid + +``` + +# Chunk Grid Models + +```{article-info} +:author: Altay Sansal +:date: "{sub-ref}`today`" +:read-time: "{sub-ref}`wordcount-minutes` min read" +:class-container: sd-p-0 sd-outline-muted sd-rounded-3 sd-font-weight-light +``` + +The variables in MDIO data model can represent different types of chunk grids. +These grids are essential for managing multi-dimensional data arrays efficiently. +In this breakdown, we will explore four distinct data models within the MDIO schema, +each serving a specific purpose in data handling and organization. + +MDIO implements data models following the guidelines of the Zarr v3 spec and ZEPs: + +- [Zarr core specification (version 3)](https://zarr-specs.readthedocs.io/en/latest/v3/core/v3.0.html) +- [ZEP 1 — Zarr specification version 3](https://zarr.dev/zeps/accepted/ZEP0001.html) +- [ZEP 3 — Variable chunking](https://zarr.dev/zeps/draft/ZEP0003.html) + +## Regular Grid + +The regular grid models are designed to represent a rectangular and regularly +paced chunk grid. + +```{eval-rst} +.. autosummary:: + RegularChunkGrid + RegularChunkShape +``` + +For 1D array with `size = 31`{l=python}, we can divide it into 5 equally sized +chunks. Note that the last chunk will be truncated to match the size of the array. + +`{ "name": "regular", "configuration": { "chunkShape": [7] } }`{l=json} + +Using the above schema resulting array chunks will look like this: + +```bash + ←─ 7 ─→ ←─ 7 ─→ ←─ 7 ─→ ←─ 7 ─→ ↔ 3 +┌───────┬───────┬───────┬───────┬───┐ +└───────┴───────┴───────┴───────┴───┘ +``` + +For 2D array with shape `rows, cols = (7, 17)`{l=python}, we can divide it into 9 +equally sized chunks. + +`{ "name": "regular", "configuration": { "chunkShape": [3, 7] } }`{l=json} + +Using the above schema, the resulting 2D array chunks will look like below. +Note that the rows and columns are conceptual and visually not to scale. + +```bash + ←─ 7 ─→ ←─ 7 ─→ ↔ 3 +┌───────┬───────┬───┐ +│ ╎ ╎ │ ↑ +│ ╎ ╎ │ 3 +│ ╎ ╎ │ ↓ +├╶╶╶╶╶╶╶┼╶╶╶╶╶╶╶┼╶╶╶┤ +│ ╎ ╎ │ ↑ +│ ╎ ╎ │ 3 +│ ╎ ╎ │ ↓ +├╶╶╶╶╶╶╶┼╶╶╶╶╶╶╶┼╶╶╶┤ +│ ╎ ╎ │ ↕ 1 +└───────┴───────┴───┘ +``` + +## Rectilinear Grid + +The [RectilinearChunkGrid](RectilinearChunkGrid) model extends +the concept of chunk grids to accommodate rectangular and irregularly spaced chunks. +This model is useful in data structures where non-uniform chunk sizes are necessary. +[RectilinearChunkShape](RectilinearChunkShape) specifies the chunk sizes for each +dimension as a list allowing for irregular intervals. + +```{eval-rst} +.. autosummary:: + RectilinearChunkGrid + RectilinearChunkShape +``` + +:::{note} +It's important to ensure that the sum of the irregular spacings specified +in the `chunkShape` matches the size of the respective array dimension. +::: + +For 1D array with `size = 39`{l=python}, we can divide it into 5 irregular sized +chunks. + +`{ "name": "rectilinear", "configuration": { "chunkShape": [[10, 7, 5, 7, 10]] } }`{l=json} + +Using the above schema resulting array chunks will look like this: + +```bash + ←── 10 ──→ ←─ 7 ─→ ← 5 → ←─ 7 ─→ ←── 10 ──→ +┌──────────┬───────┬─────┬───────┬──────────┐ +└──────────┴───────┴─────┴───────┴──────────┘ +``` + +For 2D array with shape `rows, cols = (7, 25)`{l=python}, we can divide it into 12 +rectilinear (rectangular bur irregular) chunks. Note that the rows and columns are +conceptual and visually not to scale. + +`{ "name": "rectilinear", "configuration": { "chunkShape": [[3, 1, 3], [10, 5, 7, 3]] } }`{l=json} + +```bash + ←── 10 ──→ ← 5 → ←─ 7 ─→ ↔ 3 +┌──────────┬─────┬───────┬───┐ +│ ╎ ╎ ╎ │ ↑ +│ ╎ ╎ ╎ │ 3 +│ ╎ ╎ ╎ │ ↓ +├╶╶╶╶╶╶╶╶╶╶┼╶╶╶╶╶┼╶╶╶╶╶╶╶┼╶╶╶┤ +│ ╎ ╎ ╎ │ ↕ 1 +├╶╶╶╶╶╶╶╶╶╶┼╶╶╶╶╶┼╶╶╶╶╶╶╶┼╶╶╶┤ +│ ╎ ╎ ╎ │ ↑ +│ ╎ ╎ ╎ │ 3 +│ ╎ ╎ ╎ │ ↓ +└──────────┴─────┴───────┴───┘ +``` + +## Model Reference + +:::{dropdown} RegularChunkGrid +:animate: fade-in-slide-down + +```{eval-rst} +.. autopydantic_model:: RegularChunkGrid + +---------- + +.. autopydantic_model:: RegularChunkShape +``` + +::: +:::{dropdown} RectilinearChunkGrid +:animate: fade-in-slide-down + +```{eval-rst} +.. autopydantic_model:: RectilinearChunkGrid + +---------- + +.. autopydantic_model:: RectilinearChunkShape +``` + +::: diff --git a/docs/data_models/compressors.md b/docs/data_models/compressors.md new file mode 100644 index 00000000..2ad9d9a2 --- /dev/null +++ b/docs/data_models/compressors.md @@ -0,0 +1,100 @@ +```{eval-rst} +:tocdepth: 3 +``` + +```{currentModule} mdio.schema.compressors + +``` + +# Compressors + +```{article-info} +:author: Altay Sansal +:date: "{sub-ref}`today`" +:read-time: "{sub-ref}`wordcount-minutes` min read" +:class-container: sd-p-0 sd-outline-muted sd-rounded-3 sd-font-weight-light +``` + +## Dataset Compression + +MDIO relies on [numcodecs] for data compression. We provide good defaults based +on opinionated and limited heuristics for each compressor for various energy datasets. +However, using these data models, the compression can be customized. + +[Numcodecs] is a project that a convenient interface to different compression +libraries. We selected the [Blosc] and [ZFP] compressors for lossless and lossy +compression of energy data. + +## Blosc + +A high-performance compressor optimized for binary data, combining fast compression +with a byte-shuffle filter for enhanced efficiency, particularly effective with +numerical arrays in multi-threaded environments. + +For more details about compression modes, see [Blosc Documentation]. + +```{eval-rst} +.. autosummary:: + Blosc +``` + +## ZFP + +ZFP is a compression algorithm tailored for floating-point and integer arrays, offering +lossy and lossless compression with customizable precision, well-suited for large +scientific datasets with a focus on balancing data fidelity and compression ratio. + +For more details about compression modes, see [ZFP Documentation]. + +```{eval-rst} +.. autosummary:: + ZFP +``` + +[numcodecs]: https://github.com/zarr-developers/numcodecs +[blosc]: https://github.com/Blosc/c-blosc +[blosc documentation]: https://www.blosc.org/python-blosc/python-blosc.html +[zfp]: https://github.com/LLNL/zfp +[zfp documentation]: https://computing.llnl.gov/projects/zfp + +## Model Reference + +::: +:::{dropdown} Blosc +:animate: fade-in-slide-down + +```{eval-rst} +.. autopydantic_model:: Blosc + +---------- + +.. autoclass:: BloscAlgorithm() + :members: + :undoc-members: + :member-order: bysource + +---------- + +.. autoclass:: BloscShuffle() + :members: + :undoc-members: + :member-order: bysource +``` + +::: + +:::{dropdown} ZFP +:animate: fade-in-slide-down + +```{eval-rst} +.. autopydantic_model:: ZFP + +---------- + +.. autoclass:: ZFPMode() + :members: + :undoc-members: + :member-order: bysource +``` + +::: diff --git a/docs/data_models/data_types.md b/docs/data_models/data_types.md new file mode 100644 index 00000000..59c2d11b --- /dev/null +++ b/docs/data_models/data_types.md @@ -0,0 +1,259 @@ +```{eval-rst} +:tocdepth: 3 +``` + +```{currentModule} mdio.schema.dtype + +``` + +# Data Types + +```{article-info} +:author: Altay Sansal +:date: "{sub-ref}`today`" +:read-time: "{sub-ref}`wordcount-minutes` min read" +:class-container: sd-p-0 sd-outline-muted sd-rounded-3 sd-font-weight-light +``` + +## Scalar Type + +Scalar types are used to represent numbers and boolean values in MDIO arrays. + +```{eval-rst} +.. autosummary:: + :nosignatures: + + ScalarType +``` + +These numbers can be integers (whole numbers without a decimal +point, like 1, -15, 204), floating-point numbers (numbers with a fractional part, +like 3.14, -0.001, 2.71828) in various 16-64 bit formats like `float32` etc. + +It is important to choose the right type for the content of the data for type safety, +memory efficiency, performance, and accuracy of the numbers represented. Most scientific +datasets are `float16`, `float32`, or `float64` values. However, there are many good +use cases for integer and complex values as well. + +The [`ScalarType`](#ScalarType)s MDIO supports can be viewed below with the tabs. + +:::::{tab-set} + +::::{tab-item} Boolean +:::{table} +:widths: auto +:align: center + +| Data Type | Options | Example Value | +| --------- | --------------- | ------------- | +| `bool` | `False`, `True` | `True` | + +::: +:::: + +::::{tab-item} Integers +:::{table} +:widths: auto +:align: center + +| Data Type | Range | Example Value | +| --------- | ----------------------------------------------------------- | ------------- | +| `int8` | `-128` to `127` | `45` | +| `int16` | `-32,768` to `32,767` | `1,234` | +| `int32` | `-2,147,483,648` to `2,147,483,647` | `2,024` | +| `int64` | `-9,223,372,036,854,775,808` to `9,223,372,036,854,775,807` | `987,654,321` | + +::: +:::: + +::::{tab-item} Unsigned Integers +:::{table} +:widths: auto +:align: center + +| Data Type | Range | Example Value | +| --------- | ----------------------------------- | --------------- | +| `uint8` | `0` to `255` | `200` | +| `uint16` | `0` to `65,535` | `50,000` | +| `uint32` | `0` to `4,294,967,295` | `3,000,000` | +| `uint64` | `0` to `18,446,744,073,709,551,615` | `5,000,000,000` | + +::: +:::: + +::::{tab-item} Floating Point +:::{table} +:widths: auto +:align: center + +| Data Type | Range | Example Value | +| --------- | ------------------------------------------------------- | -------------------- | +| `float16` | `-65,504` to `65,504` | `10.10` | +| `float32` | `-3.4028235e+38` to `3.4028235e+38` | `0.1234567` | +| `float64` | `-1.7976931348623157e+308` to `1.7976931348623157e+308` | `3.1415926535897932` | + +::: + +**Precision** + +- `float16`: 2 decimal places +- `float32`: 7 decimal places +- `float32`: 16 decimal places + +:::: + +::::{tab-item} Complex Numbers +:::{table} +:widths: auto +:align: center + +| Data Type | Range | Example Value | +| ------------ | ------------------------------------------------------- | ------------------ | +| `complex64` | `-3.4028235e+38` to `3.4028235e+38` | `3.14+2.71j` | +| `complex128` | `-1.7976931348623157e+308` to `1.7976931348623157e+308` | `2.71828+3.14159j` | + +::: +Ranges are for both real and imaginary parts. +:::: + +::::: + +## Structured Type + +Structured data type organizes and stores data in a fixed arrangement, allowing memory +efficient access and manipulation. + +```{eval-rst} +.. autosummary:: + :nosignatures: + + StructuredType + StructuredField +``` + +Structured data types are an essential component in handling complex data structures, +particularly in specialized domains like seismic data processing for subsurface +imaging applications. These data types allow for the organization of heterogeneous +data into a single, structured format. + +They are designed to be memory-efficient, which is vital for handling large seismic +datasets. Structured data types are adaptable, allowing for the addition or +modification of fields. + +A [`StructuredType`](#StructuredType) consists of [`StructuredField`](#StructuredField)s. +Fields can be different [numeric types](#numeric-types), and each represent a specific +attribute of the seismic data, like coordinate, line numbers, and time stamps. + +Each [`StructuredField`](#StructuredField) must specify a `name` and a data format +(`format`). + +All the structured fields will be packed and there will be no gaps between them. + +## Examples + +The table below illustrate [ScalarType](#ScalarType) ranges and shows an example each +type. + +Variable `foo` with type `float32`. + +```json +{ + "name": "foo", + "dataType": "float32", + "dimensions": ["x", "y"] +} +``` + +Variable `bar` with type `uint8`. + +```json +{ + "name": "bar", + "dataType": "uint8", + "dimensions": ["x", "y"] +} +``` + +Below are a couple examples of [StructuredType](#StructuredType) with varying lengths. + +We can specify a variable named `headers` that holds a 32-byte struct with +four `int32` values. + +```json +{ + "name": "headers", + "dataType": { + "fields": [ + { "name": "cdp-x", "format": "int32" }, + { "name": "cdp-y", "format": "int32" }, + { "name": "inline", "format": "int32" }, + { "name": "crossline", "format": "int32" } + ] + }, + "dimensions": ["inline", "crossline"] +} +``` + +This will yield an in-memory or on-disk struct that looks like this (for each element): + +```bash + ←─ 4 ─→ ←─ 4 ─→ ←─ 4 ─→ ←─ 4 ─→ = 16-bytes +┌───────┬───────┬───────┬───────┐ +│ int32 ╎ int32 ╎ int32 ╎ int32 │ ⋯ (next sample) +└───────┴───────┴───────┴───────┘ + └→ cdp-x └→ cdp-y └→ inline └→crossline +``` + +The below example shows mixing different data types. + +```json +{ + "name": "headers", + "dataType": { + "fields": [ + { "name": "cdp", "format": "uint32" }, + { "name": "offset", "format": "int16" }, + { "name": "cdp-x", "format": "float64" }, + { "name": "cdp-y", "format": "float64" } + ] + }, + "dimensions": ["inline", "crossline"] +} +``` + +This will yield an in-memory or on-disk struct that looks like this (for each element): + +```bash + ←── 4 ──→ ← 2 → ←─── 8 ───→ ←─── 8 ───→ = 24-bytes +┌─────────┬─────┬───────────┬───────────┐ +│ int32 ╎int16╎ float64 ╎ float64 │ ⋯ (next sample) +└─────────┴─────┴───────────┴───────────┘ + └→ cdp └→ offset └→ cdp-x └→ cdp-y +``` + +## Model Reference + +:::{dropdown} Scalar Types +:animate: fade-in-slide-down + +```{eval-rst} +.. autoclass:: ScalarType() + :members: + :undoc-members: + :member-order: bysource +``` + +::: + +:::{dropdown} Structured Type +:animate: fade-in-slide-down + +```{eval-rst} +.. autopydantic_model:: StructuredType + +---------- + +.. autopydantic_model:: StructuredField +``` + +::: diff --git a/docs/data_models/dimensions.md b/docs/data_models/dimensions.md new file mode 100644 index 00000000..8496f75e --- /dev/null +++ b/docs/data_models/dimensions.md @@ -0,0 +1,33 @@ +```{eval-rst} +:tocdepth: 3 +``` + +```{currentModule} mdio.schema.dimension + +``` + +# Dimensions + +```{article-info} +:author: Altay Sansal +:date: "{sub-ref}`today`" +:read-time: "{sub-ref}`wordcount-minutes` min read" +:class-container: sd-p-0 sd-outline-muted sd-rounded-3 sd-font-weight-light +``` + +## Intro + +```{eval-rst} +.. autosummary:: NamedDimension +``` + +## Reference + +:::{dropdown} Dimension +:open: + +```{eval-rst} +.. autopydantic_model:: NamedDimension +``` + +::: diff --git a/docs/data_models/index.md b/docs/data_models/index.md new file mode 100644 index 00000000..83fd9ad1 --- /dev/null +++ b/docs/data_models/index.md @@ -0,0 +1,9 @@ +# Dataset Models + +This section contains the data models for the MDIO format. + +```{toctree} +:maxdepth: 2 +version_0 +version_1 +``` diff --git a/docs/data_models/v0.md b/docs/data_models/v0.md new file mode 100644 index 00000000..b2ee10b8 --- /dev/null +++ b/docs/data_models/v0.md @@ -0,0 +1,52 @@ +```{eval-rst} +:tocdepth: 3 +``` + +```{currentModule} mdio.schema.v0.dataset + +``` + +# MDIO v0 + +```{article-info} +:author: Altay Sansal +:date: "{sub-ref}`today`" +:read-time: "{sub-ref}`wordcount-minutes` min read" +:class-container: sd-p-0 sd-outline-muted sd-rounded-3 sd-font-weight-light +``` + +## Intro + +```{eval-rst} +.. autosummary:: + DatasetModelV0 + VariableModelV0 + DatasetMetadataModelV0 + DimensionModelV0 +``` + +## Reference + +:::{dropdown} Dataset +:open: + +```{eval-rst} +.. autopydantic_model:: DatasetModelV0 + :inherited-members: BaseModel +.. autopydantic_model:: DatasetMetadataModelV0 + :inherited-members: BaseModel +.. autopydantic_model:: DimensionModelV0 + :inherited-members: BaseModel +``` + +::: + +:::{dropdown} Variable +:open: + +```{eval-rst} +.. autopydantic_model:: VariableModelV0 + :inherited-members: BaseModel +``` + +::: diff --git a/docs/data_models/v1.md b/docs/data_models/v1.md new file mode 100644 index 00000000..a1779c2f --- /dev/null +++ b/docs/data_models/v1.md @@ -0,0 +1,118 @@ +```{eval-rst} +:tocdepth: 3 +``` + +```{currentModule} mdio.schema.v1.dataset + +``` + +# MDIO v1 + +```{article-info} +:author: Altay Sansal +:date: "{sub-ref}`today`" +:read-time: "{sub-ref}`wordcount-minutes` min read" +:class-container: sd-p-0 sd-outline-muted sd-rounded-3 sd-font-weight-light +``` + +## Intro + +```{eval-rst} +.. autosummary:: Dataset +.. autosummary:: DatasetMetadata +``` + +## Reference + +:::{dropdown} Dataset +:open: + +```{eval-rst} +.. autopydantic_model:: Dataset + :inherited-members: BaseModel +.. autopydantic_model:: DatasetMetadata + :inherited-members: BaseModel +``` + +::: +:::{dropdown} Variable + +```{eval-rst} +.. autopydantic_model:: mdio.schema.v1.variable.Variable + :inherited-members: BaseModel +.. autopydantic_model:: mdio.schema.v1.variable.Coordinate + :inherited-members: BaseModel +.. automodule:: mdio.schema.metadata + :members: UserAttributes +.. autopydantic_model:: mdio.schema.v1.variable.VariableMetadata + :inherited-members: BaseModel +``` + +::: + +:::{dropdown} Units + +```{eval-rst} +.. autopydantic_model:: mdio.schema.v1.units.AllUnits +``` + +```{eval-rst} +.. automodule:: mdio.schema.v1.units + :members: LengthUnitModel, + TimeUnitModel, + AngleUnitModel, + DensityUnitModel, + SpeedUnitModel, + FrequencyUnitModel, + VoltageUnitModel +``` + +::: + +:::{dropdown} Stats + +```{eval-rst} +.. autopydantic_model:: mdio.schema.v1.stats.StatisticsMetadata +.. autopydantic_model:: mdio.schema.v1.stats.SummaryStatistics +.. autopydantic_model:: mdio.schema.v1.stats.EdgeDefinedHistogram + :inherited-members: BaseModel +.. autopydantic_model:: mdio.schema.v1.stats.CenteredBinHistogram + :inherited-members: BaseModel +``` + +::: + +:::{dropdown} Enums + +```{eval-rst} +.. autoclass:: mdio.schema.v1.units.AngleUnitEnum() + :members: + :undoc-members: + :member-order: bysource +.. autoclass:: mdio.schema.v1.units.DensityUnitEnum() + :members: + :undoc-members: + :member-order: bysource +.. autoclass:: mdio.schema.v1.units.FrequencyUnitEnum() + :members: + :undoc-members: + :member-order: bysource +.. autoclass:: mdio.schema.v1.units.LengthUnitEnum() + :members: + :undoc-members: + :member-order: bysource +.. autoclass:: mdio.schema.v1.units.SpeedUnitEnum() + :members: + :undoc-members: + :member-order: bysource +.. autoclass:: mdio.schema.v1.units.TimeUnitEnum() + :members: + :undoc-members: + :member-order: bysource +.. autoclass:: mdio.schema.v1.units.VoltageUnitEnum() + :members: + :undoc-members: + :member-order: bysource +``` + +::: diff --git a/docs/index.md b/docs/index.md index 3cf5c22a..ba4db72d 100644 --- a/docs/index.md +++ b/docs/index.md @@ -6,24 +6,49 @@ end-before: [apache 2.0 license]: license [contributor guide]: contributing -[command-line usage]: usage -[api reference]: reference +[command-line usage]: cli_usage +[api reference]: api_reference [installation instructions]: installation ```{toctree} ---- -hidden: -maxdepth: 1 ---- +:hidden: +:caption: Getting Started + installation -notebooks/quickstart -notebooks/creation -notebooks/compression -notebooks/rechunking -usage -reference +cli_usage +``` + +```{toctree} +:hidden: +:caption: Learning and Support + +tutorials/index +api_reference +``` + +```{toctree} +:hidden: +:caption: Core Concepts and Structures + +data_models/index +data_models/dimensions +data_models/chunk_grids +data_models/data_types +data_models/compressors +``` + +```{toctree} +:hidden: +:caption: Community and Contribution + contributing Code of Conduct +``` + +```{toctree} +:hidden: +:caption: Additional Resources + License Changelog ``` diff --git a/docs/notebooks/creation.ipynb b/docs/notebooks/creation.ipynb deleted file mode 100644 index 1e2b8ba4..00000000 --- a/docs/notebooks/creation.ipynb +++ /dev/null @@ -1,822 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "# Create a New MDIO File From Scratch\n", - "\n", - "Here we will create an empty MDIO file and populate its fields.\n", - "\n", - "```{warning}\n", - "For plotting, the notebook requires [Matplotlib](https://matplotlib.org/) as a dependency. Please install it before executing using\n", - "`pip install matplotlib` or `conda install matplotlib`.\n", - "```\n", - "\n", - "We first need to import the configuration classes and create function to be able to create the empty MDIO." - ] - }, - { - "cell_type": "code", - "metadata": { - "pycharm": { - "name": "#%%\n" - }, - "ExecuteTime": { - "end_time": "2025-04-16T14:50:04.371422Z", - "start_time": "2025-04-16T14:50:04.368107Z" - } - }, - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "from mdio import MDIOVariableConfig, MDIOCreateConfig, Grid, Dimension, create_empty\n", - "from mdio import MDIOWriter, MDIOReader\n", - "from mdio.converters.segy import get_compressor\n", - "from mdio.segy.compat import mdio_segy_spec" - ], - "outputs": [], - "execution_count": 2 - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Setting Up Grid Dimensions and Variable(s)\n", - "\n", - "Let's try to create an MDIO file in 3D with known `inline`, `crossline`, and `sample`\n", - "dimensions. This is exactly like a 3D Post-Stack dataset.\n", - "\n", - "We will use the standard `chunked_012` access pattern. All variable names must start\n", - "with `chunked_*` for `MDIOReader` to be able to open them with any access pattern.\n", - "\n", - "We will also use an MDIO private utility function to get the compressor easily. The\n", - "compressor is fully customizable, but this function gives us ones available in SEG-Y\n", - "ingestion.\n", - "\n", - "If we want headers, we can also provide `header_dtype` which is a Numpy `dtype`. Again,\n", - "we will be using the standard one MDIO uses for ingesting SEG-Ys. (Similar to SEG-Y Rev1).\n", - "\n", - "At the end we create empty MDIO on local disk or cloud, based on the path string." - ] - }, - { - "cell_type": "code", - "metadata": { - "pycharm": { - "name": "#%%\n" - }, - "ExecuteTime": { - "end_time": "2025-04-16T14:50:06.121450Z", - "start_time": "2025-04-16T14:50:06.002634Z" - } - }, - "source": [ - "grid = Grid(\n", - " dims=[\n", - " Dimension(name=\"inline\", coords=range(100, 300, 1)), # 100-300 with step 1\n", - " Dimension(name=\"crossline\", coords=range(1000, 1600, 2)), # 1000-1600 with step 2\n", - " Dimension(name=\"sample\", coords=range(0, 3000, 4)), # 0-3 seconds 4ms sample rate\n", - " ]\n", - ")\n", - "\n", - "compressor = get_compressor(lossless=True)\n", - "header_dtype = mdio_segy_spec().trace.header.dtype\n", - "variable = MDIOVariableConfig(\n", - " name=\"chunked_012\",\n", - " dtype=\"float32\",\n", - " chunks=(128, 128, 128),\n", - " compressors=compressor,\n", - " header_dtype=header_dtype,\n", - ")\n", - "\n", - "create_conf = MDIOCreateConfig(path=\"demo.mdio\", grid=grid, variables=[variable])\n", - "create_empty(config=create_conf);" - ], - "outputs": [], - "execution_count": 3 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Populating the MDIO\n", - "\n", - "Once empty MDIO is created, you can populate it with sample data, header data,\n", - "metadata, and statistics. The `live_mask` is automatically flipped to 1 after\n", - "every write. However, the consistency of the `live_mask` is up to the user. If\n", - "not populated correctly, at read time, traces may be skipped.\n", - "\n", - "We will read the usual stats and as you can see they're all empty. Text header\n", - "and binary header are only required if we are going to export this back to SEG-Y,\n", - "and can be modified. We can edit these if necessary using the writer." - ] - }, - { - "cell_type": "code", - "metadata": { - "pycharm": { - "name": "#%%\n" - }, - "ExecuteTime": { - "end_time": "2025-04-16T14:50:09.974442Z", - "start_time": "2025-04-16T14:50:09.951257Z" - } - }, - "source": [ - "writer = MDIOWriter(create_conf.path)\n", - "\n", - "# Truncate text header for display\n", - "writer.text_header[:5], writer.binary_header, writer.stats" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "(['C00 ',\n", - " 'C01 ',\n", - " 'C02 ',\n", - " 'C03 ',\n", - " 'C04 '],\n", - " {},\n", - " {'rms': 0, 'min': 0, 'mean': 0, 'max': 0, 'std': 0})" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 4 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Updating File and Checking with `MDIOReader`.\n", - "\n", - "We write traces here, the headers are still empty. If you need the headers\n", - "populated, this is where they would be written to file as well.\n", - "\n", - "All the extra metadata we are writing is so that we can export back to SEG-Y\n", - "in the future. If that's not a requirement most of the metadata can be\n", - "omitted.\n", - "\n", - "If you already have an MDIO prior to this, all the metadata can be copied\n", - "over from the previous version." - ] - }, - { - "cell_type": "code", - "metadata": { - "pycharm": { - "name": "#%%\n" - }, - "ExecuteTime": { - "end_time": "2025-04-16T14:50:12.498287Z", - "start_time": "2025-04-16T14:50:11.670230Z" - } - }, - "source": [ - "sample_dim = writer.grid.select_dim(\"sample\")\n", - "sample_interval = int(sample_dim.coords[1] - sample_dim.coords[0])\n", - "num_samples = sample_dim.size\n", - "writer.binary_header = {\n", - " \"data_sample_format\": 1,\n", - " \"sample_interval\": sample_interval,\n", - " \"samples_per_trace\": num_samples,\n", - " \"segy_revision_major\": 1,\n", - " \"segy_revision_minor\": 0,\n", - "}\n", - "\n", - "# Write some values to the file\n", - "writer[:5] = 1\n", - "writer[5:10] = 2\n", - "writer[50:100] = 3\n", - "writer[150:175] = -1\n", - "\n", - "# Write some made up stats\n", - "writer.stats = {\"mean\": 12, \"std\": 5, \"rms\": 3, \"min\": -4, \"max\": 4}\n", - "\n", - "reader = MDIOReader(create_conf.path)\n", - "reader.binary_header, reader.stats" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "({'data_sample_format': 1,\n", - " 'sample_interval': 4,\n", - " 'samples_per_trace': 750,\n", - " 'segy_revision_major': 1,\n", - " 'segy_revision_minor': 0},\n", - " {'rms': 3, 'min': -4, 'mean': 12, 'max': 4, 'std': 5})" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 5 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "Plot some of the data we populated:" - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:50:14.256953Z", - "start_time": "2025-04-16T14:50:14.036094Z" - } - }, - "source": [ - "fig, ax = plt.subplots(1, 2, sharex=\"all\")\n", - "ax[0].imshow(writer.live_mask[:].T, aspect=\"auto\")\n", - "ax[1].imshow(reader[:, 150].T, aspect=\"auto\")\n", - "\n", - "ax[0].set_xlabel(\"inline\"); ax[0].set_ylabel(\"crossline\")\n", - "ax[1].set_xlabel(\"inline\"); ax[1].set_ylabel(\"sample\")\n", - "ax[0].set_title(\"Live Mask\"); ax[1].set_title(\"Middle Crossline\")\n", - "fig.tight_layout();" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 6 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Write to SEG-Y\n", - "\n", - "Because we populated all the fields necessary for SEG-Y output, we can call the\n", - "MDIO to SEGY converter and get a file out." - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:50:15.788812Z", - "start_time": "2025-04-16T14:50:15.009889Z" - } - }, - "source": [ - "from mdio import mdio_to_segy\n", - "from segy import SegyFile\n", - "\n", - "\n", - "mdio_to_segy(\"demo.mdio\", \"demo.segy\")\n", - "segy = SegyFile(\"demo.segy\")\n", - "print(segy.binary_header)\n", - "print(segy.sample[:100])" - ], - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Unwrapping MDIO Blocks: 100%|██████████| 7/7 [00:00<00:00, 10.55it/s]\n", - "Merging lines: 100%|██████████| 1/1 [00:00<00:00, 17.26it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[(0, 0, 0, 0, 0, 4, 4000, 750, 750, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0)]\n", - "[[1. 1. 1. ... 1. 1. 1.]\n", - " [1. 1. 1. ... 1. 1. 1.]\n", - " [1. 1. 1. ... 1. 1. 1.]\n", - " ...\n", - " [1. 1. 1. ... 1. 1. 1.]\n", - " [1. 1. 1. ... 1. 1. 1.]\n", - " [1. 1. 1. ... 1. 1. 1.]]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "execution_count": 7 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": [ - "## Copying an Existing MDIO without Data and Headers\n", - "\n", - "We also provide a `create_empty_like` function which allows us to create an MDIO file\n", - "with the same structure and basic metadata as an existing one.\n", - "\n", - "This will carry over:\n", - "* All access patterns in source MDIO\n", - "* Grid (shape, coordinates, dimensions, etc)\n", - "* Text Header\n", - "* Binary Header\n", - "\n", - "It will **NOT** carry over:\n", - "* Trace data\n", - "* Header data\n", - "* Statistics\n", - "* Live Mask" - ] - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:50:17.246513Z", - "start_time": "2025-04-16T14:50:17.111779Z" - } - }, - "cell_type": "code", - "source": [ - "from mdio import create_empty_like\n", - "\n", - "copy_path = \"copy_of_existing.mdio\"\n", - "create_empty_like(create_conf.path, copy_path)\n", - "\n", - "copy_reader = MDIOReader(copy_path)\n", - "assert copy_reader.shape == reader.shape\n", - "assert copy_reader.binary_header == reader.binary_header\n", - "assert copy_reader.stats != reader.stats" - ], - "outputs": [], - "execution_count": 8 - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "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.12.3" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "104c0d4e90244ebc959e51a58794dcf4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "display": "inline-flex", - "flex_flow": "row wrap", - "width": "100%" - } - }, - "1c0f5b458ee1401eaa8de63c65802073": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "21b25dd6080d42368afc06770d5e1755": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_35fb49026dac479eba87217c2f6bcb9a", - "style": "IPY_MODEL_3ab3e27c83aa423d9ecdac94e576f0fe", - "value": "Ingesting SEG-Y in 6 chunks: 100%" - } - }, - "2693aae410f04e7587f0400b5eef1079": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "318aea09479a479981dcfa29bc856c67": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "35fb49026dac479eba87217c2f6bcb9a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3ab3e27c83aa423d9ecdac94e576f0fe": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "420b4a9492c54eb48d7779f38a09fd20": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "flex": "2" - } - }, - "42afe4fae9dd4bc4a341a231cf7a9c32": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4df685a95de542ffab6f265df89b8949": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "58eaddb54c8840da83d1f6503d6ba64f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5b3e72b71f304230bc36bb91f9c173be": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5c1fab0ccc7e42c69c2b663b67ca9e3c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "63a54817ae8b4c8d85b30d8c97e7ed0d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_e170d60a55a14c489d32b101293a9d33", - "IPY_MODEL_662ad93cf7b3470f8e197350441f09ca", - "IPY_MODEL_ac4abab2367e461e956e4e0edb27be44" - ], - "layout": "IPY_MODEL_c59d6fe969a04f4da332ae2a6fdb9c77" - } - }, - "63f87a2410ba47d38ad9f55a81357a29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_ca48140488574a28a7469552441560e4", - "style": "IPY_MODEL_ae2037efb9cc459e84bcc28ca7243437", - "value": " 2/2 [00:03<00:00, 3.01s/block]" - } - }, - "64eb2b9c8a094a1ea5f1991e5f09f5d9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "662ad93cf7b3470f8e197350441f09ca": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_420b4a9492c54eb48d7779f38a09fd20", - "max": 1, - "style": "IPY_MODEL_d16e93f72f3d4aeda2f5deee87e9754f", - "value": 1 - } - }, - "74283969ff5446c89bb83b00a70226cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_5c1fab0ccc7e42c69c2b663b67ca9e3c", - "style": "IPY_MODEL_1c0f5b458ee1401eaa8de63c65802073", - "value": " 6/6 [00:09<00:00, 2.48s/block]" - } - }, - "75cf0c1ed25e47aab20b060f3bb44fb8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_21b25dd6080d42368afc06770d5e1755", - "IPY_MODEL_c33f32b62a204ef094f67b10f8adbdc1", - "IPY_MODEL_74283969ff5446c89bb83b00a70226cf" - ], - "layout": "IPY_MODEL_91df4ac76fd744539d4237d6099f34a5" - } - }, - "7ff32d7deac14f21ab0f0939fe09e440": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "91df4ac76fd744539d4237d6099f34a5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "display": "inline-flex", - "flex_flow": "row wrap", - "width": "100%" - } - }, - "981634b52a7a4ffdae6186061c0b6482": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_f65266f861cf40ef84e9ec74a8e0b44c", - "IPY_MODEL_9aaf514a5035413d8cbbad58aa0221f4", - "IPY_MODEL_63f87a2410ba47d38ad9f55a81357a29" - ], - "layout": "IPY_MODEL_104c0d4e90244ebc959e51a58794dcf4" - } - }, - "9aaf514a5035413d8cbbad58aa0221f4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_b25523a221fd4b5e9211d07ef39cccf5", - "max": 2, - "style": "IPY_MODEL_318aea09479a479981dcfa29bc856c67", - "value": 2 - } - }, - "9fe5348964cd4f7880bcd33204bbc7a2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a03d238db31145b881a1be478f9eb72f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a6aabcd2e57348a49bb59477f6a9fd90": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_cfb02c9c7447491ca00bbb6acd99bb79", - "max": 26, - "style": "IPY_MODEL_7ff32d7deac14f21ab0f0939fe09e440", - "value": 26 - } - }, - "ac4abab2367e461e956e4e0edb27be44": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_58eaddb54c8840da83d1f6503d6ba64f", - "style": "IPY_MODEL_a03d238db31145b881a1be478f9eb72f", - "value": " 3/? [00:00<00:00, 8.29block/s]" - } - }, - "ae2037efb9cc459e84bcc28ca7243437": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b25523a221fd4b5e9211d07ef39cccf5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "flex": "2" - } - }, - "b9810ee38bbe43f4bba100e53379be65": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_42afe4fae9dd4bc4a341a231cf7a9c32", - "style": "IPY_MODEL_fdcea609ee7349629604217b625371d3", - "value": " 26/26 [00:01<00:00, 18.92block/s]" - } - }, - "c33f32b62a204ef094f67b10f8adbdc1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_d23d88490a1b4941b8ca228b7d4a39cb", - "max": 6, - "style": "IPY_MODEL_2693aae410f04e7587f0400b5eef1079", - "value": 6 - } - }, - "c59d6fe969a04f4da332ae2a6fdb9c77": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "display": "inline-flex", - "flex_flow": "row wrap", - "width": "100%" - } - }, - "ca48140488574a28a7469552441560e4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "cfb02c9c7447491ca00bbb6acd99bb79": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "flex": "2" - } - }, - "d16e93f72f3d4aeda2f5deee87e9754f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "d23d88490a1b4941b8ca228b7d4a39cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "flex": "2" - } - }, - "d565a20d37e84ed0a1195e9a90154960": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_db696e15587c4a54b82886b3eb5a0c96", - "IPY_MODEL_a6aabcd2e57348a49bb59477f6a9fd90", - "IPY_MODEL_b9810ee38bbe43f4bba100e53379be65" - ], - "layout": "IPY_MODEL_eab4b060672b4dd5a73ca7bb8f782cd2" - } - }, - "db696e15587c4a54b82886b3eb5a0c96": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_64eb2b9c8a094a1ea5f1991e5f09f5d9", - "style": "IPY_MODEL_5b3e72b71f304230bc36bb91f9c173be", - "value": "Step 1 / 2 Writing Blocks: 100%" - } - }, - "e170d60a55a14c489d32b101293a9d33": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_9fe5348964cd4f7880bcd33204bbc7a2", - "style": "IPY_MODEL_4df685a95de542ffab6f265df89b8949", - "value": "Step 2 / 2 Concat Blocks: " - } - }, - "e66368cda8124001b16459a0634029e2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "eab4b060672b4dd5a73ca7bb8f782cd2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "display": "inline-flex", - "flex_flow": "row wrap", - "width": "100%" - } - }, - "f65266f861cf40ef84e9ec74a8e0b44c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_fff4199774534d9f982f03738fbb08e7", - "style": "IPY_MODEL_e66368cda8124001b16459a0634029e2", - "value": "Scanning SEG-Y for geometry attributes: 100%" - } - }, - "fdcea609ee7349629604217b625371d3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "fff4199774534d9f982f03738fbb08e7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/docs/notebooks/quickstart.ipynb b/docs/notebooks/quickstart.ipynb deleted file mode 100644 index 73033421..00000000 --- a/docs/notebooks/quickstart.ipynb +++ /dev/null @@ -1,1389 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "# Get Started in 10 Minutes\n", - "\n", - "In this page we will be showing basic capabilities of MDIO.\n", - "\n", - "For demonstration purposes, we will download the Teapot Dome open-source dataset. The dataset details and licensing can be found at the [SEG Wiki](https://wiki.seg.org/wiki/Teapot_dome_3D_survey).\n", - "\n", - "We are using the 3D seismic stack dataset named `filt_mig.sgy`.\n", - "\n", - "The full link for the dataset (hosted on AWS): http://s3.amazonaws.com/teapot/filt_mig.sgy\n", - "\n", - "```{warning}\n", - "For plotting, the notebook requires [Matplotlib](https://matplotlib.org/) as a dependency. Please install it before executing using\n", - "`pip install matplotlib` or `conda install matplotlib`.\n", - "```\n", - "\n", - "## Defining the SEG-Y Dataset\n", - "\n", - "Since MDIO 0.8 we can directly ingest remote SEG-Y files! The file is 386 MB in size. To make the header scan performant we can also\n", - "set up an environment variable for MDIO. See here for when to use this:\n", - "[Buffered Reads in Ingestion](https://mdio-python.readthedocs.io/en/stable/usage.html#buffered-reads-in-ingestion).\n", - "\n", - "The dataset is irregularly shaped, however it is padded to a rectangle with zero (dead traces). We will see that later at the live mask plotting." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:21:02.088111Z", - "start_time": "2025-04-16T18:21:02.085812Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "import os\n", - "os.environ[\"MDIO__IMPORT__CLOUD_NATIVE\"] = \"true\"\n", - "\n", - "url = \"http://s3.amazonaws.com/teapot/filt_mig.sgy\"" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Ingesting to MDIO\n", - "\n", - "To do this, we can use the convenient SEG-Y to MDIO converter.\n", - "\n", - "The `inline` and `crossline` values are located at bytes `181` and `185`. Note that this doesn't match any SEG-Y standards.\n", - "\n", - "MDIO uses [TGSAI/segy][segy-github] to parse the SEG-Y; the field names conform to its canonical keys defined in [SEGY Binary Header Keys][segy-binary-keys] and [SEGY Trace Header Keys][segy-trace-keys]. MDIO interprets the trace headers as SEG-Y Rev1 for historical reasons and will be more flexible in the next generation.\n", - "\n", - "`181` and `185` for Teapot should ideally map to `cdp_x` and `cdp_y` in the header arrays. However, because the file does not match the standard, they are mapped to the `inline` and `crossline` header keys on ingested headers.\n", - "\n", - "In summary, we will use the byte locations as defined for ingestion. However, because `inline` / `crossline` and flipped with `cdp_x` / `cdp_y`, we must interchange the keys later.\n", - "\n", - "[segy-github]: https://github.com/TGSAI/segy\n", - "[segy-binary-keys]: https://github.com/TGSAI/segy/blob/main/src/segy/standards/fields/binary.py\n", - "[segy-trace-keys]: https://github.com/TGSAI/segy/blob/main/src/segy/standards/fields/trace.py" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:21:32.254475Z", - "start_time": "2025-04-16T18:21:03.755455Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Scanning SEG-Y for geometry attributes: 100%|██████████| 7/7 [00:07<00:00, 1.07s/block]\n", - "Ingesting SEG-Y in 18 chunks: 100%|██████████| 18/18 [00:06<00:00, 2.60block/s]\n" - ] - } - ], - "source": [ - "from mdio import segy_to_mdio\n", - "\n", - "segy_to_mdio(\n", - " segy_path=url,\n", - " mdio_path_or_buffer=\"filt_mig.mdio\",\n", - " index_bytes=(181, 185),\n", - " index_names=(\"inline\", \"crossline\"),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "It only took a few seconds to ingest, since this is a very small file. \n", - "\n", - "However, MDIO scales up to TB (that's ~1,000 GB) sized volumes!\n", - "\n", - "## Opening the Ingested MDIO File\n", - "\n", - "Let's open the MDIO file with the `MDIOReader`.\n", - "\n", - "We will also turn on `return_metadata` function to get the live trace mask and trace headers." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:55:55.839293Z", - "start_time": "2025-04-16T14:55:55.833950Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "from mdio import MDIOReader\n", - "\n", - "mdio = MDIOReader(\"filt_mig.mdio\", return_metadata=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Querying Metadata\n", - "\n", - "Now let's look at the Textual Header by the convenient `text_header` attribute.\n", - "\n", - "You will notice the text header is parsed as a list of strings that are 80 characters long." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:55:57.253647Z", - "start_time": "2025-04-16T14:55:57.248667Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "['C 1 CLIENT: ROCKY MOUNTAIN OILFIELD TESTING CENTER ',\n", - " 'C 2 PROJECT: NAVAL PETROLEUM RESERVE #3 (TEAPOT DOME); NATRONA COUNTY, WYOMING ',\n", - " 'C 3 LINE: 3D ',\n", - " 'C 4 ',\n", - " 'C 5 THIS IS THE FILTERED POST STACK MIGRATION ',\n", - " 'C 6 ',\n", - " 'C 7 INLINE 1, XLINE 1: X COORDINATE: 788937 Y COORDINATE: 938845 ',\n", - " 'C 8 INLINE 1, XLINE 188: X COORDINATE: 809501 Y COORDINATE: 939333 ',\n", - " 'C 9 INLINE 188, XLINE 1: X COORDINATE: 788039 Y COORDINATE: 976674 ',\n", - " 'C10 INLINE NUMBER: MIN: 1 MAX: 345 TOTAL: 345 ',\n", - " 'C11 CROSSLINE NUMBER: MIN: 1 MAX: 188 TOTAL: 188 ',\n", - " \"C12 TOTAL NUMBER OF CDPS: 64860 BIN DIMENSION: 110' X 110' \",\n", - " 'C13 ',\n", - " 'C14 ',\n", - " 'C15 ',\n", - " 'C16 ',\n", - " 'C17 ',\n", - " 'C18 ',\n", - " 'C19 GENERAL SEGY INFORMATION ',\n", - " 'C20 RECORD LENGHT (MS): 3000 ',\n", - " 'C21 SAMPLE RATE (MS): 2.0 ',\n", - " 'C22 DATA FORMAT: 4 BYTE IBM FLOATING POINT ',\n", - " 'C23 BYTES 13- 16: CROSSLINE NUMBER (TRACE) ',\n", - " 'C24 BYTES 17- 20: INLINE NUMBER (LINE) ',\n", - " 'C25 BYTES 81- 84: CDP_X COORD ',\n", - " 'C26 BYTES 85- 88: CDP_Y COORD ',\n", - " 'C27 BYTES 181-184: INLINE NUMBER (LINE) ',\n", - " 'C28 BYTES 185-188: CROSSLINE NUMBER (TRACE) ',\n", - " 'C29 BYTES 189-192: CDP_X COORD ',\n", - " 'C30 BYTES 193-196: CDP_Y COORD ',\n", - " 'C31 ',\n", - " 'C32 ',\n", - " 'C33 ',\n", - " 'C34 ',\n", - " 'C35 ',\n", - " 'C36 Processed by: Excel Geophysical Services, Inc. ',\n", - " 'C37 8301 East Prentice Ave. Ste. 402 ',\n", - " 'C38 Englewood, Colorado 80111 ',\n", - " 'C39 (voice) 303.694.9629 (fax) 303.771.1646 ',\n", - " 'C40 END EBCDIC ']" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mdio.text_header" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "MDIO parses the binary header into a Python dictionary.\n", - "\n", - "We can easily query it by the `binary_header` attribute and see critical information about the original file." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:55:58.917621Z", - "start_time": "2025-04-16T14:55:58.913044Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'job_id': 9999,\n", - " 'line_num': 9999,\n", - " 'reel_num': 1,\n", - " 'data_traces_per_ensemble': 188,\n", - " 'aux_traces_per_ensemble': 0,\n", - " 'sample_interval': 2000,\n", - " 'orig_sample_interval': 0,\n", - " 'samples_per_trace': 1501,\n", - " 'orig_samples_per_trace': 1501,\n", - " 'data_sample_format': 1,\n", - " 'ensemble_fold': 57,\n", - " 'trace_sorting_code': 4,\n", - " 'vertical_sum_code': 1,\n", - " 'sweep_freq_start': 0,\n", - " 'sweep_freq_end': 0,\n", - " 'sweep_length': 0,\n", - " 'sweep_type_code': 0,\n", - " 'sweep_trace_num': 0,\n", - " 'sweep_taper_start': 0,\n", - " 'sweep_taper_end': 0,\n", - " 'taper_type_code': 0,\n", - " 'correlated_data_code': 2,\n", - " 'binary_gain_code': 1,\n", - " 'amp_recovery_code': 4,\n", - " 'measurement_system_code': 2,\n", - " 'impulse_polarity_code': 1,\n", - " 'vibratory_polarity_code': 0,\n", - " 'extended_data_traces_per_ensemble': 0,\n", - " 'extended_aux_traces_per_ensemble': 0,\n", - " 'extended_samples_per_trace': 0,\n", - " 'extended_orig_samples_per_trace': 0,\n", - " 'extended_ensemble_fold': 0,\n", - " 'fixed_length_trace_flag': 0,\n", - " 'num_extended_text_headers': 0,\n", - " 'segy_revision_major': 0,\n", - " 'segy_revision_minor': 0}" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mdio.binary_header" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## MDIO Grid, Dimensions, and Related Attributes\n", - "\n", - "MDIO also has named dimensions, so we can see which dimension (axis) corresponds to which coordinate.\n", - "\n", - "MDIO has an abstraction for an N-Dimensional grid. We can get the grid, and look at some of its properties." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:56:00.605526Z", - "start_time": "2025-04-16T14:56:00.602342Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "('inline', 'crossline', 'sample')" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mdio.grid.dim_names" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:56:01.648527Z", - "start_time": "2025-04-16T14:56:01.645840Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "np.int64(1)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mdio.grid.get_min(\"inline\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:56:04.965372Z", - "start_time": "2025-04-16T14:56:04.962498Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "np.int64(188)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mdio.grid.get_max(\"crossline\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "We can extract a dimension by name, and see its values. \n", - "\n", - "The `Dimension` has `name` and `coords` that returns a string and a numpy array." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:56:22.248867Z", - "start_time": "2025-04-16T14:56:22.245424Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Dimension(coords=array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,\n", - " 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n", - " 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,\n", - " 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,\n", - " 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,\n", - " 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,\n", - " 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n", - " 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,\n", - " 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,\n", - " 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n", - " 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,\n", - " 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156,\n", - " 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,\n", - " 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,\n", - " 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,\n", - " 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,\n", - " 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221,\n", - " 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,\n", - " 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,\n", - " 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,\n", - " 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273,\n", - " 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286,\n", - " 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299,\n", - " 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312,\n", - " 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325,\n", - " 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338,\n", - " 339, 340, 341, 342, 343, 344, 345]), name='inline')" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mdio.grid.select_dim(\"inline\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Fetching Data and Plotting\n", - "\n", - "Now we will demonstrate getting an inline from MDIO.\n", - "\n", - "Because MDIO can hold various dimensionality of data, we have to first query the inline location.\n", - "\n", - "Then we can use the queried index to get the data itself.\n", - "\n", - "We will also plot the inline, for this we need the crossline and sample coordinates.\n", - "\n", - "MDIO stores dataset statistics. We can use the standard deviation (std) value of the dataset to adjust the gain." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:56:25.312440Z", - "start_time": "2025-04-16T14:56:24.187832Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "crosslines = mdio.grid.select_dim(\"crossline\").coords\n", - "times = mdio.grid.select_dim(\"sample\").coords\n", - "\n", - "std = mdio.stats[\"std\"]\n", - "\n", - "inline_index = mdio.coord_to_index(278, dimensions=\"inline\").item()\n", - "il_mask, il_headers, il_data = mdio[inline_index]\n", - "\n", - "vmin, vmax = -2 * std, 2 * std\n", - "plt.pcolormesh(crosslines, times, il_data.T, vmin=vmin, vmax=vmax, cmap=\"gray_r\")\n", - "plt.gca().invert_yaxis()\n", - "plt.title(f\"Inline {278}\")\n", - "plt.xlabel(\"crossline\")\n", - "plt.ylabel(\"twt (ms)\");" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Let's do the same with a time sample.\n", - "\n", - "We already have crossline labels and standard deviation, so we don't have to fetch it again.\n", - "\n", - "We will display two-way-time at 1,000 ms." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:56:27.380072Z", - "start_time": "2025-04-16T14:56:27.238298Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "inlines = mdio.grid.select_dim(\"inline\").coords\n", - "\n", - "twt_index = mdio.coord_to_index(1_000, dimensions=\"sample\").item()\n", - "z_mask, z_headers, z_data = mdio[:, :, twt_index]\n", - "\n", - "vmin, vmax = -2 * std, 2 * std\n", - "plt.pcolormesh(inlines, crosslines, z_data.T, vmin=vmin, vmax=vmax, cmap=\"gray_r\")\n", - "plt.title(f\"Two-way-time at {1000}ms\")\n", - "plt.xlabel(\"inline\")\n", - "plt.ylabel(\"crossline\");" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "We can also overlay live mask with the time slice. However, in this example dataset is zero padded.\n", - "\n", - "The live mask will always show True." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:56:29.141772Z", - "start_time": "2025-04-16T14:56:29.019649Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "live_mask = mdio.live_mask[:]\n", - "\n", - "plt.pcolormesh(inlines, crosslines, live_mask.T, vmin=0, vmax=1, alpha=0.5)\n", - "plt.pcolormesh(inlines, crosslines, z_data.T, vmin=vmin, vmax=vmax, cmap=\"gray_r\", alpha=0.5)\n", - "plt.title(f\"Two-way-time at {1000}ms\")\n", - "plt.xlabel(\"inline\")\n", - "plt.ylabel(\"crossline\");" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Query Headers" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "We can query headers for the whole dataset very quickly because they are separated from the seismic wavefield.\n", - "\n", - "Let's get all the headers for X and Y coordinates in this dataset. \n", - "\n", - "As mentioned before, X Coordinates map to `inline` and Y Coordinates map to `crossline` due to non-standard Teapot data.\n", - "\n", - "Note that the header maps will still honor the geometry/grid of the dataset!" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T14:56:31.265395Z", - "start_time": "2025-04-16T14:56:31.218131Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[788937, 789047, 789157, ..., 809282, 809392, 809502],\n", - " [788935, 789045, 789155, ..., 809279, 809389, 809499],\n", - " [788932, 789042, 789152, ..., 809276, 809386, 809496],\n", - " ...,\n", - " [788044, 788154, 788264, ..., 808389, 808499, 808609],\n", - " [788042, 788152, 788262, ..., 808386, 808496, 808606],\n", - " [788039, 788149, 788259, ..., 808383, 808493, 808603]], dtype=int32)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mdio._headers[:][\"inline\"] # actually cdp_x" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2024-09-18T21:00:25.472505Z", - "start_time": "2024-09-18T21:00:25.445539Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[938846, 938848, 938851, ..., 939329, 939331, 939334],\n", - " [938956, 938958, 938961, ..., 939439, 939441, 939444],\n", - " [939066, 939068, 939071, ..., 939549, 939551, 939554],\n", - " ...,\n", - " [976455, 976458, 976460, ..., 976938, 976941, 976943],\n", - " [976565, 976568, 976570, ..., 977048, 977051, 977053],\n", - " [976675, 976678, 976680, ..., 977158, 977161, 977163]], dtype=int32)" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mdio._headers[:][\"crossline\"] # actually cdp_y" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "or both at he same time:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2024-09-18T21:01:00.282409Z", - "start_time": "2024-09-18T21:01:00.255074Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[(788937, 938846), (789047, 938848), (789157, 938851), ...,\n", - " (809282, 939329), (809392, 939331), (809502, 939334)],\n", - " [(788935, 938956), (789045, 938958), (789155, 938961), ...,\n", - " (809279, 939439), (809389, 939441), (809499, 939444)],\n", - " [(788932, 939066), (789042, 939068), (789152, 939071), ...,\n", - " (809276, 939549), (809386, 939551), (809496, 939554)],\n", - " ...,\n", - " [(788044, 976455), (788154, 976458), (788264, 976460), ...,\n", - " (808389, 976938), (808499, 976941), (808609, 976943)],\n", - " [(788042, 976565), (788152, 976568), (788262, 976570), ...,\n", - " (808386, 977048), (808496, 977051), (808606, 977053)],\n", - " [(788039, 976675), (788149, 976678), (788259, 976680), ...,\n", - " (808383, 977158), (808493, 977161), (808603, 977163)]],\n", - " dtype={'names': ['inline', 'crossline'], 'formats': ['" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "crossline_index = mdio.coord_to_index(100, dimensions=\"crossline\").item()\n", - "xl_mask, xl_headers, xl_data = mdio[:, crossline_index]\n", - "\n", - "vmin, vmax = -2 * std, 2 * std\n", - "\n", - "gs_kw = dict(height_ratios=(1, 5))\n", - "fig, ax = plt.subplots(2, 1, gridspec_kw=gs_kw, sharex=\"all\")\n", - "\n", - "ax[0].plot(inlines, xl_headers[\"inline\"])\n", - "\n", - "ax[1].pcolormesh(inlines, times, xl_data.T, vmin=vmin, vmax=vmax, cmap=\"gray_r\")\n", - "ax[1].invert_yaxis()\n", - "ax[1].set_xlabel(\"inline\")\n", - "ax[1].set_ylabel(\"twt (ms)\")\n", - "\n", - "plt.suptitle(f\"Crossline {100} with header.\");" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## MDIO to SEG-Y Conversion\n", - "\n", - "Finally, let's demonstrate going back to SEG-Y. \n", - "\n", - "We will use the convenient `mdio_to_segy` function and write it out as a round-trip file." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Unwrapping MDIO Blocks: 100%|██████████| 13/13 [00:01<00:00, 10.05it/s]\n", - "Merging lines: 100%|██████████| 345/345 [00:00<00:00, 1121.64it/s]\n" - ] - } - ], - "source": [ - "from mdio import mdio_to_segy\n", - "\n", - "mdio_to_segy(\n", - " mdio_path_or_buffer=\"filt_mig.mdio\",\n", - " output_segy_path=\"filt_mig_roundtrip.sgy\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "## Validate Round-Trip SEG-Y File\n", - "\n", - "We can validate if the round-trip SEG-Y file is matching the original using [TGSAI/segy][segy-github].\n", - "\n", - "Step by step:\n", - "* Open original file\n", - "* Open round-trip file\n", - "* Compare text headers\n", - "* Compare binary headers\n", - "* Compare 100 random headers and traces\n", - "\n", - "[segy-github]: https://github.com/TGSAI/segy" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "from segy import SegyFile\n", - "\n", - "original_segy = SegyFile(url)\n", - "roundtrip_segy = SegyFile(\"filt_mig_roundtrip.sgy\")\n", - "\n", - "# Compare text header\n", - "assert original_segy.text_header == roundtrip_segy.text_header\n", - "\n", - "# Compare bin header\n", - "assert original_segy.binary_header == roundtrip_segy.binary_header\n", - "\n", - "# Compare 100 random trace headers and traces\n", - "rng = np.random.default_rng()\n", - "rand_indices = rng.integers(low=0, high=original_segy.num_traces, size=100)\n", - "for idx in rand_indices:\n", - " np.testing.assert_equal(original_segy.trace[idx], roundtrip_segy.trace[idx])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "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.13.1" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "104c0d4e90244ebc959e51a58794dcf4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "display": "inline-flex", - "flex_flow": "row wrap", - "width": "100%" - } - }, - "1c0f5b458ee1401eaa8de63c65802073": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "21b25dd6080d42368afc06770d5e1755": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_35fb49026dac479eba87217c2f6bcb9a", - "style": "IPY_MODEL_3ab3e27c83aa423d9ecdac94e576f0fe", - "value": "Ingesting SEG-Y in 6 chunks: 100%" - } - }, - "2693aae410f04e7587f0400b5eef1079": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "318aea09479a479981dcfa29bc856c67": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "35fb49026dac479eba87217c2f6bcb9a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "3ab3e27c83aa423d9ecdac94e576f0fe": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "420b4a9492c54eb48d7779f38a09fd20": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "flex": "2" - } - }, - "42afe4fae9dd4bc4a341a231cf7a9c32": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "4df685a95de542ffab6f265df89b8949": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "58eaddb54c8840da83d1f6503d6ba64f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "5b3e72b71f304230bc36bb91f9c173be": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "5c1fab0ccc7e42c69c2b663b67ca9e3c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "63a54817ae8b4c8d85b30d8c97e7ed0d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_e170d60a55a14c489d32b101293a9d33", - "IPY_MODEL_662ad93cf7b3470f8e197350441f09ca", - "IPY_MODEL_ac4abab2367e461e956e4e0edb27be44" - ], - "layout": "IPY_MODEL_c59d6fe969a04f4da332ae2a6fdb9c77" - } - }, - "63f87a2410ba47d38ad9f55a81357a29": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_ca48140488574a28a7469552441560e4", - "style": "IPY_MODEL_ae2037efb9cc459e84bcc28ca7243437", - "value": " 2/2 [00:03<00:00, 3.01s/block]" - } - }, - "64eb2b9c8a094a1ea5f1991e5f09f5d9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "662ad93cf7b3470f8e197350441f09ca": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_420b4a9492c54eb48d7779f38a09fd20", - "max": 1, - "style": "IPY_MODEL_d16e93f72f3d4aeda2f5deee87e9754f", - "value": 1 - } - }, - "74283969ff5446c89bb83b00a70226cf": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_5c1fab0ccc7e42c69c2b663b67ca9e3c", - "style": "IPY_MODEL_1c0f5b458ee1401eaa8de63c65802073", - "value": " 6/6 [00:09<00:00, 2.48s/block]" - } - }, - "75cf0c1ed25e47aab20b060f3bb44fb8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_21b25dd6080d42368afc06770d5e1755", - "IPY_MODEL_c33f32b62a204ef094f67b10f8adbdc1", - "IPY_MODEL_74283969ff5446c89bb83b00a70226cf" - ], - "layout": "IPY_MODEL_91df4ac76fd744539d4237d6099f34a5" - } - }, - "7ff32d7deac14f21ab0f0939fe09e440": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "91df4ac76fd744539d4237d6099f34a5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "display": "inline-flex", - "flex_flow": "row wrap", - "width": "100%" - } - }, - "981634b52a7a4ffdae6186061c0b6482": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_f65266f861cf40ef84e9ec74a8e0b44c", - "IPY_MODEL_9aaf514a5035413d8cbbad58aa0221f4", - "IPY_MODEL_63f87a2410ba47d38ad9f55a81357a29" - ], - "layout": "IPY_MODEL_104c0d4e90244ebc959e51a58794dcf4" - } - }, - "9aaf514a5035413d8cbbad58aa0221f4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_b25523a221fd4b5e9211d07ef39cccf5", - "max": 2, - "style": "IPY_MODEL_318aea09479a479981dcfa29bc856c67", - "value": 2 - } - }, - "9fe5348964cd4f7880bcd33204bbc7a2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "a03d238db31145b881a1be478f9eb72f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "a6aabcd2e57348a49bb59477f6a9fd90": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_cfb02c9c7447491ca00bbb6acd99bb79", - "max": 26, - "style": "IPY_MODEL_7ff32d7deac14f21ab0f0939fe09e440", - "value": 26 - } - }, - "ac4abab2367e461e956e4e0edb27be44": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_58eaddb54c8840da83d1f6503d6ba64f", - "style": "IPY_MODEL_a03d238db31145b881a1be478f9eb72f", - "value": " 3/? [00:00<00:00, 8.29block/s]" - } - }, - "ae2037efb9cc459e84bcc28ca7243437": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b25523a221fd4b5e9211d07ef39cccf5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "flex": "2" - } - }, - "b9810ee38bbe43f4bba100e53379be65": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_42afe4fae9dd4bc4a341a231cf7a9c32", - "style": "IPY_MODEL_fdcea609ee7349629604217b625371d3", - "value": " 26/26 [00:01<00:00, 18.92block/s]" - } - }, - "c33f32b62a204ef094f67b10f8adbdc1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "bar_style": "success", - "layout": "IPY_MODEL_d23d88490a1b4941b8ca228b7d4a39cb", - "max": 6, - "style": "IPY_MODEL_2693aae410f04e7587f0400b5eef1079", - "value": 6 - } - }, - "c59d6fe969a04f4da332ae2a6fdb9c77": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "display": "inline-flex", - "flex_flow": "row wrap", - "width": "100%" - } - }, - "ca48140488574a28a7469552441560e4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - }, - "cfb02c9c7447491ca00bbb6acd99bb79": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "flex": "2" - } - }, - "d16e93f72f3d4aeda2f5deee87e9754f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "description_width": "" - } - }, - "d23d88490a1b4941b8ca228b7d4a39cb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "flex": "2" - } - }, - "d565a20d37e84ed0a1195e9a90154960": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_db696e15587c4a54b82886b3eb5a0c96", - "IPY_MODEL_a6aabcd2e57348a49bb59477f6a9fd90", - "IPY_MODEL_b9810ee38bbe43f4bba100e53379be65" - ], - "layout": "IPY_MODEL_eab4b060672b4dd5a73ca7bb8f782cd2" - } - }, - "db696e15587c4a54b82886b3eb5a0c96": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_64eb2b9c8a094a1ea5f1991e5f09f5d9", - "style": "IPY_MODEL_5b3e72b71f304230bc36bb91f9c173be", - "value": "Step 1 / 2 Writing Blocks: 100%" - } - }, - "e170d60a55a14c489d32b101293a9d33": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_9fe5348964cd4f7880bcd33204bbc7a2", - "style": "IPY_MODEL_4df685a95de542ffab6f265df89b8949", - "value": "Step 2 / 2 Concat Blocks: " - } - }, - "e66368cda8124001b16459a0634029e2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "eab4b060672b4dd5a73ca7bb8f782cd2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "display": "inline-flex", - "flex_flow": "row wrap", - "width": "100%" - } - }, - "f65266f861cf40ef84e9ec74a8e0b44c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_fff4199774534d9f982f03738fbb08e7", - "style": "IPY_MODEL_e66368cda8124001b16459a0634029e2", - "value": "Scanning SEG-Y for geometry attributes: 100%" - } - }, - "fdcea609ee7349629604217b625371d3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "fff4199774534d9f982f03738fbb08e7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": {} - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/docs/notebooks/rechunking.ipynb b/docs/notebooks/rechunking.ipynb deleted file mode 100644 index 9b8868e2..00000000 --- a/docs/notebooks/rechunking.ipynb +++ /dev/null @@ -1,564 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "ca09761db8545719", - "metadata": {}, - "source": [ - "# Optimizing Access Patterns\n", - "\n", - "## Introduction\n", - "\n", - "In this page we will be showing how we can take an existing MDIO and add\n", - "fast access, lossy, versions of the data in X/Y/Z cross-sections (slices).\n", - "\n", - "We can re-use the MDIO dataset we created in the [Quickstart](#quickstart) page.\n", - "Please run it first.\n", - "\n", - "We will define our compression levels first. We will use this to adjust the quality\n", - "of the lossy compression." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "initial_id", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:38:02.462276Z", - "start_time": "2025-04-16T18:38:02.459882Z" - } - }, - "outputs": [], - "source": [ - "from enum import Enum\n", - "\n", - "class MdioZfpQuality(float, Enum):\n", - " \"\"\"Config options for ZFP compression.\"\"\"\n", - "\n", - " VERY_LOW = 6\n", - " LOW = 3\n", - " MEDIUM = 1\n", - " HIGH = 0.1\n", - " VERY_HIGH = 0.01\n", - " ULTRA = 0.001" - ] - }, - { - "cell_type": "markdown", - "id": "c2a09a89-b453-4c3e-b879-14caaedd29de", - "metadata": {}, - "source": [ - "We will use the lower level `MDIOAccessor` to open the existing file in write mode that\n", - "allows us to modify its raw metadata. This can be dangerous, we recommend using only provided\n", - "tools to avoid data corruption.\n", - "\n", - "We specify the original access pattern of the source data `\"012\"` with some parameters like\n", - "caching. For the rechunking, we recommend using the single threaded `\"zarr\"` backend to avoid\n", - "race conditions.\n", - "\n", - "We also define a `dict` for common arguments in rechunking." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "45558306-ab9c-46aa-a299-8758a911b373", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:38:04.107696Z", - "start_time": "2025-04-16T18:38:04.101239Z" - } - }, - "outputs": [], - "source": [ - "from mdio.api.accessor import MDIOWriter\n", - "\n", - "mdio_path = \"filt_mig.mdio\"\n", - "\n", - "writer = MDIOWriter(\n", - " mdio_path_or_buffer=mdio_path,\n", - " access_pattern=\"012\",\n", - " backend=\"zarr\",\n", - " disk_cache=False,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "0a9af731-39b2-4373-af96-76811e7fead4", - "metadata": {}, - "source": [ - "## Compression (Lossy)\n", - "\n", - "Now, let's define our compression level. The compression ratios vary a lot\n", - "on the data characteristics. However, the compression levels here are good\n", - "guidelines that are based on standard deviation of the original data.\n", - "\n", - "We use ZFP's fixed accuracy mode with a tolerance based on data standard\n", - "deviation, as mentioned above. For more ZFP options you can see its documentation.\n", - "\n", - "Empirically, for this dataset, we see the following size reductions (per copy):\n", - "\n", - "* `10 : 1` on `VERY_LOW`\n", - "* `7.5 : 1` on `LOW`\n", - "* `4.5 : 1` on `MEDIUM`\n", - "* `3 : 1` on `HIGH`\n", - "* `2 : 1` on `VERY_HIGH`\n", - "* `1.5 : 1` on `ULTRA`" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "97681d5f-3c10-430c-8ff1-c9c1cff63d2c", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:38:06.097297Z", - "start_time": "2025-04-16T18:38:06.094137Z" - } - }, - "outputs": [], - "source": [ - "from numcodecs import ZFPY\n", - "from zfpy import mode_fixed_accuracy\n", - "\n", - "std = writer.stats[\"std\"] # standard deviation of original data\n", - "\n", - "quality = MdioZfpQuality.LOW\n", - "tolerance = quality * std\n", - "sample_compressor = ZFPY(mode_fixed_accuracy, tolerance=tolerance)\n", - "\n", - "common_kwargs = {\"overwrite\": True, \"compressor\": sample_compressor}" - ] - }, - { - "cell_type": "markdown", - "id": "fafe9e65-5d46-4b32-893d-6020dce7a007", - "metadata": {}, - "source": [ - "## Optimizing IL/XL/Z Independently\n", - "\n", - "In this cell, we will demonstrate how to create IL/XL and Z (two-way-time) optimized\n", - "versions **independently**. In the next section we will do the same with the batch\n", - "mode where the data only needs to be read into memory once.\n", - "\n", - "In the example below, each rechunking operation will read the data from the original\n", - "MDIO dataset and discard it. We did enable 256 MB (2^28 bytes) memory cache above,\n", - "it will help some, but still not ideal." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ae5a722e-c6af-48d7-9893-031991bf9619", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:38:15.196142Z", - "start_time": "2025-04-16T18:38:10.444861Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Rechunking to fast_il: 100%|██████████| 3/3 [00:00<00:00, 3.35chunk/s]\n", - "Rechunking to fast_xl: 100%|██████████| 3/3 [00:00<00:00, 3.27chunk/s]\n", - "Rechunking to fast_z: 100%|██████████| 3/3 [00:01<00:00, 1.92chunk/s]\n" - ] - } - ], - "source": [ - "from mdio.api.convenience import rechunk\n", - "\n", - "rechunk(writer, (4, 512, 512), suffix=\"fast_il\", **common_kwargs)\n", - "rechunk(writer, (512, 4, 512), suffix=\"fast_xl\", **common_kwargs)\n", - "rechunk(writer, (512, 512, 4), suffix=\"fast_z\", **common_kwargs)" - ] - }, - { - "cell_type": "markdown", - "id": "2d3fd987-2d9b-48f7-8688-745f9e3d9f0d", - "metadata": {}, - "source": [ - "We can now open the original MDIO dataset and the fast access patterns.\n", - "When printing the `chunks` attribute, we see the original one first, and\n", - "the subsequent ones show data is rechunked with ZFP compression." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "9c46691a-f7fa-42ea-ad36-595681b2dff0", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:38:17.474789Z", - "start_time": "2025-04-16T18:38:17.457405Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(64, 64, 64) (Blosc(cname='zstd', clevel=5, shuffle=SHUFFLE, blocksize=0),)\n", - "(4, 188, 512) (ZFPY(mode=4, tolerance=2.791618335971825, rate=-1, precision=-1),)\n", - "(345, 4, 512) (ZFPY(mode=4, tolerance=2.791618335971825, rate=-1, precision=-1),)\n", - "(345, 188, 4) (ZFPY(mode=4, tolerance=2.791618335971825, rate=-1, precision=-1),)\n" - ] - } - ], - "source": [ - "from mdio import MDIOReader\n", - "\n", - "orig_mdio = MDIOReader(mdio_path)\n", - "il_mdio = MDIOReader(mdio_path, access_pattern=\"fast_il\")\n", - "xl_mdio = MDIOReader(mdio_path, access_pattern=\"fast_xl\")\n", - "z_mdio = MDIOReader(mdio_path, access_pattern=\"fast_z\")\n", - "\n", - "print(orig_mdio.chunks, orig_mdio._traces.compressors)\n", - "print(il_mdio.chunks, il_mdio._traces.compressors)\n", - "print(xl_mdio.chunks, xl_mdio._traces.compressors)\n", - "print(z_mdio.chunks, z_mdio._traces.compressors)" - ] - }, - { - "cell_type": "markdown", - "id": "64a32960-73e7-408e-9592-bc851c0d7c66", - "metadata": {}, - "source": [ - "We can now compare the sizes of the compressed representations to original.\n", - "\n", - "Below commands are for UNIX based operating systems and won't work on Windows." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "6d66a26c-79c8-4e24-9181-60707cae6d59", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:38:21.243179Z", - "start_time": "2025-04-16T18:38:20.442045Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "149M\tfilt_mig.mdio/data/chunked_012\n", - " 21M\tfilt_mig.mdio/data/chunked_fast_il\n", - " 20M\tfilt_mig.mdio/data/chunked_fast_xl\n", - " 21M\tfilt_mig.mdio/data/chunked_fast_z\n" - ] - } - ], - "source": [ - "!du -hs {mdio_path}/data/chunked_012\n", - "!du -hs {mdio_path}/data/chunked_fast_il\n", - "!du -hs {mdio_path}/data/chunked_fast_xl\n", - "!du -hs {mdio_path}/data/chunked_fast_z" - ] - }, - { - "cell_type": "markdown", - "id": "147251da-55c0-497d-b954-1217c9b59698", - "metadata": {}, - "source": [ - "Comparing local disk read speeds for inlines:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "bdd81177-3e90-4089-8ccc-cf7966b33041", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:38:27.478502Z", - "start_time": "2025-04-16T18:38:22.367637Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "23.5 ms ± 599 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - "2.47 ms ± 77.8 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" - ] - } - ], - "source": [ - "%timeit orig_mdio[175] # 3d chunked\n", - "%timeit il_mdio[175] # inline optimized" - ] - }, - { - "cell_type": "markdown", - "id": "9cbd29f8-aa00-4f72-906f-96663d0163e9", - "metadata": {}, - "source": [ - "For crosslines:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "725e2562-9005-413a-b4c0-5c0f281183c9", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:38:37.386185Z", - "start_time": "2025-04-16T18:38:27.487846Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "51.2 ms ± 1.82 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - "4.96 ms ± 103 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" - ] - } - ], - "source": [ - "%timeit orig_mdio[:, 90] # 3d chunked\n", - "%timeit xl_mdio[:, 90] # xline optimized" - ] - }, - { - "cell_type": "markdown", - "id": "bd274979-4b54-44a2-bd21-c35e933aaf43", - "metadata": {}, - "source": [ - "Finally, for Z (time-slices):" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "47983dac-2463-4b52-b3fd-d496a4ade114", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:38:55.017370Z", - "start_time": "2025-04-16T18:38:37.395229Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "8.21 ms ± 1.38 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "1.35 ms ± 45.1 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" - ] - } - ], - "source": [ - "%timeit orig_mdio[..., 751] # 3d chunked\n", - "%timeit z_mdio[..., 751] # time-slice optimized" - ] - }, - { - "cell_type": "markdown", - "id": "d26454dd-bf6a-46e8-863d-a0230269e339", - "metadata": {}, - "source": [ - "We can check the subjective quality of the compression by visually comparing\n", - "two inlines. Similar to the example we had in the [Compression](#compression) page." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "280d0759-2548-4e73-9caa-6734d294e36f", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:39:12.201293Z", - "start_time": "2025-04-16T18:39:11.872250Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", - "\n", - "vmin = -3 * std\n", - "vmax = 3 * std\n", - "\n", - "imshow_kw = dict(vmin=vmin, vmax=vmax, cmap=\"gray_r\", interpolation=\"bilinear\", aspect=\"auto\")\n", - "\n", - "\n", - "def attach_colorbar(image, axis):\n", - " divider = make_axes_locatable(axis)\n", - " cax = divider.append_axes(\"top\", size=\"2%\", pad=0.05)\n", - " plt.colorbar(image, cax=cax, orientation=\"horizontal\")\n", - " cax.xaxis.set_ticks_position(\"top\")\n", - " cax.tick_params(labelsize=8)\n", - "\n", - "\n", - "def plot_image_and_cbar(data, axis, title):\n", - " image = axis.imshow(data.T, **imshow_kw)\n", - " attach_colorbar(image, axis)\n", - " axis.set_title(title, y=-0.15)\n", - "\n", - "\n", - "def plot_inlines_with_diff(orig, compressed, title):\n", - " fig, ax = plt.subplots(1, 4, sharey=\"all\", sharex=\"all\", figsize=(8, 5))\n", - "\n", - " diff = orig[200] - compressed[200]\n", - "\n", - " plot_image_and_cbar(orig[200], ax[0], \"original\")\n", - " plot_image_and_cbar(compressed[200], ax[1], \"lossy\")\n", - " plot_image_and_cbar(diff, ax[2], \"difference\")\n", - " plot_image_and_cbar(diff * 1_000, ax[3], \"1,000x difference\")\n", - "\n", - " plt.suptitle(f\"{title} ({std=})\")\n", - " fig.tight_layout()\n", - "\n", - " plt.show()\n", - "\n", - "\n", - "plot_inlines_with_diff(orig_mdio, il_mdio, \"\")" - ] - }, - { - "cell_type": "markdown", - "id": "2900c40b-c332-4334-a4cc-f0e5571c7387", - "metadata": {}, - "source": [ - "In conclusion, we show that by generating optimized, lossy compressed copies of the data\n", - "for certain access patterns yield big performance benefits when reading the data.\n", - "\n", - "The differences are orders of magnitude larger on big datasets and remote stores, given available\n", - "network bandwidth." - ] - }, - { - "cell_type": "markdown", - "id": "38f7d35e-d743-4bb3-a7a6-fa77aab08f00", - "metadata": {}, - "source": [ - "## Optimizing in Batch\n", - "\n", - "Now that we understand how rechunking and lossy compression works, we will demonstrate how\n", - "to do this in batches. \n", - "\n", - "The benefit of doing the batched processing is that the dataset gets read once. This is\n", - "especially important if the original MDIO resides in a remote store like AWS S3, or Google\n", - "Cloud's GCS.\n", - "\n", - "Note that we not are overwriting the old optimized chunks, just creating new ones with the\n", - "suffix 2 to demonstrate we can create as many version of the original data as we want." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "14c58331-0ce3-42fa-9cd0-a43574ce24bf", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:39:19.725778Z", - "start_time": "2025-04-16T18:39:15.546003Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Rechunking to fast_il2,fast_xl2,fast_z2: 100%|██████████| 3/3 [00:03<00:00, 1.29s/chunk]\n" - ] - } - ], - "source": [ - "from mdio.api.convenience import rechunk_batch\n", - "\n", - "rechunk_batch(\n", - " writer,\n", - " chunks_list=[(4, 512, 512), (512, 4, 512), (512, 512, 4)],\n", - " suffix_list=[\"fast_il2\", \"fast_xl2\", \"fast_z2\"],\n", - " **common_kwargs,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "a3f47a17-7537-4fc9-b3ab-b57badae18d1", - "metadata": { - "ExecuteTime": { - "end_time": "2025-04-16T18:39:33.576164Z", - "start_time": "2025-04-16T18:39:33.559671Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(64, 64, 64) (Blosc(cname='zstd', clevel=5, shuffle=SHUFFLE, blocksize=0),)\n", - "(4, 188, 512) (ZFPY(mode=4, tolerance=2.791618335971825, rate=-1, precision=-1),)\n", - "(345, 4, 512) (ZFPY(mode=4, tolerance=2.791618335971825, rate=-1, precision=-1),)\n", - "(345, 188, 4) (ZFPY(mode=4, tolerance=2.791618335971825, rate=-1, precision=-1),)\n" - ] - } - ], - "source": [ - "from mdio import MDIOReader\n", - "\n", - "orig_mdio = MDIOReader(mdio_path)\n", - "il2_mdio = MDIOReader(mdio_path, access_pattern=\"fast_il2\")\n", - "xl2_mdio = MDIOReader(mdio_path, access_pattern=\"fast_xl2\")\n", - "z2_mdio = MDIOReader(mdio_path, access_pattern=\"fast_z2\")\n", - "\n", - "print(orig_mdio.chunks, orig_mdio._traces.compressors)\n", - "print(il_mdio.chunks, il2_mdio._traces.compressors)\n", - "print(xl_mdio.chunks, xl2_mdio._traces.compressors)\n", - "print(z_mdio.chunks, z2_mdio._traces.compressors)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "008950d1-b142-4ca8-9879-f926007c97ca", - "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.13.1" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/requirements.txt b/docs/requirements.txt index dfb45d51..d6ad60e1 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,6 +1,8 @@ furo==2024.8.6 sphinx==8.2.1 +sphinx-design==0.6.1 sphinx-click==6.0.0 sphinx-copybutton==0.5.2 myst-nb==1.2.0 linkify-it-py==2.0.3 +autodoc-pydantic==2.2.0 diff --git a/docs/notebooks/compression.ipynb b/docs/tutorials/compression.ipynb similarity index 99% rename from docs/notebooks/compression.ipynb rename to docs/tutorials/compression.ipynb index 330d90a9..95f9515b 100644 --- a/docs/notebooks/compression.ipynb +++ b/docs/tutorials/compression.ipynb @@ -6,6 +6,13 @@ "source": [ "# Seismic Data Compression\n", "\n", + "```{article-info}\n", + ":author: Altay Sansal\n", + ":date: \"{sub-ref}`today`\"\n", + ":read-time: \"{sub-ref}`wordcount-minutes` min read\"\n", + ":class-container: sd-p-0 sd-outline-muted sd-rounded-3 sd-font-weight-light\n", + "```\n", + "\n", "In this page we will be showing compression performance of _MDIO_.\n", "\n", "For demonstration purposes, we will use one of the Volve dataset stacks.\n", diff --git a/docs/tutorials/index.md b/docs/tutorials/index.md new file mode 100644 index 00000000..9b631105 --- /dev/null +++ b/docs/tutorials/index.md @@ -0,0 +1,8 @@ +# Tutorials + +```{toctree} +:hidden: +quickstart +compression +rechunking +``` diff --git a/docs/tutorials/quickstart.ipynb b/docs/tutorials/quickstart.ipynb new file mode 100644 index 00000000..e36e89b5 --- /dev/null +++ b/docs/tutorials/quickstart.ipynb @@ -0,0 +1,1406 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Get Started in 8 Minutes\n", + "\n", + "```{article-info}\n", + ":author: Altay Sansal\n", + ":date: \"{sub-ref}`today`\"\n", + ":read-time: \"{sub-ref}`wordcount-minutes` min read\"\n", + ":class-container: sd-p-0 sd-outline-muted sd-rounded-3 sd-font-weight-light\n", + "```\n", + "\n", + "In this page we will be showing basic capabilities of MDIO.\n", + "\n", + "For demonstration purposes, we will download the Teapot Dome open-source dataset. The dataset details and licensing can be found at the [SEG Wiki](https://wiki.seg.org/wiki/Teapot_dome_3D_survey).\n", + "\n", + "We are using the 3D seismic stack dataset named `filt_mig.sgy`.\n", + "\n", + "The full link for the dataset (hosted on AWS): http://s3.amazonaws.com/teapot/filt_mig.sgy\n", + "\n", + "```{warning}\n", + "For plotting, the notebook requires [Matplotlib](https://matplotlib.org/) as a dependency. Please install it before executing using\n", + "`pip install matplotlib` or `conda install matplotlib`.\n", + "```\n", + "\n", + "## Downloading the SEG-Y Dataset\n", + "\n", + "Let's download this dataset to our working directory. It may take from a few seconds up to a couple minutes based on your internet connection speed. The file is 386 MB in size.\n", + "\n", + "The dataset is irregularly shaped, however it is padded to a rectangle with zero (dead traces). We will see that later at the live mask plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:58:51.175760Z", + "start_time": "2024-09-18T20:58:40.579758Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('filt_mig.sgy', )" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from os import path\n", + "from urllib.request import urlretrieve\n", + "\n", + "url = \"http://s3.amazonaws.com/teapot/filt_mig.sgy\"\n", + "urlretrieve(url, \"filt_mig.sgy\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Ingesting to MDIO\n", + "\n", + "To do this, we can use the convenient SEG-Y to MDIO converter.\n", + "\n", + "The `inline` and `crossline` values are located at bytes `181` and `185`. Note that this doesn't match any SEG-Y standards.\n", + "\n", + "MDIO uses [TGSAI/segy][segy-github] to parse the SEG-Y; the field names conform to its canonical keys defined in [SEGY Binary Header Keys][segy-binary-keys] and [SEGY Trace Header Keys][segy-trace-keys]. MDIO interprets the trace headers as SEG-Y Rev1 for historical reasons and will be more flexible in the next generation.\n", + "\n", + "`181` and `185` for Teapot should ideally map to `cdp_x` and `cdp_y` in the header arrays. However, because the file does not match the standard, they are mapped to the `inline` and `crossline` header keys on ingested headers.\n", + "\n", + "In summary, we will use the byte locations as defined for ingestion. However, because `inline` / `crossline` and flipped with `cdp_x` / `cdp_y`, we must interchange the keys later.\n", + "\n", + "[segy-github]: https://github.com/TGSAI/segy\n", + "[segy-binary-keys]: https://github.com/TGSAI/segy/blob/main/src/segy/standards/fields/binary.py\n", + "[segy-trace-keys]: https://github.com/TGSAI/segy/blob/main/src/segy/standards/fields/trace.py" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:59:00.561840Z", + "start_time": "2024-09-18T20:58:51.516552Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Scanning SEG-Y for geometry attributes: 100%|██████████| 7/7 [00:03<00:00, 1.89block/s]\n", + "Ingesting SEG-Y in 18 chunks: 100%|██████████| 18/18 [00:04<00:00, 4.12block/s]\n" + ] + } + ], + "source": [ + "from mdio import segy_to_mdio\n", + "\n", + "segy_to_mdio(\n", + " segy_path=\"filt_mig.sgy\",\n", + " mdio_path_or_buffer=\"filt_mig.mdio\",\n", + " index_bytes=(181, 185),\n", + " index_names=(\"inline\", \"crossline\"),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "It only took a few seconds to ingest, since this is a very small file. \n", + "\n", + "However, MDIO scales up to TB (that's ~1,000 GB) sized volumes!\n", + "\n", + "## Opening the Ingested MDIO File\n", + "\n", + "Let's open the MDIO file with the `MDIOReader`.\n", + "\n", + "We will also turn on `return_metadata` function to get the live trace mask and trace headers." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:59:00.569221Z", + "start_time": "2024-09-18T20:59:00.565754Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from mdio import MDIOReader\n", + "\n", + "mdio = MDIOReader(\"filt_mig.mdio\", return_metadata=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Querying Metadata\n", + "\n", + "Now let's look at the Textual Header by the convenient `text_header` attribute.\n", + "\n", + "You will notice the text header is parsed as a list of strings that are 80 characters long." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:59:00.579512Z", + "start_time": "2024-09-18T20:59:00.576806Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['C 1 CLIENT: ROCKY MOUNTAIN OILFIELD TESTING CENTER ',\n", + " 'C 2 PROJECT: NAVAL PETROLEUM RESERVE #3 (TEAPOT DOME); NATRONA COUNTY, WYOMING ',\n", + " 'C 3 LINE: 3D ',\n", + " 'C 4 ',\n", + " 'C 5 THIS IS THE FILTERED POST STACK MIGRATION ',\n", + " 'C 6 ',\n", + " 'C 7 INLINE 1, XLINE 1: X COORDINATE: 788937 Y COORDINATE: 938845 ',\n", + " 'C 8 INLINE 1, XLINE 188: X COORDINATE: 809501 Y COORDINATE: 939333 ',\n", + " 'C 9 INLINE 188, XLINE 1: X COORDINATE: 788039 Y COORDINATE: 976674 ',\n", + " 'C10 INLINE NUMBER: MIN: 1 MAX: 345 TOTAL: 345 ',\n", + " 'C11 CROSSLINE NUMBER: MIN: 1 MAX: 188 TOTAL: 188 ',\n", + " \"C12 TOTAL NUMBER OF CDPS: 64860 BIN DIMENSION: 110' X 110' \",\n", + " 'C13 ',\n", + " 'C14 ',\n", + " 'C15 ',\n", + " 'C16 ',\n", + " 'C17 ',\n", + " 'C18 ',\n", + " 'C19 GENERAL SEGY INFORMATION ',\n", + " 'C20 RECORD LENGHT (MS): 3000 ',\n", + " 'C21 SAMPLE RATE (MS): 2.0 ',\n", + " 'C22 DATA FORMAT: 4 BYTE IBM FLOATING POINT ',\n", + " 'C23 BYTES 13- 16: CROSSLINE NUMBER (TRACE) ',\n", + " 'C24 BYTES 17- 20: INLINE NUMBER (LINE) ',\n", + " 'C25 BYTES 81- 84: CDP_X COORD ',\n", + " 'C26 BYTES 85- 88: CDP_Y COORD ',\n", + " 'C27 BYTES 181-184: INLINE NUMBER (LINE) ',\n", + " 'C28 BYTES 185-188: CROSSLINE NUMBER (TRACE) ',\n", + " 'C29 BYTES 189-192: CDP_X COORD ',\n", + " 'C30 BYTES 193-196: CDP_Y COORD ',\n", + " 'C31 ',\n", + " 'C32 ',\n", + " 'C33 ',\n", + " 'C34 ',\n", + " 'C35 ',\n", + " 'C36 Processed by: Excel Geophysical Services, Inc. ',\n", + " 'C37 8301 East Prentice Ave. Ste. 402 ',\n", + " 'C38 Englewood, Colorado 80111 ',\n", + " 'C39 (voice) 303.694.9629 (fax) 303.771.1646 ',\n", + " 'C40 END EBCDIC ']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mdio.text_header" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "MDIO parses the binary header into a Python dictionary.\n", + "\n", + "We can easily query it by the `binary_header` attribute and see critical information about the original file." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:59:01.236557Z", + "start_time": "2024-09-18T20:59:01.233832Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'amp_recovery_code': 4,\n", + " 'aux_traces_per_ensemble': 0,\n", + " 'binary_gain_code': 1,\n", + " 'correlated_data_code': 2,\n", + " 'data_sample_format': 1,\n", + " 'data_traces_per_ensemble': 188,\n", + " 'ensemble_fold': 57,\n", + " 'extended_aux_traces_per_ensemble': 0,\n", + " 'extended_data_traces_per_ensemble': 0,\n", + " 'extended_ensemble_fold': 0,\n", + " 'extended_orig_samples_per_trace': 0,\n", + " 'extended_samples_per_trace': 0,\n", + " 'fixed_length_trace_flag': 0,\n", + " 'impulse_polarity_code': 1,\n", + " 'job_id': 9999,\n", + " 'line_num': 9999,\n", + " 'measurement_system_code': 2,\n", + " 'num_extended_text_headers': 0,\n", + " 'orig_sample_interval': 0,\n", + " 'orig_samples_per_trace': 1501,\n", + " 'reel_num': 1,\n", + " 'sample_interval': 2000,\n", + " 'samples_per_trace': 1501,\n", + " 'segy_revision': 0,\n", + " 'segy_revision_minor': 0,\n", + " 'sweep_freq_end': 0,\n", + " 'sweep_freq_start': 0,\n", + " 'sweep_length': 0,\n", + " 'sweep_taper_end': 0,\n", + " 'sweep_taper_start': 0,\n", + " 'sweep_trace_num': 0,\n", + " 'sweep_type_code': 0,\n", + " 'taper_type_code': 0,\n", + " 'trace_sorting_code': 4,\n", + " 'vertical_sum_code': 1,\n", + " 'vibratory_polarity_code': 0}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mdio.binary_header" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## MDIO Grid, Dimensions, and Related Attributes\n", + "\n", + "MDIO also has named dimensions, so we can see which dimension (axis) corresponds to which coordinate.\n", + "\n", + "MDIO has an abstraction for an N-Dimensional grid. We can get the grid, and look at some of its properties." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:59:17.153067Z", + "start_time": "2024-09-18T20:59:17.150654Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('inline', 'crossline', 'sample')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mdio.grid.dim_names" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:59:18.063449Z", + "start_time": "2024-09-18T20:59:18.060528Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mdio.grid.get_min(\"inline\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:59:18.613847Z", + "start_time": "2024-09-18T20:59:18.611287Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "188" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mdio.grid.get_max(\"crossline\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "We can extract a dimension by name, and see its values. \n", + "\n", + "The `Dimension` has `name` and `coords` that returns a string and a numpy array." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:59:20.375872Z", + "start_time": "2024-09-18T20:59:20.372849Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Dimension(coords=array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,\n", + " 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n", + " 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,\n", + " 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,\n", + " 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,\n", + " 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,\n", + " 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,\n", + " 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,\n", + " 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,\n", + " 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n", + " 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,\n", + " 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156,\n", + " 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,\n", + " 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,\n", + " 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,\n", + " 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,\n", + " 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221,\n", + " 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,\n", + " 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,\n", + " 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,\n", + " 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273,\n", + " 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286,\n", + " 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299,\n", + " 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312,\n", + " 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325,\n", + " 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338,\n", + " 339, 340, 341, 342, 343, 344, 345]), name='inline')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mdio.grid.select_dim(\"inline\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Fetching Data and Plotting\n", + "\n", + "Now we will demonstrate getting an inline from MDIO.\n", + "\n", + "Because MDIO can hold various dimensionality of data, we have to first query the inline location.\n", + "\n", + "Then we can use the queried index to get the data itself.\n", + "\n", + "We will also plot the inline, for this we need the crossline and sample coordinates.\n", + "\n", + "MDIO stores dataset statistics. We can use the standard deviation (std) value of the dataset to adjust the gain." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T20:59:21.651362Z", + "start_time": "2024-09-18T20:59:21.503964Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "crosslines = mdio.grid.select_dim(\"crossline\").coords\n", + "times = mdio.grid.select_dim(\"sample\").coords\n", + "\n", + "std = mdio.stats[\"std\"]\n", + "\n", + "inline_index = mdio.coord_to_index(278, dimensions=\"inline\").item()\n", + "il_mask, il_headers, il_data = mdio[inline_index]\n", + "\n", + "vmin, vmax = -2 * std, 2 * std\n", + "plt.pcolormesh(crosslines, times, il_data.T, vmin=vmin, vmax=vmax, cmap=\"gray_r\")\n", + "plt.gca().invert_yaxis()\n", + "plt.title(f\"Inline {278}\")\n", + "plt.xlabel(\"crossline\")\n", + "plt.ylabel(\"twt (ms)\");" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Let's do the same with a time sample.\n", + "\n", + "We already have crossline labels and standard deviation, so we don't have to fetch it again.\n", + "\n", + "We will display two-way-time at 1,000 ms." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inlines = mdio.grid.select_dim(\"inline\").coords\n", + "\n", + "twt_index = mdio.coord_to_index(1_000, dimensions=\"sample\").item()\n", + "z_mask, z_headers, z_data = mdio[:, :, twt_index]\n", + "\n", + "vmin, vmax = -2 * std, 2 * std\n", + "plt.pcolormesh(inlines, crosslines, z_data.T, vmin=vmin, vmax=vmax, cmap=\"gray_r\")\n", + "plt.title(f\"Two-way-time at {1000}ms\")\n", + "plt.xlabel(\"inline\")\n", + "plt.ylabel(\"crossline\");" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "We can also overlay live mask with the time slice. However, in this example dataset is zero padded.\n", + "\n", + "The live mask will always show True." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "live_mask = mdio.live_mask[:]\n", + "\n", + "plt.pcolormesh(inlines, crosslines, live_mask.T, vmin=0, vmax=1, alpha=0.5)\n", + "plt.pcolormesh(inlines, crosslines, z_data.T, vmin=vmin, vmax=vmax, cmap=\"gray_r\", alpha=0.5)\n", + "plt.title(f\"Two-way-time at {1000}ms\")\n", + "plt.xlabel(\"inline\")\n", + "plt.ylabel(\"crossline\");" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Query Headers" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "We can query headers for the whole dataset very quickly because they are separated from the seismic wavefield.\n", + "\n", + "Let's get all the headers for X and Y coordinates in this dataset. \n", + "\n", + "As mentioned before, X Coordinates map to `inline` and Y Coordinates map to `crossline` due to non-standard Teapot data.\n", + "\n", + "Note that the header maps will still honor the geometry/grid of the dataset!" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T21:00:13.917249Z", + "start_time": "2024-09-18T21:00:13.889737Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[788937, 789047, 789157, ..., 809282, 809392, 809502],\n", + " [788935, 789045, 789155, ..., 809279, 809389, 809499],\n", + " [788932, 789042, 789152, ..., 809276, 809386, 809496],\n", + " ...,\n", + " [788044, 788154, 788264, ..., 808389, 808499, 808609],\n", + " [788042, 788152, 788262, ..., 808386, 808496, 808606],\n", + " [788039, 788149, 788259, ..., 808383, 808493, 808603]], dtype=int32)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mdio._headers[:][\"inline\"] # actually cdp_x" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T21:00:25.472505Z", + "start_time": "2024-09-18T21:00:25.445539Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[938846, 938848, 938851, ..., 939329, 939331, 939334],\n", + " [938956, 938958, 938961, ..., 939439, 939441, 939444],\n", + " [939066, 939068, 939071, ..., 939549, 939551, 939554],\n", + " ...,\n", + " [976455, 976458, 976460, ..., 976938, 976941, 976943],\n", + " [976565, 976568, 976570, ..., 977048, 977051, 977053],\n", + " [976675, 976678, 976680, ..., 977158, 977161, 977163]], dtype=int32)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mdio._headers[:][\"crossline\"] # actually cdp_y" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "or both at he same time:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-18T21:01:00.282409Z", + "start_time": "2024-09-18T21:01:00.255074Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[(788937, 938846), (789047, 938848), (789157, 938851), ...,\n", + " (809282, 939329), (809392, 939331), (809502, 939334)],\n", + " [(788935, 938956), (789045, 938958), (789155, 938961), ...,\n", + " (809279, 939439), (809389, 939441), (809499, 939444)],\n", + " [(788932, 939066), (789042, 939068), (789152, 939071), ...,\n", + " (809276, 939549), (809386, 939551), (809496, 939554)],\n", + " ...,\n", + " [(788044, 976455), (788154, 976458), (788264, 976460), ...,\n", + " (808389, 976938), (808499, 976941), (808609, 976943)],\n", + " [(788042, 976565), (788152, 976568), (788262, 976570), ...,\n", + " (808386, 977048), (808496, 977051), (808606, 977053)],\n", + " [(788039, 976675), (788149, 976678), (788259, 976680), ...,\n", + " (808383, 977158), (808493, 977161), (808603, 977163)]],\n", + " dtype={'names': ['inline', 'crossline'], 'formats': ['" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "crossline_index = mdio.coord_to_index(100, dimensions=\"crossline\").item()\n", + "xl_mask, xl_headers, xl_data = mdio[:, crossline_index]\n", + "\n", + "vmin, vmax = -2 * std, 2 * std\n", + "\n", + "gs_kw = dict(height_ratios=(1, 5))\n", + "fig, ax = plt.subplots(2, 1, gridspec_kw=gs_kw, sharex=\"all\")\n", + "\n", + "ax[0].plot(inlines, xl_headers[\"inline\"])\n", + "\n", + "ax[1].pcolormesh(inlines, times, xl_data.T, vmin=vmin, vmax=vmax, cmap=\"gray_r\")\n", + "ax[1].invert_yaxis()\n", + "ax[1].set_xlabel(\"inline\")\n", + "ax[1].set_ylabel(\"twt (ms)\")\n", + "\n", + "plt.suptitle(f\"Crossline {100} with header.\");" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## MDIO to SEG-Y Conversion\n", + "\n", + "Finally, let's demonstrate going back to SEG-Y. \n", + "\n", + "We will use the convenient `mdio_to_segy` function and write it out as a round-trip file." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Array shape is (345, 188, 1501)\n", + "Setting (dask) chunks from (64, 64, 64) to (256, 188, 1501)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Unwrapping MDIO Blocks: 100%|██████████| 13/13 [00:01<00:00, 8.05it/s]\n", + "Merging lines: 100%|██████████| 345/345 [00:00<00:00, 1260.89it/s]\n" + ] + } + ], + "source": [ + "from mdio import mdio_to_segy\n", + "\n", + "mdio_to_segy(\n", + " mdio_path_or_buffer=\"filt_mig.mdio\",\n", + " output_segy_path=\"filt_mig_roundtrip.sgy\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Validate Round-Trip SEG-Y File\n", + "\n", + "We can validate if the round-trip SEG-Y file is matching the original using [TGSAI/segy][segy-github].\n", + "\n", + "Step by step:\n", + "* Open original file\n", + "* Open round-trip file\n", + "* Compare text headers\n", + "* Compare binary headers\n", + "* Compare 100 random headers and traces\n", + "\n", + "[segy-github]: https://github.com/TGSAI/segy" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from segy import SegyFile\n", + "\n", + "original_segy = SegyFile(\"filt_mig.sgy\")\n", + "roundtrip_segy = SegyFile(\"filt_mig_roundtrip.sgy\")\n", + "\n", + "# Compare text header\n", + "assert original_segy.text_header == roundtrip_segy.text_header\n", + "\n", + "# Compare bin header\n", + "assert original_segy.binary_header == roundtrip_segy.binary_header\n", + "\n", + "# Compare 100 random trace headers and traces\n", + "rng = np.random.default_rng()\n", + "rand_indices = rng.integers(low=0, high=original_segy.num_traces, size=100)\n", + "for idx in rand_indices:\n", + " np.testing.assert_equal(original_segy.trace[idx], roundtrip_segy.trace[idx])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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.12.3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "104c0d4e90244ebc959e51a58794dcf4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "display": "inline-flex", + "flex_flow": "row wrap", + "width": "100%" + } + }, + "1c0f5b458ee1401eaa8de63c65802073": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "21b25dd6080d42368afc06770d5e1755": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_35fb49026dac479eba87217c2f6bcb9a", + "style": "IPY_MODEL_3ab3e27c83aa423d9ecdac94e576f0fe", + "value": "Ingesting SEG-Y in 6 chunks: 100%" + } + }, + "2693aae410f04e7587f0400b5eef1079": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "318aea09479a479981dcfa29bc856c67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "35fb49026dac479eba87217c2f6bcb9a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3ab3e27c83aa423d9ecdac94e576f0fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "420b4a9492c54eb48d7779f38a09fd20": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "flex": "2" + } + }, + "42afe4fae9dd4bc4a341a231cf7a9c32": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "4df685a95de542ffab6f265df89b8949": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "58eaddb54c8840da83d1f6503d6ba64f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "5b3e72b71f304230bc36bb91f9c173be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "5c1fab0ccc7e42c69c2b663b67ca9e3c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "63a54817ae8b4c8d85b30d8c97e7ed0d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_e170d60a55a14c489d32b101293a9d33", + "IPY_MODEL_662ad93cf7b3470f8e197350441f09ca", + "IPY_MODEL_ac4abab2367e461e956e4e0edb27be44" + ], + "layout": "IPY_MODEL_c59d6fe969a04f4da332ae2a6fdb9c77" + } + }, + "63f87a2410ba47d38ad9f55a81357a29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_ca48140488574a28a7469552441560e4", + "style": "IPY_MODEL_ae2037efb9cc459e84bcc28ca7243437", + "value": " 2/2 [00:03<00:00, 3.01s/block]" + } + }, + "64eb2b9c8a094a1ea5f1991e5f09f5d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "662ad93cf7b3470f8e197350441f09ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_420b4a9492c54eb48d7779f38a09fd20", + "max": 1, + "style": "IPY_MODEL_d16e93f72f3d4aeda2f5deee87e9754f", + "value": 1 + } + }, + "74283969ff5446c89bb83b00a70226cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_5c1fab0ccc7e42c69c2b663b67ca9e3c", + "style": "IPY_MODEL_1c0f5b458ee1401eaa8de63c65802073", + "value": " 6/6 [00:09<00:00, 2.48s/block]" + } + }, + "75cf0c1ed25e47aab20b060f3bb44fb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_21b25dd6080d42368afc06770d5e1755", + "IPY_MODEL_c33f32b62a204ef094f67b10f8adbdc1", + "IPY_MODEL_74283969ff5446c89bb83b00a70226cf" + ], + "layout": "IPY_MODEL_91df4ac76fd744539d4237d6099f34a5" + } + }, + "7ff32d7deac14f21ab0f0939fe09e440": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "91df4ac76fd744539d4237d6099f34a5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "display": "inline-flex", + "flex_flow": "row wrap", + "width": "100%" + } + }, + "981634b52a7a4ffdae6186061c0b6482": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_f65266f861cf40ef84e9ec74a8e0b44c", + "IPY_MODEL_9aaf514a5035413d8cbbad58aa0221f4", + "IPY_MODEL_63f87a2410ba47d38ad9f55a81357a29" + ], + "layout": "IPY_MODEL_104c0d4e90244ebc959e51a58794dcf4" + } + }, + "9aaf514a5035413d8cbbad58aa0221f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_b25523a221fd4b5e9211d07ef39cccf5", + "max": 2, + "style": "IPY_MODEL_318aea09479a479981dcfa29bc856c67", + "value": 2 + } + }, + "9fe5348964cd4f7880bcd33204bbc7a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "a03d238db31145b881a1be478f9eb72f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a6aabcd2e57348a49bb59477f6a9fd90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_cfb02c9c7447491ca00bbb6acd99bb79", + "max": 26, + "style": "IPY_MODEL_7ff32d7deac14f21ab0f0939fe09e440", + "value": 26 + } + }, + "ac4abab2367e461e956e4e0edb27be44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_58eaddb54c8840da83d1f6503d6ba64f", + "style": "IPY_MODEL_a03d238db31145b881a1be478f9eb72f", + "value": " 3/? [00:00<00:00, 8.29block/s]" + } + }, + "ae2037efb9cc459e84bcc28ca7243437": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b25523a221fd4b5e9211d07ef39cccf5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "flex": "2" + } + }, + "b9810ee38bbe43f4bba100e53379be65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_42afe4fae9dd4bc4a341a231cf7a9c32", + "style": "IPY_MODEL_fdcea609ee7349629604217b625371d3", + "value": " 26/26 [00:01<00:00, 18.92block/s]" + } + }, + "c33f32b62a204ef094f67b10f8adbdc1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "bar_style": "success", + "layout": "IPY_MODEL_d23d88490a1b4941b8ca228b7d4a39cb", + "max": 6, + "style": "IPY_MODEL_2693aae410f04e7587f0400b5eef1079", + "value": 6 + } + }, + "c59d6fe969a04f4da332ae2a6fdb9c77": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "display": "inline-flex", + "flex_flow": "row wrap", + "width": "100%" + } + }, + "ca48140488574a28a7469552441560e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "cfb02c9c7447491ca00bbb6acd99bb79": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "flex": "2" + } + }, + "d16e93f72f3d4aeda2f5deee87e9754f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "description_width": "" + } + }, + "d23d88490a1b4941b8ca228b7d4a39cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "flex": "2" + } + }, + "d565a20d37e84ed0a1195e9a90154960": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_db696e15587c4a54b82886b3eb5a0c96", + "IPY_MODEL_a6aabcd2e57348a49bb59477f6a9fd90", + "IPY_MODEL_b9810ee38bbe43f4bba100e53379be65" + ], + "layout": "IPY_MODEL_eab4b060672b4dd5a73ca7bb8f782cd2" + } + }, + "db696e15587c4a54b82886b3eb5a0c96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_64eb2b9c8a094a1ea5f1991e5f09f5d9", + "style": "IPY_MODEL_5b3e72b71f304230bc36bb91f9c173be", + "value": "Step 1 / 2 Writing Blocks: 100%" + } + }, + "e170d60a55a14c489d32b101293a9d33": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_9fe5348964cd4f7880bcd33204bbc7a2", + "style": "IPY_MODEL_4df685a95de542ffab6f265df89b8949", + "value": "Step 2 / 2 Concat Blocks: " + } + }, + "e66368cda8124001b16459a0634029e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "eab4b060672b4dd5a73ca7bb8f782cd2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "display": "inline-flex", + "flex_flow": "row wrap", + "width": "100%" + } + }, + "f65266f861cf40ef84e9ec74a8e0b44c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_fff4199774534d9f982f03738fbb08e7", + "style": "IPY_MODEL_e66368cda8124001b16459a0634029e2", + "value": "Scanning SEG-Y for geometry attributes: 100%" + } + }, + "fdcea609ee7349629604217b625371d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "fff4199774534d9f982f03738fbb08e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/tutorials/rechunking.ipynb b/docs/tutorials/rechunking.ipynb new file mode 100644 index 00000000..ee8fc7b4 --- /dev/null +++ b/docs/tutorials/rechunking.ipynb @@ -0,0 +1,514 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ca09761db8545719", + "metadata": {}, + "source": [ + "# Optimizing Access Patterns\n", + "\n", + "## Introduction\n", + "\n", + "In this page we will be showing how we can take an existing MDIO and add\n", + "fast access, lossy, versions of the data in X/Y/Z cross-sections (slices).\n", + "\n", + "We can re-use the MDIO dataset we created in the [Quickstart](#quickstart) page.\n", + "Please run it first.\n", + "\n", + "We will define our compression levels first. We will use this to adjust the quality\n", + "of the lossy compression." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "initial_id", + "metadata": { + "ExecuteTime": { + "end_time": "2024-03-12T02:40:52.720542Z", + "start_time": "2024-03-12T02:40:52.716236Z" + } + }, + "outputs": [], + "source": [ + "from enum import Enum\n", + "\n", + "class MdioZfpQuality(float, Enum):\n", + " \"\"\"Config options for ZFP compression.\"\"\"\n", + "\n", + " VERY_LOW = 6\n", + " LOW = 3\n", + " MEDIUM = 1\n", + " HIGH = 0.1\n", + " VERY_HIGH = 0.01\n", + " ULTRA = 0.001" + ] + }, + { + "cell_type": "markdown", + "id": "c2a09a89-b453-4c3e-b879-14caaedd29de", + "metadata": {}, + "source": [ + "We will use the lower level `MDIOAccessor` to open the existing file in write mode that\n", + "allows us to modify its raw metadata. This can be dangerous, we recommend using only provided\n", + "tools to avoid data corruption.\n", + "\n", + "We specify the original access pattern of the source data `\"012\"` with some parameters like\n", + "caching. For the rechunking, we recommend using the single threaded `\"zarr\"` backend to avoid\n", + "race conditions.\n", + "\n", + "We also define a `dict` for common arguments in rechunking." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "45558306-ab9c-46aa-a299-8758a911b373", + "metadata": {}, + "outputs": [], + "source": [ + "from mdio.api.accessor import MDIOAccessor\n", + "\n", + "mdio_path = \"filt_mig.mdio\"\n", + "\n", + "orig_mdio_cached = MDIOAccessor(\n", + " mdio_path_or_buffer=mdio_path,\n", + " mode=\"w\",\n", + " access_pattern=\"012\",\n", + " storage_options=None,\n", + " return_metadata=False,\n", + " new_chunks=None,\n", + " backend=\"zarr\",\n", + " memory_cache_size=2**28,\n", + " disk_cache=False,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0a9af731-39b2-4373-af96-76811e7fead4", + "metadata": {}, + "source": [ + "## Compression (Lossy)\n", + "\n", + "Now, let's define our compression level. The compression ratios vary a lot\n", + "on the data characteristics. However, the compression levels here are good\n", + "guidelines that are based on standard deviation of the original data.\n", + "\n", + "We use ZFP's fixed accuracy mode with a tolerance based on data standard\n", + "deviation, as mentioned above. For more ZFP options you can see its documentation.\n", + "\n", + "Empirically, for this dataset, we see the following size reductions (per copy):\n", + "\n", + "* `10 : 1` on `VERY_LOW`\n", + "* `7.5 : 1` on `LOW`\n", + "* `4.5 : 1` on `MEDIUM`\n", + "* `3 : 1` on `HIGH`\n", + "* `2 : 1` on `VERY_HIGH`\n", + "* `1.5 : 1` on `ULTRA`" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "97681d5f-3c10-430c-8ff1-c9c1cff63d2c", + "metadata": {}, + "outputs": [], + "source": [ + "from numcodecs import ZFPY\n", + "from zfpy import mode_fixed_accuracy\n", + "\n", + "std = orig_mdio_cached.stats[\"std\"] # standard deviation of original data\n", + "\n", + "quality = MdioZfpQuality.LOW\n", + "tolerance = quality * std\n", + "sample_compressor = ZFPY(mode_fixed_accuracy, tolerance=tolerance)\n", + "\n", + "common_kwargs = {\"overwrite\": True, \"compressor\": sample_compressor}" + ] + }, + { + "cell_type": "markdown", + "id": "fafe9e65-5d46-4b32-893d-6020dce7a007", + "metadata": {}, + "source": [ + "## Optimizing IL/XL/Z Independently\n", + "\n", + "In this cell, we will demonstrate how to create IL/XL and Z (two-way-time) optimized\n", + "versions **independently**. In the next section we will do the same with the batch\n", + "mode where the data only needs to be read into memory once.\n", + "\n", + "In the example below, each rechunking operation will read the data from the original\n", + "MDIO dataset and discard it. We did enable 256 MB (2^28 bytes) memory cache above,\n", + "it will help some, but still not ideal." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ae5a722e-c6af-48d7-9893-031991bf9619", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Rechunking to fast_il: 100%|██████████| 3/3 [00:01<00:00, 1.77chunk/s]\n", + "Rechunking to fast_xl: 100%|██████████| 3/3 [00:01<00:00, 1.90chunk/s]\n", + "Rechunking to fast_z: 100%|██████████| 3/3 [00:01<00:00, 1.97chunk/s]\n" + ] + } + ], + "source": [ + "from mdio.api.convenience import rechunk\n", + "\n", + "rechunk(orig_mdio_cached, (4, 512, 512), suffix=\"fast_il\", **common_kwargs)\n", + "rechunk(orig_mdio_cached, (512, 4, 512), suffix=\"fast_xl\", **common_kwargs)\n", + "rechunk(orig_mdio_cached, (512, 512, 4), suffix=\"fast_z\", **common_kwargs)" + ] + }, + { + "cell_type": "markdown", + "id": "2d3fd987-2d9b-48f7-8688-745f9e3d9f0d", + "metadata": {}, + "source": [ + "We can now open the original MDIO dataset and the fast access patterns.\n", + "When printing the `chunks` attribute, we see the original one first, and\n", + "the subsequent ones show data is rechunked with ZFP compression." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9c46691a-f7fa-42ea-ad36-595681b2dff0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(64, 64, 64) Blosc(cname='zstd', clevel=5, shuffle=SHUFFLE, blocksize=0)\n", + "(4, 187, 512) ZFPY(mode=4, tolerance=2.7916183359718256, rate=-1, precision=-1)\n", + "(345, 4, 512) ZFPY(mode=4, tolerance=2.7916183359718256, rate=-1, precision=-1)\n", + "(345, 187, 4) ZFPY(mode=4, tolerance=2.7916183359718256, rate=-1, precision=-1)\n" + ] + } + ], + "source": [ + "from mdio import MDIOReader\n", + "\n", + "orig_mdio = MDIOReader(mdio_path)\n", + "il_mdio = MDIOReader(mdio_path, access_pattern=\"fast_il\")\n", + "xl_mdio = MDIOReader(mdio_path, access_pattern=\"fast_xl\")\n", + "z_mdio = MDIOReader(mdio_path, access_pattern=\"fast_z\")\n", + "\n", + "print(orig_mdio.chunks, orig_mdio._traces.compressor)\n", + "print(il_mdio.chunks, il_mdio._traces.compressor)\n", + "print(xl_mdio.chunks, xl_mdio._traces.compressor)\n", + "print(z_mdio.chunks, z_mdio._traces.compressor)" + ] + }, + { + "cell_type": "markdown", + "id": "64a32960-73e7-408e-9592-bc851c0d7c66", + "metadata": {}, + "source": [ + "We can now compare the sizes of the compressed representations to original.\n", + "\n", + "Below commands are for UNIX based operating systems and won't work on Windows." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6d66a26c-79c8-4e24-9181-60707cae6d59", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "149M\tfilt_mig.mdio/data/chunked_012\n", + " 21M\tfilt_mig.mdio/data/chunked_fast_il\n", + " 20M\tfilt_mig.mdio/data/chunked_fast_xl\n", + " 21M\tfilt_mig.mdio/data/chunked_fast_z\n" + ] + } + ], + "source": [ + "!du -hs {mdio_path}/data/chunked_012\n", + "!du -hs {mdio_path}/data/chunked_fast_il\n", + "!du -hs {mdio_path}/data/chunked_fast_xl\n", + "!du -hs {mdio_path}/data/chunked_fast_z" + ] + }, + { + "cell_type": "markdown", + "id": "147251da-55c0-497d-b954-1217c9b59698", + "metadata": {}, + "source": [ + "Comparing local disk read speeds for inlines:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bdd81177-3e90-4089-8ccc-cf7966b33041", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "31.1 ms ± 825 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "3.6 ms ± 52.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "%timeit orig_mdio[175] # 3d chunked\n", + "%timeit il_mdio[175] # inline optimized" + ] + }, + { + "cell_type": "markdown", + "id": "9cbd29f8-aa00-4f72-906f-96663d0163e9", + "metadata": {}, + "source": [ + "For crosslines:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "725e2562-9005-413a-b4c0-5c0f281183c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "65.3 ms ± 705 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "8.76 ms ± 353 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "%timeit orig_mdio[:, 90] # 3d chunked\n", + "%timeit xl_mdio[:, 90] # xline optimized" + ] + }, + { + "cell_type": "markdown", + "id": "bd274979-4b54-44a2-bd21-c35e933aaf43", + "metadata": {}, + "source": [ + "Finally, for Z (time-slices):" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "47983dac-2463-4b52-b3fd-d496a4ade114", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.36 ms ± 185 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "872 µs ± 8.24 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" + ] + } + ], + "source": [ + "%timeit orig_mdio[..., 751] # 3d chunked\n", + "%timeit z_mdio[..., 751] # time-slice optimized" + ] + }, + { + "cell_type": "markdown", + "id": "d26454dd-bf6a-46e8-863d-a0230269e339", + "metadata": {}, + "source": [ + "We can check the subjective quality of the compression by visually comparing\n", + "two inlines. Similar to the example we had in the [Compression](#compression) page." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "280d0759-2548-4e73-9caa-6734d294e36f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "\n", + "vmin = -3 * std\n", + "vmax = 3 * std\n", + "\n", + "imshow_kw = dict(vmin=vmin, vmax=vmax, cmap=\"gray_r\", interpolation=\"bilinear\", aspect=\"auto\")\n", + "\n", + "\n", + "def attach_colorbar(image, axis):\n", + " divider = make_axes_locatable(axis)\n", + " cax = divider.append_axes(\"top\", size=\"2%\", pad=0.05)\n", + " plt.colorbar(image, cax=cax, orientation=\"horizontal\")\n", + " cax.xaxis.set_ticks_position(\"top\")\n", + " cax.tick_params(labelsize=8)\n", + "\n", + "\n", + "def plot_image_and_cbar(data, axis, title):\n", + " image = axis.imshow(data.T, **imshow_kw)\n", + " attach_colorbar(image, axis)\n", + " axis.set_title(title, y=-0.15)\n", + "\n", + "\n", + "def plot_inlines_with_diff(orig, compressed, title):\n", + " fig, ax = plt.subplots(1, 4, sharey=\"all\", sharex=\"all\", figsize=(8, 5))\n", + "\n", + " diff = orig[200] - compressed[200]\n", + "\n", + " plot_image_and_cbar(orig[200], ax[0], \"original\")\n", + " plot_image_and_cbar(compressed[200], ax[1], \"lossy\")\n", + " plot_image_and_cbar(diff, ax[2], \"difference\")\n", + " plot_image_and_cbar(diff * 1_000, ax[3], \"1,000x difference\")\n", + "\n", + " plt.suptitle(f\"{title} ({std=})\")\n", + " fig.tight_layout()\n", + "\n", + " plt.show()\n", + "\n", + "\n", + "plot_inlines_with_diff(orig_mdio, il_mdio, \"\")" + ] + }, + { + "cell_type": "markdown", + "id": "2900c40b-c332-4334-a4cc-f0e5571c7387", + "metadata": {}, + "source": [ + "In conclusion, we show that by generating optimized, lossy compressed copies of the data\n", + "for certain access patterns yield big performance benefits when reading the data.\n", + "\n", + "The differences are orders of magnitude larger on big datasets and remote stores, given available\n", + "network bandwidth." + ] + }, + { + "cell_type": "markdown", + "id": "38f7d35e-d743-4bb3-a7a6-fa77aab08f00", + "metadata": {}, + "source": [ + "## Optimizing in Batch\n", + "\n", + "Now that we understand how rechunking and lossy compression works, we will demonstrate how\n", + "to do this in batches. \n", + "\n", + "The benefit of doing the batched processing is that the dataset gets read once. This is\n", + "especially important if the original MDIO resides in a remote store like AWS S3, or Google\n", + "Cloud's GCS.\n", + "\n", + "Note that we not are overwriting the old optimized chunks, just creating new ones with the\n", + "suffix 2 to demonstrate we can create as many version of the original data as we want." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "14c58331-0ce3-42fa-9cd0-a43574ce24bf", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Rechunking to fast_il2,fast_xl2,fast_z2: 100%|██████████| 3/3 [00:05<00:00, 1.84s/chunk]\n" + ] + } + ], + "source": [ + "from mdio.api.convenience import rechunk_batch\n", + "\n", + "rechunk_batch(\n", + " orig_mdio_cached,\n", + " chunks_list=[(4, 512, 512), (512, 4, 512), (512, 512, 4)],\n", + " suffix_list=[\"fast_il2\", \"fast_xl2\", \"fast_z2\"],\n", + " **common_kwargs,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a3f47a17-7537-4fc9-b3ab-b57badae18d1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(64, 64, 64) Blosc(cname='zstd', clevel=5, shuffle=SHUFFLE, blocksize=0)\n", + "(4, 187, 512) ZFPY(mode=4, tolerance=2.7916183359718256, rate=-1, precision=-1)\n", + "(345, 4, 512) ZFPY(mode=4, tolerance=2.7916183359718256, rate=-1, precision=-1)\n", + "(345, 187, 4) ZFPY(mode=4, tolerance=2.7916183359718256, rate=-1, precision=-1)\n" + ] + } + ], + "source": [ + "from mdio import MDIOReader\n", + "\n", + "orig_mdio = MDIOReader(mdio_path)\n", + "il2_mdio = MDIOReader(mdio_path, access_pattern=\"fast_il2\")\n", + "xl2_mdio = MDIOReader(mdio_path, access_pattern=\"fast_xl2\")\n", + "z2_mdio = MDIOReader(mdio_path, access_pattern=\"fast_z2\")\n", + "\n", + "print(orig_mdio.chunks, orig_mdio._traces.compressor)\n", + "print(il_mdio.chunks, il2_mdio._traces.compressor)\n", + "print(xl_mdio.chunks, xl2_mdio._traces.compressor)\n", + "print(z_mdio.chunks, z2_mdio._traces.compressor)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "008950d1-b142-4ca8-9879-f926007c97ca", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index f5b3abfa..e8ba87aa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "multidimio" -version = "0.9.0" +version = "1.0.0-alpha.1" description = "Cloud-native, scalable, and user-friendly multi dimensional energy data!" authors = [{ name = "Altay Sansal", email = "altay.sansal@tgs.com" }] requires-python = ">=3.11,<3.14" diff --git a/src/mdio/__main__.py b/src/mdio/__main__.py index b40f34ef..682346bf 100644 --- a/src/mdio/__main__.py +++ b/src/mdio/__main__.py @@ -27,7 +27,10 @@ class MyCLI(click.MultiCommand): must have a variable named `cli` for the command to be exposed. Args: - - plugin_folder: Path to the directory containing command modules. + plugin_folder: Path to the directory containing command modules. + *args: Any positional arguments. + **kwargs: Any keyword arguments. + """ def __init__(self, plugin_folder: Path, *args, **kwargs): diff --git a/src/mdio/api/accessor.py b/src/mdio/api/accessor.py index 2b0133f9..a4b7c298 100644 --- a/src/mdio/api/accessor.py +++ b/src/mdio/api/accessor.py @@ -500,6 +500,8 @@ def coord_to_index( class MDIOReader(MDIOAccessor): """Read-only accessor for MDIO files. + Initialized with `r` permission. + For detailed documentation see MDIOAccessor. Args: @@ -552,6 +554,8 @@ def __init__( class MDIOWriter(MDIOAccessor): """Writable accessor for MDIO files. + Initialized with `w` permission. + For detailed documentation see MDIOAccessor. Args: diff --git a/src/mdio/commands/segy.py b/src/mdio/commands/segy.py index f1561106..2c8bc76d 100644 --- a/src/mdio/commands/segy.py +++ b/src/mdio/commands/segy.py @@ -224,6 +224,7 @@ def segy_import( Usage: + \b Below are some examples of ingesting standard SEG-Y files per the SEG-Y Revision 1 and 2 formats. @@ -271,6 +272,8 @@ def segy_import( Usage: + + \b 3D Seismic Shot Data (Byte Locations Vary): Let's assume streamer number does not exist but there are 800 channels per cable. @@ -294,6 +297,7 @@ def segy_import( For shot gathers with channel numbers and wrapped channels, no grid overrides are necessary. + \b In cases where the user does not know if the input has unwrapped channels but desires to store with wrapped channel index use: --grid-overrides '{"AutoChannelWrap": True}' diff --git a/src/mdio/converters/mdio.py b/src/mdio/converters/mdio.py index 30565b0b..c5e97936 100644 --- a/src/mdio/converters/mdio.py +++ b/src/mdio/converters/mdio.py @@ -45,6 +45,10 @@ def mdio_to_segy( # noqa: C901 The input headers are preserved as is, and will be transferred to the output file. + The user has control over the endianness, and the floating point data + type. However, by default we export as Big-Endian IBM float, per the + SEG-Y format's default. + The input MDIO can be local or cloud based. However, the output SEG-Y will be generated locally. diff --git a/src/mdio/converters/segy.py b/src/mdio/converters/segy.py index 37ee6e5c..9dc175e2 100644 --- a/src/mdio/converters/segy.py +++ b/src/mdio/converters/segy.py @@ -430,7 +430,7 @@ def segy_to_mdio( # noqa: C901 else: msg = ( f"Default chunking for {dim_count}-D seismic data is " - "not implemented yet. Please explicity define chunk sizes." + "not implemented yet. Please explicitly define chunk sizes." ) raise NotImplementedError(msg) diff --git a/src/mdio/core/dimension.py b/src/mdio/core/dimension.py index 8151e8d9..67e0cae5 100644 --- a/src/mdio/core/dimension.py +++ b/src/mdio/core/dimension.py @@ -23,6 +23,11 @@ class Dimension: Args: coords: Vector of coordinates. name: Name of the dimension. + + Attributes: + coords: Vector of coordinates. + name: Name of the dimension. + """ coords: list | tuple | NDArray | range diff --git a/src/mdio/core/grid.py b/src/mdio/core/grid.py index 3718c622..0500341c 100644 --- a/src/mdio/core/grid.py +++ b/src/mdio/core/grid.py @@ -32,6 +32,9 @@ class Grid: Args: dims: List of dimension instances. + + Attributes: + dims: List of dimension instances. """ dims: list[Dimension] diff --git a/src/mdio/segy/blocked_io.py b/src/mdio/segy/blocked_io.py index 99c20155..7d90448d 100644 --- a/src/mdio/segy/blocked_io.py +++ b/src/mdio/segy/blocked_io.py @@ -201,7 +201,7 @@ def to_segy( r"""Convert MDIO blocks to SEG-Y parts. Blocks are written out in parallel via multiple workers, and then - djacent blocks are tracked and merged on disk via the `segy_trace_concat` + adjacent blocks are tracked and merged on disk via the `segy_trace_concat` function. The adjacent are hierarchically merged, and it preserves order. Assume array with shape (4, 3, 2) with chunk sizes (1, 1, 2). From 28e7da87d7a591b05057f8e2f298cceed431d25c Mon Sep 17 00:00:00 2001 From: BrianMichell Date: Wed, 23 Apr 2025 21:18:27 +0000 Subject: [PATCH 2/4] Fix linting --- src/mdio/__main__.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/mdio/__main__.py b/src/mdio/__main__.py index 682346bf..906bf959 100644 --- a/src/mdio/__main__.py +++ b/src/mdio/__main__.py @@ -27,10 +27,9 @@ class MyCLI(click.MultiCommand): must have a variable named `cli` for the command to be exposed. Args: - plugin_folder: Path to the directory containing command modules. - *args: Any positional arguments. - **kwargs: Any keyword arguments. - + - `plugin_folder`: Path to the directory containing command modules. + - `*args`: Any positional arguments. + - `**kwargs`: Any keyword arguments. """ def __init__(self, plugin_folder: Path, *args, **kwargs): From f0a3eda5e1ca349e72a9eee10ad8010768bb8580 Mon Sep 17 00:00:00 2001 From: BrianMichell Date: Wed, 23 Apr 2025 21:18:43 +0000 Subject: [PATCH 3/4] Bump version --- uv.lock | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/uv.lock b/uv.lock index e191c910..0d6e53d8 100644 --- a/uv.lock +++ b/uv.lock @@ -1500,7 +1500,7 @@ wheels = [ [[package]] name = "multidimio" -version = "0.9.0" +version = "1.0.0a1" source = { editable = "." } dependencies = [ { name = "click" }, From 49555ea51d5d3a4e74dd776ac8ead7aaec6c8ed2 Mon Sep 17 00:00:00 2001 From: BrianMichell Date: Thu, 24 Apr 2025 15:07:32 +0000 Subject: [PATCH 4/4] Resolve docs-build issues --- docs/data_models/index.md | 4 +- docs/tutorials/quickstart.ipynb | 2 +- noxfile.py | 4 ++ pyproject.toml | 8 ++- src/mdio/converters/segy.py | 5 +- uv.lock | 120 +++++++++++++++++++++++++++++--- 6 files changed, 127 insertions(+), 16 deletions(-) diff --git a/docs/data_models/index.md b/docs/data_models/index.md index 83fd9ad1..6921e6fe 100644 --- a/docs/data_models/index.md +++ b/docs/data_models/index.md @@ -4,6 +4,6 @@ This section contains the data models for the MDIO format. ```{toctree} :maxdepth: 2 -version_0 -version_1 +v0 +v1 ``` diff --git a/docs/tutorials/quickstart.ipynb b/docs/tutorials/quickstart.ipynb index e36e89b5..4f65f2d4 100644 --- a/docs/tutorials/quickstart.ipynb +++ b/docs/tutorials/quickstart.ipynb @@ -922,7 +922,7 @@ "* Compare binary headers\n", "* Compare 100 random headers and traces\n", "\n", - "[segy-github]: https://github.com/TGSAI/segy" + "" ] }, { diff --git a/noxfile.py b/noxfile.py index 087dba24..a313c2da 100644 --- a/noxfile.py +++ b/noxfile.py @@ -278,9 +278,11 @@ def docs_build(session: Session) -> None: "sphinx", "sphinx-click", "sphinx-copybutton", + "sphinx-design", "furo", "myst-nb", "linkify-it-py", + "pint", ], ) @@ -303,9 +305,11 @@ def docs(session: Session) -> None: "sphinx-autobuild", "sphinx-click", "sphinx-copybutton", + "sphinx-design", "furo", "myst-nb", "linkify-it-py", + "pint", ], ) diff --git a/pyproject.toml b/pyproject.toml index e8ba87aa..d3466626 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -31,6 +31,7 @@ dependencies = [ "psutil (>=6.1.0,<7.0.0)", "pydantic (>=2.8.2,<3.0.0)", "pydantic-settings (>=2.4.0,<3.0.0)", + "autodoc-pydantic (>=2.2.0,<3.0.0)", "fsspec (>=2024.10.0)", "segy (>=0.4.0,<0.5.0)", "rich (>=13.9.4,<14.0.0)", @@ -76,14 +77,17 @@ dev = [ "pytest-dependency>=0.6.0,<0.7", "pyupgrade>=3.19.0,<4", "safety>=3.2.3,<4", + "sphinx>=8.1.3,<9", "sphinx-autobuild>=2024.10.3", "sphinx-click>=6.0.0,<7", "sphinx-copybutton>=0.5.2,<0.6", + "sphinxcontrib-packages>=1.2.0,<2", + "sphinx-design>=0.6.1,<0.7", "typeguard>=4.4.1,<5", "xdoctest[colors]>=1.2.0,<2", - "myst-parser>=3.0.1,<4", + "myst-parser>=4.0.0,<5", "Pygments>=2.18.0,<3", - "Sphinx>=7.4.7,<8", + "pint>=0.24.3,<0.25", ] [tool.uv] diff --git a/src/mdio/converters/segy.py b/src/mdio/converters/segy.py index 9dc175e2..4f6670b2 100644 --- a/src/mdio/converters/segy.py +++ b/src/mdio/converters/segy.py @@ -211,7 +211,6 @@ def segy_to_mdio( # noqa: C901 >>> from mdio import segy_to_mdio >>> - >>> >>> segy_to_mdio( ... segy_path="prefix1/file.segy", ... mdio_path_or_buffer="prefix2/file.mdio", @@ -287,8 +286,8 @@ def segy_to_mdio( # noqa: C901 In cases where the user does not know if the input has unwrapped channels but desires to store with wrapped channel index use: - >>> grid_overrides={"AutoChannelWrap": True, - "AutoChannelTraceQC": 1000000} + >>> grid_overrides={"AutoChannelWrap": True, + ... "AutoChannelTraceQC": 1000000} For ingestion of pre-stack streamer data where the user needs to access/index *common-channel gathers* (single gun) then the following diff --git a/uv.lock b/uv.lock index 0d6e53d8..d8fbf9fb 100644 --- a/uv.lock +++ b/uv.lock @@ -190,6 +190,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b1/ae/4d289407515223677e7d105ec88bc707a115cce79464c6b56313beb0dd36/authlib-1.5.1-py2.py3-none-any.whl", hash = "sha256:8408861cbd9b4ea2ff759b00b6f02fd7d81ac5a56d0b2b22c08606c6049aae11", size = 231358 }, ] +[[package]] +name = "autodoc-pydantic" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "sphinx" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/df/87120e2195f08d760bc5cf8a31cfa2381a6887517aa89453b23f1ae3354f/autodoc_pydantic-2.2.0-py3-none-any.whl", hash = "sha256:8c6a36fbf6ed2700ea9c6d21ea76ad541b621fbdf16b5a80ee04673548af4d95", size = 34001 }, +] + [[package]] name = "azure-core" version = "1.32.0" @@ -794,6 +807,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e4/f1/196d28df38200133574922a3fa20b58629bb11cdabe185cbd9943d6fd371/distributed-2025.3.0-py3-none-any.whl", hash = "sha256:ebdacd181873b39bc30185857a5a856f051efaaf42ef2a8f507708857acdc6a9", size = 1018811 }, ] +[[package]] +name = "distro" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277 }, +] + [[package]] name = "docutils" version = "0.21.2" @@ -903,6 +925,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/12/bf/0e6933d78d172df672325622bf1b7f8364f4a6515da9e89398227c19d02e/flake8_rst_docstrings-0.3.0-py3-none-any.whl", hash = "sha256:f8c3c6892ff402292651c31983a38da082480ad3ba253743de52989bdc84ca1c", size = 10892 }, ] +[[package]] +name = "flexcache" +version = "0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/b0/8a21e330561c65653d010ef112bf38f60890051d244ede197ddaa08e50c1/flexcache-0.3.tar.gz", hash = "sha256:18743bd5a0621bfe2cf8d519e4c3bfdf57a269c15d1ced3fb4b64e0ff4600656", size = 15816 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/cd/c883e1a7c447479d6e13985565080e3fea88ab5a107c21684c813dba1875/flexcache-0.3-py3-none-any.whl", hash = "sha256:d43c9fea82336af6e0115e308d9d33a185390b8346a017564611f1466dcd2e32", size = 13263 }, +] + +[[package]] +name = "flexparser" +version = "0.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/82/99/b4de7e39e8eaf8207ba1a8fa2241dd98b2ba72ae6e16960d8351736d8702/flexparser-0.4.tar.gz", hash = "sha256:266d98905595be2ccc5da964fe0a2c3526fbbffdc45b65b3146d75db992ef6b2", size = 31799 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/5e/3be305568fe5f34448807976dc82fc151d76c3e0e03958f34770286278c1/flexparser-0.4-py3-none-any.whl", hash = "sha256:3738b456192dcb3e15620f324c447721023c0293f6af9955b481e91d00179846", size = 27625 }, +] + [[package]] name = "frozenlist" version = "1.5.0" @@ -1503,6 +1549,7 @@ name = "multidimio" version = "1.0.0a1" source = { editable = "." } dependencies = [ + { name = "autodoc-pydantic" }, { name = "click" }, { name = "click-params" }, { name = "dask" }, @@ -1545,6 +1592,7 @@ dev = [ { name = "mypy" }, { name = "myst-parser" }, { name = "pep8-naming" }, + { name = "pint" }, { name = "pre-commit" }, { name = "pre-commit-hooks" }, { name = "pygments" }, @@ -1556,6 +1604,8 @@ dev = [ { name = "sphinx-autobuild" }, { name = "sphinx-click" }, { name = "sphinx-copybutton" }, + { name = "sphinx-design" }, + { name = "sphinxcontrib-packages" }, { name = "typeguard" }, { name = "xdoctest", extra = ["colors"] }, ] @@ -1563,6 +1613,7 @@ dev = [ [package.metadata] requires-dist = [ { name = "adlfs", marker = "extra == 'cloud'", specifier = ">=2024.7.0" }, + { name = "autodoc-pydantic", specifier = ">=2.2.0,<3.0.0" }, { name = "bokeh", marker = "extra == 'distributed'", specifier = ">=3.4.2,<4.0.0" }, { name = "click", specifier = ">=8.1.7,<9.0.0" }, { name = "click-params", specifier = ">=0.5.0,<0.6.0" }, @@ -1595,8 +1646,9 @@ dev = [ { name = "furo", specifier = ">=2024.8.6" }, { name = "isort", specifier = ">=5.13.2,<6" }, { name = "mypy", specifier = ">=1.13.0,<2" }, - { name = "myst-parser", specifier = ">=3.0.1,<4" }, + { name = "myst-parser", specifier = ">=4.0.0,<5" }, { name = "pep8-naming", specifier = ">=0.14.1,<0.15" }, + { name = "pint", specifier = ">=0.24.3,<0.25" }, { name = "pre-commit", specifier = ">=4.0.1,<5" }, { name = "pre-commit-hooks", specifier = ">=5.0.0,<6" }, { name = "pygments", specifier = ">=2.18.0,<3" }, @@ -1604,10 +1656,12 @@ dev = [ { name = "pytest-dependency", specifier = ">=0.6.0,<0.7" }, { name = "pyupgrade", specifier = ">=3.19.0,<4" }, { name = "safety", specifier = ">=3.2.3,<4" }, - { name = "sphinx", specifier = ">=7.4.7,<8" }, + { name = "sphinx", specifier = ">=8.1.3,<9" }, { name = "sphinx-autobuild", specifier = ">=2024.10.3" }, { name = "sphinx-click", specifier = ">=6.0.0,<7" }, { name = "sphinx-copybutton", specifier = ">=0.5.2,<0.6" }, + { name = "sphinx-design", specifier = ">=0.6.1,<0.7" }, + { name = "sphinxcontrib-packages", specifier = ">=1.2.0,<2" }, { name = "typeguard", specifier = ">=4.4.1,<5" }, { name = "xdoctest", extras = ["colors"], specifier = ">=1.2.0,<2" }, ] @@ -1654,7 +1708,7 @@ wheels = [ [[package]] name = "myst-parser" -version = "3.0.1" +version = "4.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "docutils" }, @@ -1664,9 +1718,9 @@ dependencies = [ { name = "pyyaml" }, { name = "sphinx" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/49/64/e2f13dac02f599980798c01156393b781aec983b52a6e4057ee58f07c43a/myst_parser-3.0.1.tar.gz", hash = "sha256:88f0cb406cb363b077d176b51c476f62d60604d68a8dcdf4832e080441301a87", size = 92392 } +sdist = { url = "https://files.pythonhosted.org/packages/66/a5/9626ba4f73555b3735ad86247a8077d4603aa8628537687c839ab08bfe44/myst_parser-4.0.1.tar.gz", hash = "sha256:5cfea715e4f3574138aecbf7d54132296bfd72bb614d31168f48c477a830a7c4", size = 93985 } wheels = [ - { url = "https://files.pythonhosted.org/packages/e2/de/21aa8394f16add8f7427f0a1326ccd2b3a2a8a3245c9252bc5ac034c6155/myst_parser-3.0.1-py3-none-any.whl", hash = "sha256:6457aaa33a5d474aca678b8ead9b3dc298e89c68e67012e73146ea6fd54babf1", size = 83163 }, + { url = "https://files.pythonhosted.org/packages/5f/df/76d0321c3797b54b60fef9ec3bd6f4cfd124b9e422182156a1dd418722cf/myst_parser-4.0.1-py3-none-any.whl", hash = "sha256:9134e88959ec3b5780aedf8a99680ea242869d012e8821db3126d427edc9c95d", size = 84579 }, ] [[package]] @@ -1970,6 +2024,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/21/2c/5e05f58658cf49b6667762cca03d6e7d85cededde2caf2ab37b81f80e574/pillow-11.2.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:208653868d5c9ecc2b327f9b9ef34e0e42a4cdd172c2988fd81d62d2bc9bc044", size = 2674751 }, ] +[[package]] +name = "pint" +version = "0.24.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "flexcache" }, + { name = "flexparser" }, + { name = "platformdirs" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/20/bb/52b15ddf7b7706ed591134a895dbf6e41c8348171fb635e655e0a4bbb0ea/pint-0.24.4.tar.gz", hash = "sha256:35275439b574837a6cd3020a5a4a73645eb125ce4152a73a2f126bf164b91b80", size = 342225 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/16/bd2f5904557265882108dc2e04f18abc05ab0c2b7082ae9430091daf1d5c/Pint-0.24.4-py3-none-any.whl", hash = "sha256:aa54926c8772159fcf65f82cc0d34de6768c151b32ad1deb0331291c38fe7659", size = 302029 }, +] + [[package]] name = "platformdirs" version = "4.3.7" @@ -2551,6 +2620,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 }, ] +[[package]] +name = "roman-numerals-py" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/76/48fd56d17c5bdbdf65609abbc67288728a98ed4c02919428d4f52d23b24b/roman_numerals_py-3.1.0.tar.gz", hash = "sha256:be4bf804f083a4ce001b5eb7e3c0862479d10f94c936f6c4e5f250aa5ff5bd2d", size = 9017 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/53/97/d2cbbaa10c9b826af0e10fdf836e1bf344d9f0abb873ebc34d1f49642d3f/roman_numerals_py-3.1.0-py3-none-any.whl", hash = "sha256:9da2ad2fb670bcf24e81070ceb3be72f6c11c440d73bd579fbeca1e9f330954c", size = 7742 }, +] + [[package]] name = "rsa" version = "4.9" @@ -2751,7 +2829,7 @@ wheels = [ [[package]] name = "sphinx" -version = "7.4.7" +version = "8.2.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "alabaster" }, @@ -2763,6 +2841,7 @@ dependencies = [ { name = "packaging" }, { name = "pygments" }, { name = "requests" }, + { name = "roman-numerals-py" }, { name = "snowballstemmer" }, { name = "sphinxcontrib-applehelp" }, { name = "sphinxcontrib-devhelp" }, @@ -2771,9 +2850,9 @@ dependencies = [ { name = "sphinxcontrib-qthelp" }, { name = "sphinxcontrib-serializinghtml" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5b/be/50e50cb4f2eff47df05673d361095cafd95521d2a22521b920c67a372dcb/sphinx-7.4.7.tar.gz", hash = "sha256:242f92a7ea7e6c5b406fdc2615413890ba9f699114a9c09192d7dfead2ee9cfe", size = 8067911 } +sdist = { url = "https://files.pythonhosted.org/packages/38/ad/4360e50ed56cb483667b8e6dadf2d3fda62359593faabbe749a27c4eaca6/sphinx-8.2.3.tar.gz", hash = "sha256:398ad29dee7f63a75888314e9424d40f52ce5a6a87ae88e7071e80af296ec348", size = 8321876 } wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/ef/153f6803c5d5f8917dbb7f7fcf6d34a871ede3296fa89c2c703f5f8a6c8e/sphinx-7.4.7-py3-none-any.whl", hash = "sha256:c2419e2135d11f1951cd994d6eb18a1835bd8fdd8429f9ca375dc1f3281bd239", size = 3401624 }, + { url = "https://files.pythonhosted.org/packages/31/53/136e9eca6e0b9dc0e1962e2c908fbea2e5ac000c2a2fbd9a35797958c48b/sphinx-8.2.3-py3-none-any.whl", hash = "sha256:4405915165f13521d875a8c29c8970800a0141c14cc5416a38feca4ea5d9b9c3", size = 3589741 }, ] [[package]] @@ -2831,6 +2910,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9e/48/1ea60e74949eecb12cdd6ac43987f9fd331156388dcc2319b45e2ebb81bf/sphinx_copybutton-0.5.2-py3-none-any.whl", hash = "sha256:fb543fd386d917746c9a2c50360c7905b605726b9355cd26e9974857afeae06e", size = 13343 }, ] +[[package]] +name = "sphinx-design" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2b/69/b34e0cb5336f09c6866d53b4a19d76c227cdec1bbc7ac4de63ca7d58c9c7/sphinx_design-0.6.1.tar.gz", hash = "sha256:b44eea3719386d04d765c1a8257caca2b3e6f8421d7b3a5e742c0fd45f84e632", size = 2193689 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/43/65c0acbd8cc6f50195a3a1fc195c404988b15c67090e73c7a41a9f57d6bd/sphinx_design-0.6.1-py3-none-any.whl", hash = "sha256:b11f37db1a802a183d61b159d9a202314d4d2fe29c163437001324fe2f19549c", size = 2215338 }, +] + [[package]] name = "sphinxcontrib-applehelp" version = "2.0.0" @@ -2867,6 +2958,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071 }, ] +[[package]] +name = "sphinxcontrib-packages" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distro" }, + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/4d/9f32abbfbd2ea1ab29c5199819d2114f7c6ba09d2e45faaaf26777d1ab54/sphinxcontrib_packages-1.2.0.tar.gz", hash = "sha256:bdb5f4b0f4b78491287fdbeeef25fb2e546b1165c94d2ca2a1ec1d27ef11a6a8", size = 20385 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/e3/3c649a43cf62e4de7ba9872f4191c1c13ade3a21af30c8bfb1db0977c1dc/sphinxcontrib_packages-1.2.0-py3-none-any.whl", hash = "sha256:ea10b144406c51db0a5e1ad40799f037822c25b1d83318971fdb35e81cf8f611", size = 19411 }, +] + [[package]] name = "sphinxcontrib-qthelp" version = "2.0.0"