sdf-xarray 0.2.6__tar.gz → 0.3.0__tar.gz

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/CONTRIBUTING.md

@@ -33,7 +33,7 @@ To run these tools locally, install the optional dependencies and run:
 
 ```bash
 pip install "sdf-xarray[lint]"
-ruff check
+ruff check src tests
 ```
 
 ### Running and Adding Tests

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdf-xarray
-Version: 0.2.6
+Version: 0.3.0
 Summary: Provides a backend for xarray to read SDF files as created by the EPOCH plasma PIC code.
 Author-Email: Peter Hill <peter.hill@york.ac.uk>, Joel Adams <joel.adams@york.ac.uk>, Shaun Doherty <shaun.doherty@york.ac.uk>
 License-Expression: BSD-3-Clause
@@ -61,6 +61,9 @@ sdf-xarray provides a backend for [xarray](https://xarray.dev) to read SDF files
 [EPOCH](https://epochpic.github.io) using the [SDF-C](https://github.com/epochpic/SDF_C) library.
 Part of [BEAM](#broad-epoch-analysis-modules-beam) (Broad EPOCH Analysis Modules).
 
+> [!IMPORTANT]
+> To install this package make sure you are using one of the Python versions listed above.
+
 ## Installation
 
 Install from PyPI with:

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/README.md

@@ -13,6 +13,9 @@ sdf-xarray provides a backend for [xarray](https://xarray.dev) to read SDF files
 [EPOCH](https://epochpic.github.io) using the [SDF-C](https://github.com/epochpic/SDF_C) library.
 Part of [BEAM](#broad-epoch-analysis-modules-beam) (Broad EPOCH Analysis Modules).
 
+> [!IMPORTANT]
+> To install this package make sure you are using one of the Python versions listed above.
+
 ## Installation
 
 Install from PyPI with:

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/docs/conf.py

@@ -8,9 +8,9 @@ from importlib.metadata import version as get_version
 from pathlib import Path
 
 with suppress(ImportError):
-    import matplotlib
+    import matplotlib as mpl
 
-    matplotlib.use("Agg")
+    mpl.use("Agg")
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/docs/getting_started.rst

@@ -7,6 +7,15 @@
 Installation
 ------------
 
+.. |python_versions_pypi| image:: https://img.shields.io/pypi/pyversions/sdf-xarray.svg
+   :alt: Supported Python versions
+   :target: https://pypi.org/project/sdf-xarray/
+
+.. important::
+
+   To install this package, ensure that you are using one of the supported Python
+   versions: |python_versions_pypi|
+
 Install sdf-xarray from PyPI with:
 
 .. code-block:: bash
@@ -28,7 +37,7 @@ Usage
 `xarray`. There are several ways to load SDF files:
 
 - To load a single file, use :func:`xarray.open_dataset`.
-- To load multiple files, use :func:`xarray.open_mfdataset` or :func:`sdf_xarray.open_mfdataset`.
+- To load multiple files, use :func:`xarray.open_mfdataset` or :func:`sdf_xarray.open_mfdataset` (Recommended). 
 - To access the raw contents of a single SDF file, use :func:`sdf_xarray.sdf_interface.SDFFile`.
 
 .. note::
@@ -42,21 +51,32 @@ Basic usage:
 .. ipython:: python
 
     import xarray as xr
+    import sdf_xarray as sdfxr
     with xr.open_dataset("tutorial_dataset_1d/0010.sdf") as df:
         print(df["Electric_Field_Ex"])
 
 Multi file loading
 ~~~~~~~~~~~~~~~~~~
 
-To open a whole simulation at once, pass
-``preprocess=sdf_xarray.SDFPreprocess()`` to `xarray.open_mfdataset`:
+To open a whole simulation's files at once use the :func:`sdf_xarray.open_mfdataset` function:
+
+.. ipython:: python
+    
+    sdfxr.open_mfdataset("tutorial_dataset_1d/*.sdf")
+
+You can alternatively open the dataset using the xarray's :func:`xarray.open_mfdataset`
+along with the ``preprocess=sdfxr.SDFPreprocess()``:
 
 .. ipython:: python
 
-    from sdf_xarray import SDFPreprocess
-    xr.open_mfdataset("tutorial_dataset_1d/*.sdf", preprocess=SDFPreprocess())
+    xr.open_mfdataset(
+        "tutorial_dataset_1d/*.sdf",
+        join="outer",
+        compat="no_conflicts",
+        preprocess=sdfxr.SDFPreprocess()
+    )
 
-`SDFPreprocess` checks that all the files are from the same simulation, and
+:class:`sdf_xarray.SDFPreprocess` checks that all the files are from the same simulation, and
 ensures there's a ``time`` dimension so the files are correctly concatenated.
 
 If your simulation has multiple ``output`` blocks so that not all variables are
@@ -64,12 +84,11 @@ output at every time step, then those variables will have ``NaN`` values at the
 corresponding time points.
 
 Alternatively, we can create a separate time dimensions for each ``output``
-block using `sdf_xarray.open_mfdataset` with ``separate_times=True``:
+block using :func:`sdf_xarray.open_mfdataset` with ``separate_times=True``:
 
 .. ipython:: python
 
-    from sdf_xarray import open_mfdataset
-    open_mfdataset("tutorial_dataset_1d/*.sdf", separate_times=True)
+    sdfxr.open_mfdataset("tutorial_dataset_1d/*.sdf", separate_times=True)
 
 This is better for memory consumption, at the cost of perhaps slightly less
 friendly comparisons between variables on different time coordinates.

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/docs/key_functionality.rst

@@ -6,17 +6,17 @@ Key Functionality
 
 .. ipython:: python
 
+   import xarray as xr
+   import sdf_xarray as sdfxr
    import matplotlib.pyplot as plt
    from IPython.display import display, HTML
-   import xarray as xr
-   from sdf_xarray import SDFFile, SDFPreprocess
 
 Loading SDF Files
 -----------------
 There are several ways to load SDF files:
 
 - To load a single file, use :func:`xarray.open_dataset`.
-- To load multiple files, use :func:`xarray.open_mfdataset` or :func:`sdf_xarray.open_mfdataset`.
+- To load multiple files, use :func:`sdf_xarray.open_mfdataset` or :func:`xarray.open_mfdataset`.
 - To access the raw contents of a single SDF file, use :func:`sdf_xarray.sdf_interface.SDFFile`.
 
 .. note::
@@ -34,28 +34,48 @@ Loading a Single Raw SDF File
 
 .. ipython:: python
 
-   with SDFFile("tutorial_dataset_1d/0010.sdf") as sdf_file:
+   with sdfxr.SDFFile("tutorial_dataset_1d/0010.sdf") as sdf_file:
       print(sdf_file.variables)
 
 Loading all SDF Files for a Simulation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-When loading in all the files we have do some processing of the data
+Multiple files can be loaded using one of two methods. The first of which
+is by using the :func:`sdf_xarray.open_mfdataset`
+
+.. ipython:: python
+
+   sdfxr.open_mfdataset("tutorial_dataset_1d/*.sdf")
+
+Alternatively files can be loaded using :func:`xarray.open_mfdataset`
+however when loading in all the files we have do some processing of the data
 so that we can correctly align it along the time dimension; This is
 done via the ``preprocess`` parameter.
 
 .. ipython:: python
 
-   xr.open_mfdataset("tutorial_dataset_1d/*.sdf", preprocess=SDFPreprocess())
+   xr.open_mfdataset(
+      "tutorial_dataset_1d/*.sdf",
+      join="outer",
+      compat="no_conflicts",
+      preprocess=sdfxr.SDFPreprocess())
 
 Reading particle data
 ~~~~~~~~~~~~~~~~~~~~~
 
 .. warning::
-   It is **not recommended** to use :func:`xarray.open_mfdataset` or :func:`open_mfdataset` to load particle data from multiple SDF outputs. The number of particles often varies between outputs, which can lead to inconsistent array shapes that these functions cannot handle. Instead, consider loading each file individually and then concatenating them manually.
+   It is **not recommended** to use :func:`xarray.open_mfdataset` or
+   :func:`sdf_xarray.open_mfdataset` to load particle data from multiple
+   SDF outputs. The number of particles often varies between outputs,
+   which can lead to inconsistent array shapes that these functions
+   cannot handle. Instead, consider loading each file individually and
+   then concatenating them manually.
 
 .. note::
-   When loading multiple probes from a single SDF file, you **must** use the `probe_names` parameter to assign a unique name to each. For example, use `probe_names=["Front_Electron_Probe", "Back_Electron_Probe"]`. Failing to do so will result in dimension name conflicts.
+   When loading multiple probes from a single SDF file, you **must** use the
+   ``probe_names`` parameter to assign a unique name to each. For example,
+   use ``probe_names=["Front_Electron_Probe", "Back_Electron_Probe"]``.
+   Failing to do so will result in dimension name conflicts.
 
 By default, particle data isn't kept as it takes up a lot of space.
 Pass ``keep_particles=True`` as a keyword argument to
@@ -85,7 +105,7 @@ looking at when you call ``.values``
 
 .. ipython:: python
 
-   ds = xr.open_mfdataset("tutorial_dataset_1d/*.sdf", preprocess=SDFPreprocess())
+   ds = sdfxr.open_mfdataset("tutorial_dataset_1d/*.sdf")
 
    ds["Electric_Field_Ex"]
 

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/docs/unit_conversion.rst

@@ -38,8 +38,7 @@ import, the ``xarray.Dataset.pint`` accessor will not be initialised.
 
 .. ipython:: python
 
-    import xarray as xr
-    from sdf_xarray import SDFPreprocess
+    from sdf_xarray import open_mfdataset
     import pint_xarray
 
 In the following example we will extract the time-resolved total particle
@@ -72,7 +71,7 @@ be removed.
 
 .. ipython:: python
 
-    with xr.open_mfdataset("tutorial_dataset_1d/*.sdf", preprocess=SDFPreprocess()) as ds:
+    with open_mfdataset("tutorial_dataset_1d/*.sdf") as ds:
         total_particle_energy = ds["Total_Particle_Energy_Electron"]
 
     total_particle_energy

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/src/sdf_xarray/__init__.py

@@ -2,12 +2,15 @@ import os
 import re
 from collections import Counter, defaultdict
 from collections.abc import Callable, Iterable
+from importlib.metadata import version
 from itertools import product
+from os import PathLike as os_PathLike
 from pathlib import Path
 from typing import ClassVar
 
 import numpy as np
 import xarray as xr
+from packaging.version import Version
 from xarray.backends import AbstractDataStore, BackendArray, BackendEntrypoint
 from xarray.backends.file_manager import CachingFileManager
 from xarray.backends.locks import ensure_lock
@@ -21,6 +24,12 @@ import sdf_xarray.plotting  # noqa: F401
 
 from .sdf_interface import Constant, SDFFile  # type: ignore  # noqa: PGH003
 
+# TODO Remove this once the new kwarg options are fully implemented
+if Version(version("xarray")) >= Version("2025.8.0"):
+    xr.set_options(use_new_combine_kwarg_defaults=True)
+
+PathLike = str | os_PathLike
+
 
 def _rename_with_underscore(name: str) -> str:
     """A lot of the variable names have spaces, forward slashes and dashes in them, which
@@ -51,14 +60,32 @@ def _process_latex_name(variable_name: str) -> str:
     return variable_name
 
 
+def _resolve_glob(path_glob: PathLike | Iterable[PathLike]):
+    """
+    Normalise input path_glob into a sorted list of absolute, resolved Path objects.
+    """
+
+    try:
+        p = Path(path_glob)
+        paths = list(p.parent.glob(p.name)) if p.name == "*.sdf" else list(p)
+    except TypeError:
+        paths = list({Path(p) for p in path_glob})
+
+    paths = sorted(p.resolve() for p in paths)
+    if not paths:
+        raise FileNotFoundError(f"No files matched pattern or input: {path_glob!r}")
+    return paths
+
+
 def combine_datasets(path_glob: Iterable | str, **kwargs) -> xr.Dataset:
     """Combine all datasets using a single time dimension"""
 
     return xr.open_mfdataset(
         path_glob,
-        data_vars="minimal",
-        coords="minimal",
-        compat="override",
+        data_vars="all",
+        coords="different",
+        compat="no_conflicts",
+        join="outer",
         preprocess=SDFPreprocess(),
         **kwargs,
     )
@@ -103,19 +130,13 @@ def open_mfdataset(
         List of EPOCH probe names
     """
 
-    # TODO: This is not very robust, look at how xarray.open_mfdataset does it
-    if isinstance(path_glob, str):
-        path_glob = Path().glob(path_glob)
-
-    # Coerce to list because we might need to use the sequence multiple times
-    path_glob = sorted(list(path_glob))  # noqa: C414
-
+    path_glob = _resolve_glob(path_glob)
     if not separate_times:
         return combine_datasets(
             path_glob, keep_particles=keep_particles, probe_names=probe_names
         )
 
-    time_dims, var_times_map = make_time_dims(path_glob)
+    _, var_times_map = make_time_dims(path_glob)
     all_dfs = [
         xr.open_dataset(f, keep_particles=keep_particles, probe_names=probe_names)
         for f in path_glob
@@ -136,7 +157,12 @@ def open_mfdataset(
                 )
 
     return xr.combine_by_coords(
-        all_dfs, data_vars="minimal", combine_attrs="drop_conflicts"
+        all_dfs,
+        data_vars="all",
+        coords="different",
+        combine_attrs="drop_conflicts",
+        join="outer",
+        compat="no_conflicts",
     )
 
 

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/src/sdf_xarray/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.6'
-__version_tuple__ = version_tuple = (0, 2, 6)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
 
-__commit_id__ = commit_id = 'g67411803b'
+__commit_id__ = commit_id = 'gcca942b3f'

{sdf_xarray-0.2.6 → sdf_xarray-0.3.0}/tests/test_basic.py

@@ -1,9 +1,11 @@
 import pathlib
 
+import numpy as np
+import numpy.testing as npt
 import pytest
 import xarray as xr
 
-from sdf_xarray import SDFPreprocess, _process_latex_name, open_mfdataset
+from sdf_xarray import SDFPreprocess, _process_latex_name, _resolve_glob, open_mfdataset
 
 EXAMPLE_FILES_DIR = pathlib.Path(__file__).parent / "example_files_1D"
 EXAMPLE_MISMATCHED_FILES_DIR = (
@@ -84,6 +86,70 @@ def test_multiple_files_one_time_dim():
         assert tuple(absorption.coords) == ("time",)
         assert absorption.shape == (11,)
 
+        time = df["time"]
+        ex = df.isel(time=10)["Electric_Field_Ex"]
+        ex_values = ex.values
+        ex_x_coords = ex.coords["X_Grid_mid"].values
+        time_values = np.array(
+            [
+                5.466993e-14,
+                2.417504e-10,
+                4.833915e-10,
+                7.251419e-10,
+                9.667830e-10,
+                1.208533e-09,
+                1.450175e-09,
+                1.691925e-09,
+                1.933566e-09,
+                2.175316e-09,
+                2.416958e-09,
+            ]
+        )
+
+        expected_ex = np.array(
+            [
+                -3126528.47057157754898071289062500000000,
+                -3249643.37612255383282899856567382812500,
+                -6827013.11566223856061697006225585937500,
+                -9350267.99022011645138263702392578125000,
+                -1643592.58487333403900265693664550781250,
+                -2044751.41207189299166202545166015625000,
+                -4342811.34666103497147560119628906250000,
+                -10420841.38402196019887924194335937500000,
+                -7038801.83154528774321079254150390625000,
+                781649.31791684380732476711273193359375,
+                4476555.84853181242942810058593750000000,
+                5873312.79385650344192981719970703125000,
+                -95930.60501570138148963451385498046875,
+                -8977898.96547995693981647491455078125000,
+                -7951712.64987809769809246063232421875000,
+                -5655667.11171338520944118499755859375000,
+            ]
+        )
+        expected_ex_coords = np.array(
+            [
+                1.72522447e-05,
+                5.17567340e-05,
+                8.62612233e-05,
+                1.20765713e-04,
+                1.55270202e-04,
+                1.89774691e-04,
+                2.24279181e-04,
+                2.58783670e-04,
+                2.93288159e-04,
+                3.27792649e-04,
+                3.62297138e-04,
+                3.96801627e-04,
+                4.31306117e-04,
+                4.65810606e-04,
+                5.00315095e-04,
+                5.34819585e-04,
+            ]
+        )
+        npt.assert_allclose(time_values, time.values, rtol=1e-6)
+        npt.assert_allclose(ex_values, expected_ex)
+        npt.assert_allclose(ex_x_coords, expected_ex_coords)
+
 
 def test_multiple_files_multiple_time_dims():
     with open_mfdataset(
@@ -99,7 +165,59 @@ def test_multiple_files_multiple_time_dims():
         assert df["Absorption_Total_Laser_Energy_Injected"].shape == (11,)
 
 
-def test_erroring_on_mismatched_jobid_files():
+def test_resolve_glob_from_string_pattern():
+    pattern = str(EXAMPLE_FILES_DIR / "*.sdf")
+    result = _resolve_glob(pattern)
+    expected = sorted(EXAMPLE_FILES_DIR.glob("*.sdf"))
+    assert result == expected
+
+
+def test_resolve_glob_from_path_glob():
+    pattern = EXAMPLE_FILES_DIR.glob("*.sdf")
+    result = _resolve_glob(pattern)
+    expected = sorted(EXAMPLE_FILES_DIR.glob("*.sdf"))
+    assert result == expected
+
+
+def test_resolve_glob_from_path_missing_glob():
+    pattern = EXAMPLE_FILES_DIR
+    with pytest.raises(TypeError):
+        _resolve_glob(pattern)
+
+
+def test_resolve_glob_from_path_list():
+    pattern = [EXAMPLE_FILES_DIR / "0000.sdf"]
+    result = _resolve_glob(pattern)
+    expected = [EXAMPLE_FILES_DIR / "0000.sdf"]
+    assert result == expected
+
+
+def test_resolve_glob_from_path_list_multiple():
+    pattern = [EXAMPLE_FILES_DIR / "0000.sdf", EXAMPLE_FILES_DIR / "0001.sdf"]
+    result = _resolve_glob(pattern)
+    expected = [EXAMPLE_FILES_DIR / "0000.sdf", EXAMPLE_FILES_DIR / "0001.sdf"]
+    assert result == expected
+
+
+def test_resolve_glob_from_path_list_multiple_unordered():
+    pattern = [EXAMPLE_FILES_DIR / "0001.sdf", EXAMPLE_FILES_DIR / "0000.sdf"]
+    result = _resolve_glob(pattern)
+    expected = [EXAMPLE_FILES_DIR / "0000.sdf", EXAMPLE_FILES_DIR / "0001.sdf"]
+    assert result == expected
+
+
+def test_resolve_glob_from_path_list_multiple_duplicates():
+    pattern = [
+        EXAMPLE_FILES_DIR / "0000.sdf",
+        EXAMPLE_FILES_DIR / "0000.sdf",
+        EXAMPLE_FILES_DIR / "0001.sdf",
+    ]
+    result = _resolve_glob(pattern)
+    expected = [EXAMPLE_FILES_DIR / "0000.sdf", EXAMPLE_FILES_DIR / "0001.sdf"]
+    assert result == expected
+
+
+def test_xr_erroring_on_mismatched_jobid_files():
     with pytest.raises(ValueError):  # noqa: PT011
         xr.open_mfdataset(
             EXAMPLE_MISMATCHED_FILES_DIR.glob("*.sdf"),
@@ -107,22 +225,100 @@ def test_erroring_on_mismatched_jobid_files():
             data_vars="minimal",
             coords="minimal",
             compat="override",
+            join="outer",
             preprocess=SDFPreprocess(),
         )
 
 
-def test_time_dim_units():
+def test_xr_multiple_files_data():
+    with xr.open_mfdataset(
+        EXAMPLE_FILES_DIR.glob("*.sdf"),
+        compat="no_conflicts",
+        join="outer",
+        preprocess=SDFPreprocess(),
+    ) as df:
+        ex = df.isel(time=10)["Electric_Field_Ex"]
+        ex_values = ex.values
+        ex_x_coords = ex.coords["X_Grid_mid"].values
+
+        expected_ex = np.array(
+            [
+                -3126528.47057157754898071289062500000000,
+                -3249643.37612255383282899856567382812500,
+                -6827013.11566223856061697006225585937500,
+                -9350267.99022011645138263702392578125000,
+                -1643592.58487333403900265693664550781250,
+                -2044751.41207189299166202545166015625000,
+                -4342811.34666103497147560119628906250000,
+                -10420841.38402196019887924194335937500000,
+                -7038801.83154528774321079254150390625000,
+                781649.31791684380732476711273193359375,
+                4476555.84853181242942810058593750000000,
+                5873312.79385650344192981719970703125000,
+                -95930.60501570138148963451385498046875,
+                -8977898.96547995693981647491455078125000,
+                -7951712.64987809769809246063232421875000,
+                -5655667.11171338520944118499755859375000,
+            ]
+        )
+        expected_ex_coords = np.array(
+            [
+                1.72522447e-05,
+                5.17567340e-05,
+                8.62612233e-05,
+                1.20765713e-04,
+                1.55270202e-04,
+                1.89774691e-04,
+                2.24279181e-04,
+                2.58783670e-04,
+                2.93288159e-04,
+                3.27792649e-04,
+                3.62297138e-04,
+                3.96801627e-04,
+                4.31306117e-04,
+                4.65810606e-04,
+                5.00315095e-04,
+                5.34819585e-04,
+            ]
+        )
+        npt.assert_allclose(ex_values, expected_ex)
+        npt.assert_allclose(ex_x_coords, expected_ex_coords)
+
+
+def test_xr_time_dim():
     with xr.open_mfdataset(
-        EXAMPLE_ARRAYS_DIR.glob("*.sdf"), preprocess=SDFPreprocess()
+        EXAMPLE_FILES_DIR.glob("*.sdf"),
+        join="outer",
+        preprocess=SDFPreprocess(),
     ) as df:
-        assert df["time"].units == "s"
-        assert df["time"].long_name == "Time"
-        assert df["time"].full_name == "time"
+        time = df["time"]
+        assert time.units == "s"
+        assert time.long_name == "Time"
+        assert time.full_name == "time"
+
+        time_values = np.array(
+            [
+                5.466993e-14,
+                2.417504e-10,
+                4.833915e-10,
+                7.251419e-10,
+                9.667830e-10,
+                1.208533e-09,
+                1.450175e-09,
+                1.691925e-09,
+                1.933566e-09,
+                2.175316e-09,
+                2.416958e-09,
+            ]
+        )
+
+        npt.assert_allclose(time_values, time.values, rtol=1e-6)
 
 
-def test_latex_rename_variables():
+def test_xr_latex_rename_variables():
     with xr.open_mfdataset(
         EXAMPLE_ARRAYS_DIR.glob("*.sdf"),
+        join="outer",
         preprocess=SDFPreprocess(),
         keep_particles=True,
     ) as df:
@@ -158,7 +354,7 @@ def test_latex_rename_variables():
         )
 
 
-def test_arrays_with_no_grids():
+def test_xr_arrays_with_no_grids():
     with xr.open_dataset(EXAMPLE_ARRAYS_DIR / "0001.sdf") as df:
         laser_phase = "laser_x_min_phase"
         assert laser_phase in df
@@ -169,9 +365,11 @@ def test_arrays_with_no_grids():
         assert df[random_states].shape == (8,)
 
 
-def test_arrays_with_no_grids_multifile():
+def test_xr_arrays_with_no_grids_multifile():
     with xr.open_mfdataset(
-        EXAMPLE_ARRAYS_DIR.glob("*.sdf"), preprocess=SDFPreprocess()
+        EXAMPLE_ARRAYS_DIR.glob("*.sdf"),
+        join="outer",
+        preprocess=SDFPreprocess(),
     ) as df:
         laser_phase = "laser_x_min_phase"
         assert laser_phase in df
@@ -182,20 +380,20 @@ def test_arrays_with_no_grids_multifile():
         assert df[random_states].shape == (2, 8)
 
 
-def test_3d_distribution_function():
+def test_xr_3d_distribution_function():
     with xr.open_dataset(EXAMPLE_3D_DIST_FN / "0000.sdf") as df:
         distribution_function = "dist_fn_x_px_py_Electron"
         assert df[distribution_function].shape == (16, 20, 20)
 
 
-def test_drop_variables():
+def test_xr_drop_variables():
     with xr.open_dataset(
         EXAMPLE_FILES_DIR / "0000.sdf", drop_variables=["Electric_Field_Ex"]
     ) as df:
         assert "Electric_Field_Ex" not in df
 
 
-def test_drop_variables_multiple():
+def test_xr_drop_variables_multiple():
     with xr.open_dataset(
         EXAMPLE_FILES_DIR / "0000.sdf",
         drop_variables=["Electric_Field_Ex", "Electric_Field_Ey"],
@@ -204,7 +402,7 @@ def test_drop_variables_multiple():
         assert "Electric_Field_Ey" not in df
 
 
-def test_drop_variables_original():
+def test_xr_drop_variables_original():
     with xr.open_dataset(
         EXAMPLE_FILES_DIR / "0000.sdf",
         drop_variables=["Electric_Field/Ex", "Electric_Field/Ey"],
@@ -213,7 +411,7 @@ def test_drop_variables_original():
         assert "Electric_Field_Ey" not in df
 
 
-def test_drop_variables_mixed():
+def test_xr_drop_variables_mixed():
     with xr.open_dataset(
         EXAMPLE_FILES_DIR / "0000.sdf",
         drop_variables=["Electric_Field/Ex", "Electric_Field_Ey"],
@@ -222,14 +420,14 @@ def test_drop_variables_mixed():
         assert "Electric_Field_Ey" not in df
 
 
-def test_erroring_drop_variables():
+def test_xr_erroring_drop_variables():
     with pytest.raises(KeyError):
         xr.open_dataset(
             EXAMPLE_FILES_DIR / "0000.sdf", drop_variables=["Electric_Field/E"]
         )
 
 
-def test_loading_multiple_probes():
+def test_xr_loading_multiple_probes():
     with xr.open_dataset(
         EXAMPLE_2D_PARTICLE_DATA / "0002.sdf",
         keep_particles=True,
@@ -241,7 +439,7 @@ def test_loading_multiple_probes():
         assert "ID_Electron_Back_Probe_Px" in df.dims
 
 
-def test_loading_one_probe_drop_second_probe():
+def test_xr_oading_one_probe_drop_second_probe():
     with xr.open_dataset(
         EXAMPLE_2D_PARTICLE_DATA / "0002.sdf",
         keep_particles=True,