adios4dolfinx 0.7.2__tar.gz → 0.8.0.dev0__tar.gz

adios4dolfinx-0.8.0.dev0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.1
+Name: adios4dolfinx
+Version: 0.8.0.dev0
+Summary: Checkpointing functionality for DOLFINx meshes/functions with ADIOS2
+Author-email: "Jørgen S. Dokken" <dokken@simula.no>
+License: Copyright 2023 Jørgen S. Dokken
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fenics-dolfinx>=0.8.0.dev0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: ipyparallel; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pdbpp; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: jupyter-book; extra == "docs"
+Requires-Dist: ipyparallel; extra == "docs"
+Requires-Dist: ipywidgets; extra == "docs"
+Provides-Extra: all
+Requires-Dist: adios4dolfinx[dev,docs,test]; extra == "all"
+
+# ADIOS2Wrappers for DOLFINx
+
+[![MIT](https://img.shields.io/github/license/jorgensd/adios4dolfinx)](LICENSE)
+[Read Latest Documentation](https://jsdokken.com/adios4dolfinx/)
+
+This is an extension for [DOLFINx](https://github.com/FEniCS/dolfinx/) to checkpoint meshes, meshtags and functions using [ADIOS2](https://adios2.readthedocs.io/en/latest/).
+
+The code uses the adios2 Python-wrappers to write DOLFINx objects to file, supporting N-to-M (_recoverable_) and N-to-N (_snapshot_) checkpointing.
+See: [Checkpointing in DOLFINx - FEniCS 23](https://jsdokken.com/checkpointing-presentation/#/) for more information.
+
+For scalability, the code uses [MPI Neighbourhood collectives](https://www.mpi-forum.org/docs/mpi-3.1/mpi31-report/node200.htm) for communication across processes.
+
+## Installation
+
+### Docker
+
+ADIOS2 is installed in the official DOLFINx containers.
+
+```bash
+docker run -ti -v $(pwd):/root/shared -w /root/shared --name=dolfinx-checkpoint ghcr.io/fenics/dolfinx/dolfinx:nightly
+```
+
+### Conda
+
+To use with conda (DOLFINx release v0.7.0 works with v0.7.3 of ADIOS4DOLFINx)
+
+```bash
+conda create -n dolfinx-checkpoint python=3.10
+conda activate dolfinx-checkpoint
+conda install -c conda-forge fenics-dolfinx pip adios2
+python3 -m pip install git+https://github.com/jorgensd/adios4dolfinx@v0.7.2
+```
+
+## Functionality
+
+### DOLFINx
+
+- Reading and writing meshes, using `adios4dolfinx.read/write_mesh`
+- Reading and writing meshtags associated to meshes `adios4dolfinx.read/write_meshtags`
+- Reading checkpoints for any element (serial and parallel, arbitrary number of functions and timesteps per file). Use `adios4dolfinx.read/write_function`.
+- Writing standalone function checkpoints relating to "original meshes", i.e. meshes read from `XDMFFile`. Use `adios4dolfinx.write_function_on_input_mesh` for this.
+- Store mesh partitioning and re-read the mesh with this information, avoiding calling SCOTCH, Kahip or Parmetis.
+
+> [!IMPORTANT]  
+> For checkpoints written with `write_function` to be valid, you first have to store the mesh with `write_mesh` to the checkpoint file.
+
+> [!IMPORTANT]  
+> A checkpoint file supports multiple functions and multiple time steps, as long as the functions are associated with the same mesh
+
+> [!IMPORTANT]  
+> Only one mesh per file is allowed
+
+### Backwards compatibility
+
+> [!WARNING]
+> If you are using v0.7.2, you are adviced to upgrade to v0.7.3, as it contains som crucial fixes for openmpi.
+
+### Legacy DOLFIN
+
+Only checkpoints for `Lagrange` or `DG` functions are supported from legacy DOLFIN
+
+- Reading meshes from the DOLFIN HDF5File-format
+- Reading checkpoints from the DOLFIN HDF5File-format (one checkpoint per file only)
+- Reading checkpoints from the DOLFIN XDMFFile-format (one checkpoint per file only, and only uses the `.h5` file)
+
+See the [API](./docs/api) for more information.
+
+## Long term plan
+
+The long term plan is to get this library merged into DOLFINx (rewritten in C++ with appropriate Python-bindings).
+
+# Contributor guidelines
+When contributing to this repository, please first [create an issue](https://github.com/jorgensd/adios4dolfinx/issues/new/choose) containing information about the missing feature or the bug that you would like to fix. Here you can discuss the change you want to make with the maintainers of the repository.
+
+Please note we have a code of conduct, please follow it in all your interactions with the project.
+
+## New contributor guide
+
+To get an overview of the project, read the [documentation](https://jorgensd.github.io/adios4dolfinx). Here are some resources to help you get started with open source contributions:
+
+- [Finding ways to contribute to open source on GitHub](https://docs.github.com/en/get-started/exploring-projects-on-github/finding-ways-to-contribute-to-open-source-on-github)
+- [Set up Git](https://docs.github.com/en/get-started/quickstart/set-up-git)
+- [GitHub flow](https://docs.github.com/en/get-started/quickstart/github-flow)
+- [Collaborating with pull requests](https://docs.github.com/en/github/collaborating-with-pull-requests)
+
+## Pull Request Process
+
+
+### Pull Request
+
+- When you're finished with the changes, create a pull request, also known as a PR. It is also OK to create a [draft pull request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) from the very beginning. Once you are done you can click on the ["Ready for review"] button. You can also [request a review](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/requesting-a-pull-request-review) from one of the maintainers.
+- Don't forget to [link PR to the issue that you opened ](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue).
+- Enable the checkbox to [allow maintainer edits](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/allowing-changes-to-a-pull-request-branch-created-from-a-fork) so the branch can be updated for a merge.
+Once you submit your PR, a team member will review your proposal. We may ask questions or request for additional information.
+- We may ask for changes to be made before a PR can be merged, either using [suggested changes](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/incorporating-feedback-in-your-pull-request) or pull request comments. You can apply suggested changes directly through the UI. You can make any other changes in your fork, then commit them to your branch.
+- As you update your PR and apply changes, mark each conversation as [resolved](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/commenting-on-a-pull-request#resolving-conversations).
+- If you run into any merge issues, checkout this [git tutorial](https://lab.github.com/githubtraining/managing-merge-conflicts) to help you resolve merge conflicts and other issues.
+- Please make sure that all tests are passing, github pages renders nicely, and code coverage are are not lower than before your contribution. You see the different github action workflows by clicking the "Action" tab in the GitHub repository.
+
+Note that for a pull request to be accepted, it has to pass all the tests on CI, which includes:
+- `mypy`: typechecking
+- `ruff`: Code formatting
+- `pytest`: Successfull execution of all tests in the `tests` folder.
+
+
+### Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.

adios4dolfinx-0.8.0.dev0/README.md

@@ -0,0 +1,113 @@
+# ADIOS2Wrappers for DOLFINx
+
+[![MIT](https://img.shields.io/github/license/jorgensd/adios4dolfinx)](LICENSE)
+[Read Latest Documentation](https://jsdokken.com/adios4dolfinx/)
+
+This is an extension for [DOLFINx](https://github.com/FEniCS/dolfinx/) to checkpoint meshes, meshtags and functions using [ADIOS2](https://adios2.readthedocs.io/en/latest/).
+
+The code uses the adios2 Python-wrappers to write DOLFINx objects to file, supporting N-to-M (_recoverable_) and N-to-N (_snapshot_) checkpointing.
+See: [Checkpointing in DOLFINx - FEniCS 23](https://jsdokken.com/checkpointing-presentation/#/) for more information.
+
+For scalability, the code uses [MPI Neighbourhood collectives](https://www.mpi-forum.org/docs/mpi-3.1/mpi31-report/node200.htm) for communication across processes.
+
+## Installation
+
+### Docker
+
+ADIOS2 is installed in the official DOLFINx containers.
+
+```bash
+docker run -ti -v $(pwd):/root/shared -w /root/shared --name=dolfinx-checkpoint ghcr.io/fenics/dolfinx/dolfinx:nightly
+```
+
+### Conda
+
+To use with conda (DOLFINx release v0.7.0 works with v0.7.3 of ADIOS4DOLFINx)
+
+```bash
+conda create -n dolfinx-checkpoint python=3.10
+conda activate dolfinx-checkpoint
+conda install -c conda-forge fenics-dolfinx pip adios2
+python3 -m pip install git+https://github.com/jorgensd/adios4dolfinx@v0.7.2
+```
+
+## Functionality
+
+### DOLFINx
+
+- Reading and writing meshes, using `adios4dolfinx.read/write_mesh`
+- Reading and writing meshtags associated to meshes `adios4dolfinx.read/write_meshtags`
+- Reading checkpoints for any element (serial and parallel, arbitrary number of functions and timesteps per file). Use `adios4dolfinx.read/write_function`.
+- Writing standalone function checkpoints relating to "original meshes", i.e. meshes read from `XDMFFile`. Use `adios4dolfinx.write_function_on_input_mesh` for this.
+- Store mesh partitioning and re-read the mesh with this information, avoiding calling SCOTCH, Kahip or Parmetis.
+
+> [!IMPORTANT]  
+> For checkpoints written with `write_function` to be valid, you first have to store the mesh with `write_mesh` to the checkpoint file.
+
+> [!IMPORTANT]  
+> A checkpoint file supports multiple functions and multiple time steps, as long as the functions are associated with the same mesh
+
+> [!IMPORTANT]  
+> Only one mesh per file is allowed
+
+### Backwards compatibility
+
+> [!WARNING]
+> If you are using v0.7.2, you are adviced to upgrade to v0.7.3, as it contains som crucial fixes for openmpi.
+
+### Legacy DOLFIN
+
+Only checkpoints for `Lagrange` or `DG` functions are supported from legacy DOLFIN
+
+- Reading meshes from the DOLFIN HDF5File-format
+- Reading checkpoints from the DOLFIN HDF5File-format (one checkpoint per file only)
+- Reading checkpoints from the DOLFIN XDMFFile-format (one checkpoint per file only, and only uses the `.h5` file)
+
+See the [API](./docs/api) for more information.
+
+## Long term plan
+
+The long term plan is to get this library merged into DOLFINx (rewritten in C++ with appropriate Python-bindings).
+
+# Contributor guidelines
+When contributing to this repository, please first [create an issue](https://github.com/jorgensd/adios4dolfinx/issues/new/choose) containing information about the missing feature or the bug that you would like to fix. Here you can discuss the change you want to make with the maintainers of the repository.
+
+Please note we have a code of conduct, please follow it in all your interactions with the project.
+
+## New contributor guide
+
+To get an overview of the project, read the [documentation](https://jorgensd.github.io/adios4dolfinx). Here are some resources to help you get started with open source contributions:
+
+- [Finding ways to contribute to open source on GitHub](https://docs.github.com/en/get-started/exploring-projects-on-github/finding-ways-to-contribute-to-open-source-on-github)
+- [Set up Git](https://docs.github.com/en/get-started/quickstart/set-up-git)
+- [GitHub flow](https://docs.github.com/en/get-started/quickstart/github-flow)
+- [Collaborating with pull requests](https://docs.github.com/en/github/collaborating-with-pull-requests)
+
+## Pull Request Process
+
+
+### Pull Request
+
+- When you're finished with the changes, create a pull request, also known as a PR. It is also OK to create a [draft pull request](https://github.blog/2019-02-14-introducing-draft-pull-requests/) from the very beginning. Once you are done you can click on the ["Ready for review"] button. You can also [request a review](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/requesting-a-pull-request-review) from one of the maintainers.
+- Don't forget to [link PR to the issue that you opened ](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue).
+- Enable the checkbox to [allow maintainer edits](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/allowing-changes-to-a-pull-request-branch-created-from-a-fork) so the branch can be updated for a merge.
+Once you submit your PR, a team member will review your proposal. We may ask questions or request for additional information.
+- We may ask for changes to be made before a PR can be merged, either using [suggested changes](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/incorporating-feedback-in-your-pull-request) or pull request comments. You can apply suggested changes directly through the UI. You can make any other changes in your fork, then commit them to your branch.
+- As you update your PR and apply changes, mark each conversation as [resolved](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/commenting-on-a-pull-request#resolving-conversations).
+- If you run into any merge issues, checkout this [git tutorial](https://lab.github.com/githubtraining/managing-merge-conflicts) to help you resolve merge conflicts and other issues.
+- Please make sure that all tests are passing, github pages renders nicely, and code coverage are are not lower than before your contribution. You see the different github action workflows by clicking the "Action" tab in the GitHub repository.
+
+Note that for a pull request to be accepted, it has to pass all the tests on CI, which includes:
+- `mypy`: typechecking
+- `ruff`: Code formatting
+- `pytest`: Successfull execution of all tests in the `tests` folder.
+
+
+### Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.

adios4dolfinx-0.8.0.dev0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system] # Require setuptool version due to https://github.com/pypa/setuptools/issues/2938
+requires = ["setuptools>=61.0.0", "wheel"]
+
+[project]
+name = "adios4dolfinx"
+version = "0.8.0.dev0"
+description = "Checkpointing functionality for DOLFINx meshes/functions with ADIOS2"
+authors = [{ name = "Jørgen S. Dokken", email = "dokken@simula.no" }]
+license = { file = "LICENSE" }
+readme = "README.md"
+dependencies = ["fenics-dolfinx>=0.8.0.dev0"]
+
+[project.optional-dependencies]
+test = ["pytest", "coverage", "ipyparallel"]
+dev = ["pdbpp", "ipython", "mypy", "ruff"]
+docs = ["jupyter-book", "ipyparallel", "ipywidgets"]
+all = ["adios4dolfinx[test,dev,docs]"]
+
+[tool.pytest.ini_options]
+addopts = ["--import-mode=importlib"]
+testpaths = ["tests"]
+
+[tool.mypy]
+ignore_missing_imports = true
+# Folders to exclude
+exclude = ["docs/", "build/"]
+# Folder to check with mypy
+files = ["src", "tests"]
+
+[tool.ruff]
+src = ["src", "tests", "docs"]
+line-length = 100
+indent-width = 4
+
+[tool.ruff.lint]
+select = [
+    # Pyflakes
+    "F",
+    # Pycodestyle
+    "E",
+    "W",
+    # isort
+    "I001",
+]
+
+
+[tool.ruff.lint.isort]
+known-first-party = ["adios4dolfinx"]
+known-third-party = [
+    "basix",
+    "dolfinx",
+    "ffcx",
+    "ufl",
+    "gmsh",
+    "numpy",
+    "pytest",
+]
+section-order = [
+    "future",
+    "standard-library",
+    "mpi",
+    "third-party",
+    "first-party",
+    "local-folder",
+]
+
+[tool.ruff.lint.isort.sections]
+"mpi" = ["mpi4py", "petsc4py"]

{adios4dolfinx-0.7.2 → adios4dolfinx-0.8.0.dev0}/src/adios4dolfinx/__init__.py

@@ -5,13 +5,22 @@
 # SPDX-License-Identifier:    MIT
 
 """Top-level package for ADIOS2Wrappers."""
+
 from importlib.metadata import metadata
 
-from .checkpointing import (read_function, read_mesh, read_meshtags,
-                            snapshot_checkpoint, write_function, write_mesh,
-                            write_meshtags)
-from .legacy_readers import (read_function_from_legacy_h5,
-                             read_mesh_from_legacy_h5)
+from .checkpointing import (
+    read_attributes,
+    read_function,
+    read_mesh,
+    read_meshtags,
+    write_attributes,
+    write_function,
+    write_mesh,
+    write_meshtags,
+)
+from .legacy_readers import read_function_from_legacy_h5, read_mesh_from_legacy_h5
+from .original_checkpoint import write_function_on_input_mesh, write_mesh_input_order
+from .snapshot import snapshot_checkpoint
 
 meta = metadata("adios4dolfinx")
 __version__ = meta["Version"]
@@ -30,4 +39,8 @@ __all__ = [
     "write_function",
     "read_function",
     "snapshot_checkpoint",
+    "write_function_on_input_mesh",
+    "write_mesh_input_order",
+    "write_attributes",
+    "read_attributes",
 ]

adios4dolfinx-0.8.0.dev0/src/adios4dolfinx/adios2_helpers.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from pathlib import Path
+from typing import NamedTuple
+
+from mpi4py import MPI
+
+import adios2
+import dolfinx.cpp.graph
+import dolfinx.graph
+import numpy as np
+import numpy.typing as npt
+
+from .utils import compute_local_range, valid_function_types
+
+
+def resolve_adios_scope(adios2):
+    return adios2.bindings if hasattr(adios2, "bindings") else adios2
+
+
+adios2 = resolve_adios_scope(adios2)
+
+"""
+Helpers reading/writing data with ADIOS2
+"""
+
+__all__ = ["read_array", "read_adjacency_list", "read_cell_perms", "adios_to_numpy_dtype"]
+
+adios_to_numpy_dtype = {
+    "float": np.float32,
+    "double": np.float64,
+    "float complex": np.complex64,
+    "double complex": np.complex128,
+    "uint32_t": np.uint32,
+}
+
+
+class AdiosFile(NamedTuple):
+    io: adios2.IO
+    file: adios2.Engine
+
+
+@contextmanager
+def ADIOSFile(
+    adios: adios2.ADIOS,
+    filename: Path | str,
+    engine: str,
+    mode: adios2.Mode,
+    io_name: str,
+):
+    io = adios.DeclareIO(io_name)
+    io.SetEngine(engine)
+    file = io.Open(str(filename), mode)
+    try:
+        yield AdiosFile(io=io, file=file)
+    finally:
+        file.Close()
+        adios.RemoveIO(io_name)
+
+
+def read_cell_perms(
+    adios: adios2.ADIOS,
+    comm: MPI.Intracomm,
+    filename: Path | str,
+    variable: str,
+    num_cells_global: np.int64,
+    engine: str,
+) -> npt.NDArray[np.uint32]:
+    """
+    Read cell permutation from file with given communicator,
+    Split in continuous chunks based on number of cells in the mesh (global).
+
+    Args:
+        adios: The ADIOS instance
+        comm: The MPI communicator used to read the data
+        filename: Path to input file
+        variable: Name of cell-permutation variable
+        num_cells_global: Number of cells in the mesh (global)
+        engine: Type of ADIOS engine to use for reading data
+
+    Returns:
+        Cell-permutations local to the process
+
+    .. note::
+        No MPI communication is done during this call
+    """
+
+    # Open ADIOS engine
+    io_name = f"{variable=}_reader"
+
+    with ADIOSFile(
+        adios=adios,
+        engine=engine,
+        filename=filename,
+        mode=adios2.Mode.Read,
+        io_name=io_name,
+    ) as adios_file:
+        # Find step that has cell permutation
+        for i in range(adios_file.file.Steps()):
+            adios_file.file.BeginStep()
+            if variable in adios_file.io.AvailableVariables().keys():
+                break
+            adios_file.file.EndStep()
+        if variable not in adios_file.io.AvailableVariables().keys():
+            raise KeyError(f"Variable {variable} not found in '{filename}'")
+
+        # Get variable and get global shape
+        perm_var = adios_file.io.InquireVariable(variable)
+        shape = perm_var.Shape()
+        assert len(shape) == 1
+
+        # Get local selection
+        local_cell_range = compute_local_range(comm, num_cells_global)
+        perm_var.SetSelection([[local_cell_range[0]], [local_cell_range[1] - local_cell_range[0]]])
+        in_perm = np.empty(
+            local_cell_range[1] - local_cell_range[0],
+            dtype=adios_to_numpy_dtype[perm_var.Type()],
+        )
+        adios_file.file.Get(perm_var, in_perm, adios2.Mode.Sync)
+        adios_file.file.EndStep()
+
+    return in_perm
+
+
+def read_adjacency_list(
+    adios: adios2.ADIOS,
+    comm: MPI.Intracomm,
+    filename: Path | str,
+    dofmap: str,
+    dofmap_offsets: str,
+    num_cells_global: np.int64,
+    engine: str,
+) -> dolfinx.cpp.graph.AdjacencyList_int64 | dolfinx.cpp.graph.AdjacencyList_int32:
+    """
+    Read an adjacency-list from an ADIOS file with given communicator.
+    The adjancency list is split in to a flat array (data) and its corresponding offset.
+
+    Args:
+        adios: The ADIOS instance
+        comm: The MPI communicator used to read the data
+        filename: Path to input file
+        dofmap: Name of variable containing dofmap
+        dofmap_offsets: Name of variable containing dofmap_offsets
+        num_cells_global: Number of cells in the mesh (global)
+        engine: Type of ADIOS engine to use for reading data
+
+    Returns:
+        The local part of dofmap from input dofs
+
+    .. note::
+        No MPI communication is done during this call
+    """
+    local_cell_range = compute_local_range(comm, num_cells_global)
+
+    # Open ADIOS engine
+    io_name = f"{dofmap=}_reader"
+
+    with ADIOSFile(
+        adios=adios,
+        engine=engine,
+        filename=filename,
+        mode=adios2.Mode.Read,
+        io_name=io_name,
+    ) as adios_file:
+        # First find step with dofmap offsets, to be able to read
+        # in a full row of the dofmap
+        for i in range(adios_file.file.Steps()):
+            adios_file.file.BeginStep()
+            if dofmap_offsets in adios_file.io.AvailableVariables().keys():
+                break
+            adios_file.file.EndStep()
+        if dofmap_offsets not in adios_file.io.AvailableVariables().keys():
+            raise KeyError(f"Dof offsets not found at '{dofmap_offsets}' in {filename}")
+
+        # Get global shape of dofmap-offset, and read in data with an overlap
+        d_offsets = adios_file.io.InquireVariable(dofmap_offsets)
+        shape = d_offsets.Shape()
+        assert len(shape) == 1
+        # As the offsets are one longer than the number of cells, we need to read in with an overlap
+        d_offsets.SetSelection(
+            [[local_cell_range[0]], [local_cell_range[1] + 1 - local_cell_range[0]]]
+        )
+        in_offsets = np.empty(
+            local_cell_range[1] + 1 - local_cell_range[0],
+            dtype=d_offsets.Type().strip("_t"),
+        )
+        adios_file.file.Get(d_offsets, in_offsets, adios2.Mode.Sync)
+
+        # Assuming dofmap is saved in stame step
+        # Get the relevant part of the dofmap
+        if dofmap not in adios_file.io.AvailableVariables().keys():
+            raise KeyError(f"Dof offsets not found at {dofmap} in {filename}")
+        cell_dofs = adios_file.io.InquireVariable(dofmap)
+        cell_dofs.SetSelection([[in_offsets[0]], [in_offsets[-1] - in_offsets[0]]])
+        in_dofmap = np.empty(in_offsets[-1] - in_offsets[0], dtype=cell_dofs.Type().strip("_t"))
+        adios_file.file.Get(cell_dofs, in_dofmap, adios2.Mode.Sync)
+        in_offsets -= in_offsets[0]
+
+        adios_file.file.EndStep()
+
+    # Return local dofmap
+    return dolfinx.graph.adjacencylist(in_dofmap, in_offsets.astype(np.int32))
+
+
+def read_array(
+    adios: adios2.ADIOS,
+    filename: Path | str,
+    array_name: str,
+    engine: str,
+    comm: MPI.Intracomm,
+    time: float = 0.0,
+    time_name: str = "",
+    legacy: bool = False,
+) -> tuple[npt.NDArray[valid_function_types], int]:
+    """
+    Read an array from file, return the global starting position of the local array
+
+    Args:
+        adios: The ADIOS instance
+        filename: Path to file to read array from
+        array_name: Name of array in file
+        engine: Name of engine to use to read file
+        comm: MPI communicator used for reading the data
+        time_name: Name of time variable for modern checkpoints
+        legacy: If True ignore time_name and read the first available step
+    Returns:
+        Local part of array and its global starting position
+    """
+
+    with ADIOSFile(
+        adios=adios,
+        engine=engine,
+        filename=filename,
+        mode=adios2.Mode.Read,
+        io_name="ArrayReader",
+    ) as adios_file:
+        # Get time-stamp from first available step
+        if legacy:
+            for i in range(adios_file.file.Steps()):
+                adios_file.file.BeginStep()
+                if array_name in adios_file.io.AvailableVariables().keys():
+                    break
+                adios_file.file.EndStep()
+            if array_name not in adios_file.io.AvailableVariables().keys():
+                raise KeyError(f"No array found at {array_name}")
+        else:
+            for i in range(adios_file.file.Steps()):
+                adios_file.file.BeginStep()
+                if time_name in adios_file.io.AvailableVariables().keys():
+                    arr = adios_file.io.InquireVariable(time_name)
+                    time_shape = arr.Shape()
+                    arr.SetSelection([[0], [time_shape[0]]])
+                    times = np.empty(time_shape[0], dtype=adios_to_numpy_dtype[arr.Type()])
+                    adios_file.file.Get(arr, times, adios2.Mode.Sync)
+                    if times[0] == time:
+                        break
+                if i == adios_file.file.Steps() - 1:
+                    raise KeyError(
+                        f"No data associated with {time_name}={time} found in {filename}"
+                    )
+
+                adios_file.file.EndStep()
+
+            if time_name not in adios_file.io.AvailableVariables().keys():
+                raise KeyError(f"No data associated with {time_name}={time} found in {filename}")
+
+            if array_name not in adios_file.io.AvailableVariables().keys():
+                raise KeyError(f"No array found at {time=} for {array_name}")
+
+        arr = adios_file.io.InquireVariable(array_name)
+        arr_shape = arr.Shape()
+        assert len(arr_shape) >= 1  # TODO: Should we always pick the first element?
+        arr_range = compute_local_range(comm, arr_shape[0])
+
+        if len(arr_shape) == 1:
+            arr.SetSelection([[arr_range[0]], [arr_range[1] - arr_range[0]]])
+            vals = np.empty(arr_range[1] - arr_range[0], dtype=adios_to_numpy_dtype[arr.Type()])
+        else:
+            arr.SetSelection([[arr_range[0], 0], [arr_range[1] - arr_range[0], arr_shape[1]]])
+            vals = np.empty(
+                (arr_range[1] - arr_range[0], arr_shape[1]),
+                dtype=adios_to_numpy_dtype[arr.Type()],
+            )
+            assert arr_shape[1] == 1
+
+        adios_file.file.Get(arr, vals, adios2.Mode.Sync)
+        adios_file.file.EndStep()
+
+    return vals.reshape(-1), arr_range[0]