osiris-utils 1.1.10a0__py3-none-any.whl → 1.2.0__py3-none-any.whl

osiris_utils/cli/validate.py

@@ -0,0 +1,247 @@
+"""Validate command - check OSIRIS file and simulation integrity."""
+
+import argparse
+import sys
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+import osiris_utils as ou
+
+
+def register_parser(subparsers) -> None:
+    """Register the 'validate' subcommand parser."""
+    parser = subparsers.add_parser(
+        "validate",
+        help="Validate OSIRIS files and simulations",
+        description="Check integrity of OSIRIS data files and simulation structure",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  osiris validate path/to/simulation      # Check entire simulation
+  osiris validate file.h5                 # Check single file
+  osiris validate sim --check-missing     # Check for missing timesteps
+        """,
+    )
+
+    parser.add_argument(
+        "path",
+        type=str,
+        help="Path to OSIRIS simulation directory or HDF5 file",
+    )
+
+    parser.add_argument(
+        "--check-missing",
+        action="store_true",
+        help="Check for missing timesteps in diagnostics",
+    )
+
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Fail on warnings, not just errors",
+    )
+
+    parser.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    """Execute the validate command."""
+    path = Path(args.path)
+
+    if not path.exists():
+        print(f"Error: Path '{path}' does not exist", file=sys.stderr)
+        return 1
+
+    errors = 0
+    warnings = 0
+
+    try:
+        if path.is_file():
+            e, w = validate_file(path)
+            errors += e
+            warnings += w
+        elif path.is_dir():
+            e, w = validate_simulation(path, args.check_missing)
+            errors += e
+            warnings += w
+        else:
+            print(f"Error: '{path}' is not a file or directory", file=sys.stderr)
+            return 1
+
+        # Summary
+        separator = '=' * 60
+        print(f"\n{separator}")
+        print("Validation Summary:")
+        print(f"  Errors: {errors}")
+        print(f"  Warnings: {warnings}")
+
+        if errors > 0:
+            print("\nValidation FAILED")
+            return 1
+        elif warnings > 0 and args.strict:
+            print("\nValidation FAILED (strict mode)")
+            return 1
+        else:
+            print("\nValidation PASSED")
+            return 0
+
+    except Exception as e:
+        print(f"Error during validation: {e}", file=sys.stderr)
+        return 1
+
+
+def validate_file(filepath: Path) -> tuple[int, int]:
+    """
+    Validate a single HDF5 file.
+
+    Returns
+    -------
+    tuple[int, int]
+        (error_count, warning_count)
+    """
+    errors = 0
+    warnings = 0
+
+    print(f"Validating file: {filepath}")
+
+    # Check if file can be opened
+    try:
+        with h5py.File(filepath, 'r') as f:
+            print("File is a valid HDF5 file")
+
+            # Check for required datasets
+            if 'AXIS' not in f:
+                print("Warning: Missing AXIS dataset")
+                warnings += 1
+
+            # Try to load with osiris_utils
+            try:
+                data = ou.OsirisGridFile(str(filepath))
+                print("File loads successfully with osiris_utils")
+
+                # Check data integrity
+                if data.data.size == 0:
+                    print("Error: Data array is empty")
+                    errors += 1
+                else:
+                    print(f"Data array is non-empty (shape: {data.data.shape})")
+
+                # Check for NaN or Inf
+                if not np.isfinite(data.data).all():
+                    print("Warning: Data contains NaN or Inf values")
+                    warnings += 1
+                else:
+                    print("Data contains only finite values")
+
+            except Exception as e:
+                print(f"Error: Cannot load with osiris_utils: {e}")
+                errors += 1
+
+    except OSError as e:
+        print(f"Error: Cannot open file: {e}")
+        errors += 1
+
+    return errors, warnings
+
+
+def validate_simulation(simpath: Path, check_missing: bool = False) -> tuple[int, int]:
+    """
+    Validate an entire simulation directory.
+
+    Returns
+    -------
+    tuple[int, int]
+        (error_count, warning_count)
+    """
+    errors = 0
+    warnings = 0
+
+    print(f"Validating simulation: {simpath}")
+
+    # Check for input deck
+    input_deck = None
+    for candidate in ["os-stdin", "input.deck", "deck.in"]:
+        deck_path = simpath / candidate
+        if deck_path.exists():
+            input_deck = deck_path
+            break
+
+    if input_deck is None:
+        print("Error: No input deck found")
+        errors += 1
+        return errors, warnings
+    else:
+        print(f"Found input deck: {input_deck.name}")
+
+    # Try to load simulation
+    try:
+        sim = ou.Simulation(str(input_deck))
+        print("Simulation loads successfully")
+        print(f"Found {len(sim.species)} species: {', '.join(sim.species)}")
+    except Exception as e:
+        print(f"Error: Cannot load simulation: {e}")
+        errors += 1
+        return errors, warnings
+
+    # Check MS directory
+    ms_path = simpath / "MS"
+    if not ms_path.exists():
+        print("Warning: MS directory not found")
+        warnings += 1
+        return errors, warnings
+    else:
+        print("Found MS directory")
+
+    # Check diagnostic directories
+    diag_types = ["FLD", "DENSITY", "CURRENT", "PHA"]
+    for diag_type in diag_types:
+        diag_path = ms_path / diag_type
+        if diag_path.exists():
+            e, w = validate_diagnostic_dir(diag_path, check_missing)
+            errors += e
+            warnings += w
+
+    return errors, warnings
+
+
+def validate_diagnostic_dir(diag_path: Path, check_missing: bool) -> tuple[int, int]:
+    """Validate a diagnostic directory."""
+    errors = 0
+    warnings = 0
+
+    print(f"\n  Checking {diag_path.name}:")
+
+    # Recursively find all h5 files
+    for subdir in diag_path.rglob("*"):
+        if subdir.is_dir():
+            h5_files = sorted(list(subdir.glob("*.h5")))
+            if h5_files:
+                rel_path = subdir.relative_to(diag_path)
+                print(f"    {rel_path}: {len(h5_files)} files")
+
+                if check_missing:
+                    # Check for sequential numbering
+                    actual_indices = set()
+
+                    for f in h5_files:
+                        # Extract iteration number from filename
+                        try:
+                            # Typical format: name-123456.h5
+                            iter_str = f.stem.split('-')[-1]
+                            actual_indices.add(int(iter_str))
+                        except (ValueError, IndexError):
+                            pass
+
+                    if len(actual_indices) > 0:
+                        min_idx = min(actual_indices)
+                        max_idx = max(actual_indices)
+                        expected_sequential = set(range(min_idx, max_idx + 1))
+                        missing = expected_sequential - actual_indices
+
+                        if missing:
+                            print(f"Warning: Missing iterations: {sorted(missing)[:10]}{'...' if len(missing) > 10 else ''}")
+                            warnings += 1
+
+    return errors, warnings

osiris_utils/data/__init__.py

@@ -0,0 +1,15 @@
+from .data import OsirisData, OsirisGridFile, OsirisHIST, OsirisRawFile, OsirisTrackFile
+from .diagnostic import Diagnostic, which_quantities
+from .simulation import Simulation, Species_Handler
+
+__all__ = [
+    "OsirisData",
+    "OsirisGridFile",
+    "OsirisRawFile",
+    "OsirisHIST",
+    "OsirisTrackFile",
+    "Diagnostic",
+    "which_quantities",
+    "Simulation",
+    "Species_Handler",
+]

osiris_utils/data/data.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Literal
 
 import h5py
@@ -6,6 +8,14 @@ import pandas as pd
 
 from osiris_utils.utils import create_file_tags
 
+__all__ = [
+    "OsirisData",
+    "OsirisGridFile",
+    "OsirisRawFile",
+    "OsirisHIST",
+    "OsirisTrackFile",
+]
+
 
 class OsirisData:
     """
@@ -78,7 +88,7 @@ class OsirisData:
 
     def _open_file_hdf5(self, filename):
         """
-        Open the OSIRIS output file. Usually an HDF5 file or txt.
+        Open the OSIRIS output file with optimized cache settings.
 
         Parameters
         ----------
@@ -88,11 +98,23 @@ class OsirisData:
         if self._verbose:
             print(f"Opening file > {filename}")
 
-        if filename.endswith(".h5"):
-            self._file = h5py.File(filename, "r")
-        else:
+        if not filename.endswith(".h5"):
             raise ValueError("The file should be an HDF5 file with the extension .h5")
 
+        # Optimize HDF5 chunk cache for better performance
+        # Increase cache from default 1MB to 10MB for large file access
+        propfaid = h5py.h5p.create(h5py.h5p.FILE_ACCESS)
+        propfaid.set_cache(
+            0,  # Meta cache elements (0 = use default)
+            10485760,  # 10MB chunk cache (default is 1MB)
+            0.75,  # Chunk cache preemption policy (0.75 = aggressive caching)
+            0,  # Hash table size (0 = use default)
+        )
+
+        # Open file with optimized settings
+        fid = h5py.h5f.open(filename.encode(), flags=h5py.h5f.ACC_RDONLY, fapl=propfaid)
+        self._file = h5py.File(fid)
+
     def _open_hist_file(self, filename):
         self._df = pd.read_csv(filename, sep=r"\s+", comment="!", header=0, engine="python")
 
@@ -162,11 +184,9 @@ class OsirisGridFile(OsirisData):
         Field units (LaTeX formatted)
     label : str
         Field label/name (LaTeX formatted, e.g., r'$E_x$')
-    FFTdata : np.ndarray
-        Fourier-transformed data (available after calling FFT())
     """
 
-    def __init__(self, filename):
+    def __init__(self, filename, data_slice: slice | None = None):
         super().__init__(filename)
 
         variable_key = self._get_variable_key(self._file)
@@ -175,7 +195,7 @@ class OsirisGridFile(OsirisData):
         self._label = self._file.attrs["LABEL"][0].decode("utf-8")
         self._FFTdata = None
 
-        data = np.array(self._file[variable_key][:])
+        data = np.array(self._file[variable_key][:]) if data_slice is None else np.array(self._file[variable_key][data_slice])
 
         axis = list(self._file["AXIS"].keys())
         if len(axis) == 1:
@@ -193,8 +213,11 @@ class OsirisGridFile(OsirisData):
 
             # There's an issue when the dimension is 3 and we want to plot a 2D phasespace. I believe this
             # is a problem for all cases where the dim != dim_of_phasespace
-            self._x = [np.arange(self.grid[i, 0], self.grid[i, 1], self.dx[i]) for i in range(self.dim)]
-            # self._x = [np.arange(self.grid[i, 0], self.grid[i, 1], self.dx[i]) for i in range(2)]
+            try:
+                self._x = [np.arange(self.grid[i, 0], self.grid[i, 1], self.dx[i]) for i in range(self.dim)]
+            except Exception as e:
+                print(f"Error occurred while creating spatial coordinates: {e}")
+                self._x = [np.arange(self.grid[i, 0], self.grid[i, 1], self.dx[i]) for i in range(1)]
 
         self._axis = []
         for ax in axis:
@@ -203,7 +226,8 @@ class OsirisGridFile(OsirisData):
                 "units": self._file["AXIS/" + ax].attrs["UNITS"][0].decode("utf-8"),
                 "long_name": self._file["AXIS/" + ax].attrs["LONG_NAME"][0].decode("utf-8"),
                 "type": self._file["AXIS/" + ax].attrs["TYPE"][0].decode("utf-8"),
-                "plot_label": rf'${self._file["AXIS/" + ax].attrs["LONG_NAME"][0].decode("utf-8")}$ $[{self._file["AXIS/" + ax].attrs["UNITS"][0].decode("utf-8")}]$',
+                "plot_label": rf'${self._file["AXIS/" + ax].attrs["LONG_NAME"][0].decode("utf-8")}$'
+                + rf'$[{self._file["AXIS/" + ax].attrs["UNITS"][0].decode("utf-8")}]$',
             }
             self._axis.append(axis_data)
 
@@ -226,154 +250,6 @@ class OsirisGridFile(OsirisData):
     def _get_variable_key(self, f: h5py.File) -> str:
         return next(k for k in f.keys() if k not in {"AXIS", "SIMULATION"})
 
-    def _yeeToCellCenter1d(self, boundary):
-        """
-        Converts 1d EM fields from a staggered Yee mesh to a grid with field values centered on the Center of the cell
-        """
-
-        if self.name.lower() in ["b2", "b3", "e1"]:
-            if boundary == "periodic":
-                return 0.5 * (np.roll(self.data, shift=1) + self.data)
-            else:
-                return 0.5 * (self.data[1:] + self.data[:-1])
-        elif self.name.lower() in ["b1", "e2", "e3"]:
-            if boundary == "periodic":
-                return self.data
-            else:
-                return self.data[1:]
-        else:
-            raise TypeError(f"This method expects magnetic or electric field grid data but received '{self.name}' instead")
-
-    def _yeeToCellCenter2d(self, boundary):
-        """
-        Converts 2d EM fields from a staggered Yee mesh to a grid with field values centered on the Center of the cell
-        """
-
-        if self.name.lower() in ["e1", "b2"]:
-            if boundary == "periodic":
-                return 0.5 * (np.roll(self.data, shift=1, axis=0) + self.data)
-            else:
-                return 0.5 * (self.data[1:, 1:] + self.data[:-1, 1:])
-        elif self.name.lower() in ["e2", "b1"]:
-            if boundary == "periodic":
-                return 0.5 * (np.roll(self.data, shift=1, axis=1) + self.data)
-            else:
-                return 0.5 * (self.data[1:, 1:] + self.data[1:, :-1])
-        elif self.name.lower() in ["b3"]:
-            if boundary == "periodic":
-                return 0.5 * (
-                    np.roll(
-                        (0.5 * (np.roll(self.data, shift=1, axis=0) + self.data)),
-                        shift=1,
-                        axis=1,
-                    )
-                    + (0.5 * (np.roll(self.data, shift=1, axis=0) + self.data))
-                )
-            else:
-                return 0.25 * (self.data[1:, 1:] + self.data[:-1, 1:] + self.data[1:, :-1] + self.data[:-1, :-1])
-        elif self.name.lower() in ["e3"]:
-            if boundary == "periodic":
-                return self.data
-            else:
-                return self.data[1:, 1:]
-        else:
-            raise TypeError(f"This method expects magnetic or electric field grid data but received '{self.name}' instead")
-
-    def _yeeToCellCenter3d(self, boundary):
-        """
-        Converts 3d EM fields from a staggered Yee mesh to a grid with field values centered on the Center of the cell
-        """
-        if self.name.lower() == "b1":
-            if boundary == "periodic":
-                return 0.5 * (
-                    0.5
-                    * np.roll(
-                        (np.roll(self.data, shift=1, axis=1) + self.data),
-                        shift=1,
-                        axis=2,
-                    )
-                    + 0.5 * (np.roll(self.data, shift=1, axis=1) + self.data)
-                )
-            else:
-                return 0.25 * (self.data[1:, 1:, 1:] + self.data[1:, :-1, 1:] + self.data[1:, 1:, :-1] + self.data[1:, :-1, :-1])
-        elif self.name.lower() == "b2":
-            if boundary == "periodic":
-                return 0.5 * (
-                    0.5
-                    * np.roll(
-                        (np.roll(self.data, shift=1, axis=0) + self.data),
-                        shift=1,
-                        axis=2,
-                    )
-                    + 0.5 * (np.roll(self.data, shift=1, axis=0) + self.data)
-                )
-            else:
-                return 0.25 * (self.data[1:, 1:, 1:] + self.data[:-1, 1:, 1:] + self.data[1:, 1:, :-1] + self.data[:-1, 1:, :-1])
-        elif self.name.lower() == "b3":
-            if boundary == "periodic":
-                return 0.5 * (
-                    0.5
-                    * np.roll(
-                        (np.roll(self.data, shift=1, axis=0) + self.data),
-                        shift=1,
-                        axis=1,
-                    )
-                    + 0.5 * (np.roll(self.data, shift=1, axis=0) + self.data)
-                )
-            else:
-                return 0.25 * (self.data[1:, 1:, 1:] + self.data[:-1, 1:, 1:] + self.data[1:, :-1, 1:] + self.data[:-1, :-1, 1:])
-        elif self.name.lower() == "e1":
-            if boundary == "periodic":
-                return 0.5 * (np.roll(self.data, shift=1, axis=0) + self.data)
-            else:
-                return 0.5 * (self.data[1:, 1:, 1:] + self.data[:-1, 1:, 1:])
-        elif self.name.lower() == "e2":
-            if boundary == "periodic":
-                return 0.5 * (np.roll(self.data, shift=1, axis=1) + self.data)
-            else:
-                return 0.5 * (self.data[1:, 1:, 1:] + self.data[1:, :-1, 1:])
-        elif self.name.lower() == "e3":
-            if boundary == "periodic":
-                return 0.5 * (np.roll(self.data, shift=1, axis=2) + self.data)
-            else:
-                return 0.5 * (self.data[1:, 1:, 1:] + self.data[1:, 1:, :-1])
-        else:
-            raise TypeError(f"This method expects magnetic or electric field grid data but received '{self.name}' instead")
-
-    def yeeToCellCenter(self, boundary: Literal["periodic", "default"] = "default"):
-        """'
-        Converts EM fields from a staggered Yee mesh to a grid with field values centered on the center of the cell.'
-        Can be used for 1D, 2D and 3D simulations.'
-        Creates a new attribute `data_centered` with the centered data.'
-        """
-
-        if boundary not in ("periodic", "default"):
-            raise ValueError(f"Invalid boundary: {boundary}, choose 'periodic' or 'default' instead.")
-
-        cases = {"b1", "b2", "b3", "e1", "e2", "e3"}
-        if self.name not in cases:
-            raise TypeError(f"This method expects magnetic or electric field grid data but received '{self.name}' instead")
-
-        if self.dim == 1:
-            self.data_centered = self._yeeToCellCenter1d(boundary)
-            return self.data_centered
-        elif self.dim == 2:
-            self.data_centered = self._yeeToCellCenter2d(boundary)
-            return self.data_centered
-        elif self.dim == 3:
-            self.data_centered = self._yeeToCellCenter3d(boundary)
-            return self.data_centered
-        else:
-            raise ValueError(f"Dimension {self.dim} is not supported")
-
-    def FFT(self, axis=(0,)):
-        """
-        Computes the Fast Fourier Transform of the data along the specified axis and shifts the zero frequency to the center.
-        Transforms the data to the frequency domain. A(x, y, z) -> A(kx, ky, kz)
-        """
-        datafft = np.fft.fftn(self.data, axes=axis)
-        self._FFTdata = np.fft.fftshift(datafft, axes=axis)
-
     # Getters
     @property
     def grid(self):
@@ -407,12 +283,6 @@ class OsirisGridFile(OsirisData):
     def label(self):
         return self._label
 
-    @property
-    def FFTdata(self):
-        if self._FFTdata is None:
-            raise ValueError("The FFT of the data has not been computed yet. Compute it using the FFT method.")
-        return self._FFTdata
-
     # Setters
     @data.setter
     def data(self, data):
@@ -501,8 +371,8 @@ class OsirisRawFile(OsirisData):
         self._quants = [byte.decode("utf-8") for byte in self._file.attrs["QUANTS"][:]]
         units_list = [byte.decode("utf-8") for byte in self._file.attrs["UNITS"][:]]
         labels_list = [byte.decode("utf-8") for byte in self._file.attrs["LABELS"][:]]
-        self._units = dict(zip(self._quants, units_list))
-        self._labels = dict(zip(self._quants, labels_list))
+        self._units = dict(zip(self._quants, units_list, strict=False))
+        self._labels = dict(zip(self._quants, labels_list, strict=False))
 
         self._data = {}
         self._axis = {}
@@ -598,8 +468,8 @@ class OsirisRawFile(OsirisData):
 
 
 class OsirisHIST(OsirisData):
-    """'
-    Class to read the data from an OSIRIS HIST file.'
+    """
+    Class to read the data from an OSIRIS HIST file.
 
     Input
     -----
@@ -669,8 +539,8 @@ class OsirisTrackFile(OsirisData):
         self._quants = [byte.decode("utf-8") for byte in self._file.attrs["QUANTS"][1:]]
         units_list = [byte.decode("utf-8") for byte in self._file.attrs["UNITS"][1:]]
         labels_list = [byte.decode("utf-8") for byte in self._file.attrs["LABELS"][1:]]
-        self._units = dict(zip(self._quants, units_list))
-        self._labels = dict(zip(self._quants, labels_list))
+        self._units = dict(zip(self._quants, units_list, strict=False))
+        self._labels = dict(zip(self._quants, labels_list, strict=False))
 
         self._num_particles = self._file.attrs["NTRACKS"][0]