sdf-xarray 0.2.2__cp312-cp312-win_amd64.whl → 0.2.4__cp312-cp312-win_amd64.whl

sdf_xarray/__init__.py

@@ -310,6 +310,8 @@ class SDFDataStore(AbstractDataStore):
             # Had some problems with these variables, so just ignore them for now
             if "cpu" in key.lower():
                 continue
+            if "boundary" in key.lower():
+                continue
             if "output file" in key.lower():
                 continue
 

sdf_xarray/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.2'
-__version_tuple__ = version_tuple = (0, 2, 2)
+__version__ = version = '0.2.4'
+__version_tuple__ = version_tuple = (0, 2, 4)

sdf_xarray/plotting.py

@@ -10,60 +10,82 @@ if TYPE_CHECKING:
     from matplotlib.animation import FuncAnimation
 
 
-def get_frame_title(data: xr.DataArray, frame: int, display_sdf_name: bool) -> str:
+def get_frame_title(
+    data: xr.DataArray,
+    frame: int,
+    display_sdf_name: bool = False,
+    title_custom: str | None = None,
+) -> str:
     """Generate the title for a frame"""
-    sdf_name = f", {frame:04d}.sdf" if display_sdf_name else ""
+    # Adds custom text to the start of the title, if specified
+    title_custom = "" if title_custom is None else f"{title_custom}, "
+    # Adds the time and associated units to the title
     time = data["time"][frame].to_numpy()
-    return f"t = {time:.2e}s{sdf_name}"
 
+    time_units = data["time"].attrs.get("units", False)
+    time_units_formatted = f" [{time_units}]" if time_units else ""
+    title_time = f"time = {time:.2e}{time_units_formatted}"
 
-def calculate_window_velocity_and_edges(
-    data: xr.DataArray, x_axis_coord: str
-) -> tuple[float, tuple[float, float], np.ndarray]:
-    """Calculate the moving window's velocity and initial edges.
+    # Adds sdf name to the title, if specifed
+    title_sdf = f", {frame:04d}.sdf" if display_sdf_name else ""
+    return f"{title_custom}{title_time}{title_sdf}"
 
-    1. Finds a lineout of the target atribute in the x coordinate of the first frame
-    2. Removes the NaN values to isolate the simulation window
-    3. Produces the index size of the window, indexed at zero
-    4. Uses distance moved and final time of the simulation to calculate velocity and initial xlims
-    """
-    time_since_start = data["time"].values - data["time"].values[0]
-    initial_window_edge = (0, 0)
-    target_lineout = data.values[0, :, 0]
-    target_lineout_window = target_lineout[~np.isnan(target_lineout)]
-    x_grid = data[x_axis_coord].values
-    window_size_index = target_lineout_window.size - 1
 
-    velocity_window = (x_grid[-1] - x_grid[window_size_index]) / time_since_start[-1]
-    initial_window_edge = (x_grid[0], x_grid[window_size_index])
-    return velocity_window, initial_window_edge, time_since_start
+def calculate_window_boundaries(
+    data: xr.DataArray, xlim: tuple[float, float] | False = False
+) -> np.ndarray:
+    """Calculate the bounderies a moving window frame. If the user specifies xlim, this will
+    be used as the initial bounderies and the window will move along acordingly.
+    """
+    x_grid = data["X_Grid_mid"].values
+    x_half_cell = (x_grid[1] - x_grid[0]) / 2
+    N_frames = data["time"].size
 
+    # Find the window bounderies by finding the first and last non-NaN values in the 0th lineout
+    # along the x-axis.
+    window_boundaries = np.zeros((N_frames, 2))
+    for i in range(N_frames):
+        # Check if data is 1D
+        if data.ndim == 2:
+            target_lineout = data[i].values
+        # Check if data is 2D
+        if data.ndim == 3:
+            target_lineout = data[i, :, 0].values
+        x_grid_non_nan = x_grid[~np.isnan(target_lineout)]
+        window_boundaries[i, 0] = x_grid_non_nan[0] - x_half_cell
+        window_boundaries[i, 1] = x_grid_non_nan[-1] + x_half_cell
 
-def compute_global_limits(data: xr.DataArray) -> tuple[float, float]:
-    """Remove all NaN values from the target data to calculate the 1st and 99th percentiles,
-    excluding extreme outliers.
-    """
-    values_no_nan = data.values[~np.isnan(data.values)]
-    global_min = np.percentile(values_no_nan, 1)
-    global_max = np.percentile(values_no_nan, 99)
-    return global_min, global_max
+    # User's choice for initial window edge supercides the one calculated
+    if xlim:
+        window_boundaries = window_boundaries + xlim - window_boundaries[0]
+    return window_boundaries
 
 
-def is_1d(data: xr.DataArray) -> bool:
-    """Check if the data is 1D."""
-    return len(data.shape) == 2
+def compute_global_limits(
+    data: xr.DataArray,
+    min_percentile: float = 0,
+    max_percentile: float = 100,
+) -> tuple[float, float]:
+    """Remove all NaN values from the target data to calculate the global minimum and maximum of the data.
+    User defined percentiles can remove extreme outliers.
+    """
 
+    # Removes NaN values, needed for moving windows
+    values_no_nan = data.values[~np.isnan(data.values)]
 
-def is_2d(data: xr.DataArray) -> bool:
-    """Check if the data is 2D or 3D."""
-    return len(data.shape) == 3
+    # Finds the global minimum and maximum of the plot, based on the percentile of the data
+    global_min = np.percentile(values_no_nan, min_percentile)
+    global_max = np.percentile(values_no_nan, max_percentile)
+    return global_min, global_max
 
 
-def generate_animation(
+def animate(
     data: xr.DataArray,
+    fps: float = 10,
+    min_percentile: float = 0,
+    max_percentile: float = 100,
+    title: str | None = None,
     display_sdf_name: bool = False,
-    fps: int = 10,
-    move_window: bool = False,
     ax: plt.Axes | None = None,
     **kwargs,
 ) -> FuncAnimation:
@@ -71,17 +93,18 @@ def generate_animation(
 
     Parameters
     ---------
-    dataset
-        The dataset containing the simulation data
-    target_attribute
-        The attribute to plot for each timestep
-    display_sdf_name
-        Display the sdf file name in the animation title
+    data
+        The dataarray containing the target data
     fps
         Frames per second for the animation (default: 10)
-    move_window
-        If the simulation has a moving window, the animation will move along
-        with it (default: False)
+    min_percentile
+        Minimum percentile of the data (default: 0)
+    max_percentile
+        Maximum percentile of the data (default: 100)
+    title
+        Custom title to add to the plot.
+    display_sdf_name
+        Display the sdf file name in the animation title
     ax
         Matplotlib axes on which to plot.
     kwargs
@@ -89,18 +112,28 @@ def generate_animation(
 
     Examples
     --------
-    >>> generate_animation(dataset["Derived_Number_Density_Electron"])
+    >>> dataset["Derived_Number_Density_Electron"].epoch.animate()
     """
     import matplotlib.pyplot as plt
     from matplotlib.animation import FuncAnimation
 
+    kwargs_original = kwargs.copy()
+
     if ax is None:
         _, ax = plt.subplots()
 
     N_frames = data["time"].size
-    global_min, global_max = compute_global_limits(data)
+    global_min, global_max = compute_global_limits(data, min_percentile, max_percentile)
+
+    # Initialise plot and set y-limits for 1D data
+    if data.ndim == 2:
+        kwargs.setdefault("x", "X_Grid_mid")
+        plot = data.isel(time=0).plot(ax=ax, **kwargs)
+        ax.set_title(get_frame_title(data, 0, display_sdf_name, title))
+        ax.set_ylim(global_min, global_max)
 
-    if is_2d(data):
+    # Initilise plot and set colour bar for 2D data
+    if data.ndim == 3:
         kwargs["norm"] = plt.Normalize(vmin=global_min, vmax=global_max)
         kwargs["add_colorbar"] = False
         # Set default x and y coordinates for 2D data if not provided
@@ -109,44 +142,32 @@ def generate_animation(
 
         # Initialize the plot with the first timestep
         plot = data.isel(time=0).plot(ax=ax, **kwargs)
-        ax.set_title(get_frame_title(data, 0, display_sdf_name))
+        ax.set_title(get_frame_title(data, 0, display_sdf_name, title))
 
         # Add colorbar
-        long_name = data.attrs.get("long_name")
-        units = data.attrs.get("units")
-        plt.colorbar(plot, ax=ax, label=f"{long_name} [${units}$]")
-
-    # Initialise plo and set y-limits for 1D data
-    if is_1d(data):
-        plot = data.isel(time=0).plot(ax=ax, **kwargs)
-        ax.set_title(get_frame_title(data, 0, display_sdf_name))
-        ax.set_ylim(global_min, global_max)
+        if kwargs_original.get("add_colorbar", True):
+            long_name = data.attrs.get("long_name")
+            units = data.attrs.get("units")
+            plt.colorbar(plot, ax=ax, label=f"{long_name} [${units}$]")
 
+    # check if there is a moving window by finding NaNs in the data
+    move_window = np.isnan(np.sum(data.values))
     if move_window:
-        window_velocity, window_initial_edge, time_since_start = (
-            calculate_window_velocity_and_edges(data, kwargs["x"])
-        )
-
-    # User's choice for initial window edge supercides the one calculated
-    if "xlim" in kwargs:
-        window_initial_edge = kwargs["xlim"]
+        window_boundaries = calculate_window_boundaries(data, kwargs.get("xlim", False))
 
     def update(frame):
         # Set the xlim for each frame in the case of a moving window
         if move_window:
-            kwargs["xlim"] = (
-                window_initial_edge[0] + window_velocity * time_since_start[frame],
-                window_initial_edge[1] * 0.99
-                + window_velocity * time_since_start[frame],
-            )
+            kwargs["xlim"] = window_boundaries[frame]
 
         # Update plot for the new frame
         ax.clear()
+
         data.isel(time=frame).plot(ax=ax, **kwargs)
-        ax.set_title(get_frame_title(data, frame, display_sdf_name))
+        ax.set_title(get_frame_title(data, frame, display_sdf_name, title))
 
-        # # Update y-limits for 1D data
-        if is_1d(data):
+        # Update y-limits for 1D data
+        if data.ndim == 2:
             ax.set_ylim(global_min, global_max)
 
     return FuncAnimation(
@@ -181,4 +202,4 @@ class EpochAccessor:
         >>> ani = ds["Electric_Field_Ey"].epoch.animate()
         >>> ani.save("myfile.mp4")
         """
-        return generate_animation(self._obj, *args, **kwargs)
+        return animate(self._obj, *args, **kwargs)

sdf_xarray/sdf_interface.pyx

@@ -39,7 +39,7 @@ cdef class Block:
 
 @dataclasses.dataclass
 cdef class Variable(Block):
-    units: tuple[str] | None
+    units: str | None
     mult: float | None
     grid: str | None
     grid_mid: str | None

{sdf_xarray-0.2.2.dist-info → sdf_xarray-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sdf-xarray
-Version: 0.2.2
+Version: 0.2.4
 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: Copyright 2024, Peter Hill, Joel Adams, epochpic team
@@ -32,11 +32,19 @@ License: Copyright 2024, Peter Hill, Joel Adams, epochpic team
          (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
          
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: xarray>=2024.1.0
 Requires-Dist: dask>=2024.7.1
-Requires-Dist: cython>=3.0
 Provides-Extra: docs
 Requires-Dist: sphinx>=5.3; extra == "docs"
 Requires-Dist: sphinx_autodoc_typehints>=1.19; extra == "docs"
@@ -67,9 +75,14 @@ Description-Content-Type: text/markdown
 
 # sdf-xarray
 
-![PyPI](https://img.shields.io/pypi/v/sdf-xarray?color=blue)
+![Dynamic TOML Badge](https://img.shields.io/badge/dynamic/toml?url=https%3A%2F%2Fraw.githubusercontent.com%2Fepochpic%2Fsdf-xarray%2Frefs%2Fheads%2Fmain%2Fpyproject.toml&query=%24.project.requires-python&label=python&logo=python)
+[![Available on PyPI](https://img.shields.io/pypi/v/sdf-xarray?color=blue&logo=pypi)](https://pypi.org/project/sdf-xarray/)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.15351323.svg)](https://doi.org/10.5281/zenodo.15351323)
 ![Build/Publish](https://github.com/epochpic/sdf-xarray/actions/workflows/build_publish.yml/badge.svg)
 ![Tests](https://github.com/epochpic/sdf-xarray/actions/workflows/tests.yml/badge.svg)
+[![Read the Docs](https://img.shields.io/readthedocs/sdf-xarray?logo=readthedocs&link=https%3A%2F%2Fsdf-xarray.readthedocs.io%2F)](https://sdf-xarray.readthedocs.io)
+[![Formatted with black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
+
 
 sdf-xarray provides a backend for [xarray](https://xarray.dev) to read SDF files as created by
 [EPOCH](https://epochpic.github.io) using the [SDF-C](https://github.com/epochpic/SDF_C) library.

{sdf_xarray-0.2.2.dist-info → sdf_xarray-0.2.4.dist-info}/RECORD

@@ -6,19 +6,19 @@ include/SDFC_14.4.7/sdf_list_type.h,sha256=Quu8v0-SEsQuJpGtEZnm09tAyXqWNitx0sXl5
 include/SDFC_14.4.7/sdf_vector_type.h,sha256=dbKjhzRRsvhzrnTwVjtVlvnuisEnRMKY-vvdm94ok_Q,1595
 include/SDFC_14.4.7/stack_allocator.h,sha256=L7U9vmGiVSw3VQLIv9EzTaVq7JbFxs9aNonKStTkUSg,1335
 include/SDFC_14.4.7/uthash.h,sha256=rIyy_-ylY6S_7WaZCCC3VtvXaC9q37rFyA0f1U9xc4w,63030
-lib/SDFC_14.4.7/sdfc.lib,sha256=aQ_GV-hDgqP7AbGSjuEpkj7Z5zpUd-C5_567JJeZ1yk,350410
+lib/SDFC_14.4.7/sdfc.lib,sha256=DhpyA_nvLlofl1uM9klwcs3syjPQzAzBvhGIn7ioeho,350410
 lib/SDFC_14.4.7/SDFCConfig.cmake,sha256=IOA1eusC-KvUK4LNTEiOAmEdaPH1ZvNvbYPgiG1oZio,802
 lib/SDFC_14.4.7/SDFCConfigVersion.cmake,sha256=pN7Qqyf04s3izw7PYQ0XK6imvmhaVegSdR_nEl3Ok_o,2830
 lib/SDFC_14.4.7/SDFCTargets-release.cmake,sha256=G4zdx5PyjePigeD_a6rmZAxbk7L8Nf0klUnV78Lm2fI,828
 lib/SDFC_14.4.7/SDFCTargets.cmake,sha256=OVt1Gm8n7Ew4fiTmA9yHoef3vIIGwsXUZfqeG9p9Bys,4152
-sdf_xarray/__init__.py,sha256=fJz9_MEcXjGAuZusNY6S3CDZmCJOg_Gjpzl1R-hAfmw,17573
-sdf_xarray/_version.py,sha256=UC90NvqLUDpj_FE8q0wCmEOBTFqTc2wo52DnLF1e7lU,532
+sdf_xarray/__init__.py,sha256=bPzOJwcKQAsx-mryOyxOCXHijA4nr5ayZWPRrMNNuMU,17642
+sdf_xarray/_version.py,sha256=4HOJxLsEz0nPHMraGaR2KjWuypKklVh7NijIwVz3nSg,532
 sdf_xarray/csdf.pxd,sha256=ADPjAuHsodAvdOz96Z_XlFF7VL3KmVaXcTifWDP3rK0,4205
-sdf_xarray/plotting.py,sha256=pCKZ01sAT0VLEhnWrX6LN5OSJnzcIkRA3joN7f62giM,6238
-sdf_xarray/sdf_interface.cp312-win_amd64.pyd,sha256=X3q3Kpj9SyxEKI53c8V3gZ5ZPQmi1HZqTGjsq5d0xKg,379392
-sdf_xarray/sdf_interface.pyx,sha256=3XRFlrC1e_HkJrU8-i3fMz8DlyUxZgt9wTx_QkGE_TQ,11982
-sdf_xarray-0.2.2.dist-info/METADATA,sha256=z5fvCcdbezFWBQWZJXHAlzUf32R4_kKHjYsshvoue6I,8032
-sdf_xarray-0.2.2.dist-info/WHEEL,sha256=NwgjyrmVpVzZ-osOl_ZcT-QXHLFroWlAkN7IC9J-0Pg,106
-sdf_xarray-0.2.2.dist-info/entry_points.txt,sha256=gP7BIQpXNg6vIf7S7p-Rw_EJZTC1X50BsVTkK7dA7g0,57
-sdf_xarray-0.2.2.dist-info/licenses/LICENCE,sha256=aHWuyELjtzIL1jTXFHTbI3tr9vyVyhnw3I9_QYPdEX8,1515
-sdf_xarray-0.2.2.dist-info/RECORD,,
+sdf_xarray/plotting.py,sha256=ze1paC1Uw42WOWspdqkyNsUviDt-Z7AwQlPyO7JB90o,7007
+sdf_xarray/sdf_interface.cp312-win_amd64.pyd,sha256=dHhckvhBNazLGLM_R2geBlAoWZFcll1UGrKC5VW8h3Y,359424
+sdf_xarray/sdf_interface.pyx,sha256=PFC6upg14OZBqiGInLgBoxztIIKBk-HOh3WC9Ro4YUw,11975
+sdf_xarray-0.2.4.dist-info/METADATA,sha256=l0Gwyl2O5oSNQJ8yLOCcABSSd5VlCz9MAwo4GgHxcuQ,9129
+sdf_xarray-0.2.4.dist-info/WHEEL,sha256=k3AOLK754NVb09U5k7PdROOgoHUP1Q4mZk2PKi14SoM,106
+sdf_xarray-0.2.4.dist-info/entry_points.txt,sha256=gP7BIQpXNg6vIf7S7p-Rw_EJZTC1X50BsVTkK7dA7g0,57
+sdf_xarray-0.2.4.dist-info/licenses/LICENCE,sha256=aHWuyELjtzIL1jTXFHTbI3tr9vyVyhnw3I9_QYPdEX8,1515
+sdf_xarray-0.2.4.dist-info/RECORD,,

{sdf_xarray-0.2.2.dist-info → sdf_xarray-0.2.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.1
+Generator: scikit-build-core 0.11.2
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64