py-pluto 1.1.4__py3-none-any.whl

pyPLUTO/loadpart.py

@@ -0,0 +1,233 @@
+from pathlib import Path
+from typing import Any
+
+from numpy.typing import NDArray
+
+
+class LoadPart:
+    """Load the particles from the simulation. The class is used to load
+    the particles from the simulation and store the data in the class
+    attributes. The data are loaded in a memory mapped numpy
+    multidimensional array. Such approach does not load the full data
+    until needed. Basic operations (i.e. no numpy) are possible, as well
+    as slicing the arrays, without fully loading the data. At the
+    moment, only one output can be loaded at a time.
+
+    Returns
+    -------
+    - None
+
+    Parameters
+    ----------
+    - datatype: str, default None
+        The format of the data files to be loaded. If None, the code
+        finds the format between dbl, flt and vtk.
+    - endian: str | None, default None
+        The endianess of the data files. If None, the code finds the
+        endianess.
+    - nfile_lp: int | None, default None
+        The file number for the lp methods. If None, the code finds the
+        file number.
+    - nout: int | str | list | None, default 'last'
+        The output number to be loaded. If 'last' the last output is loaded.
+        If None, the data are not loaded.
+    - path: str, default './'
+        The path to the simulation directory.
+    - text: bool, default True
+        If True, the folder and output are printed.
+        In case the user needs a more detailed information of the structure
+        and attributes loaded from the class, the __str__ method provides a
+        easy display of all the important information.
+    - vars: str | list | bool | None, default True
+        The variables to be loaded. If True, all the variables are loaded.
+        If None, the data are not loaded.
+
+    ----
+
+    Examples
+    --------
+    - Example #1: Load the last output from the simulation
+
+        >>> LoadPart()
+
+    - Example #2: Load the last output from the simulation with a specific
+        endianess
+
+        >>> LoadPart(endian="big")
+
+    - Example #3: Load the last output from the simulation with a specific
+        set of variables
+
+        >>> LoadPart(vars=["rho", "vx", "vy", "vz"])
+
+    - Example #4: Load the last output from the simulation without printing
+        the folder and the specific output loaded
+
+        >>> LoadPart(0, text=False)
+
+    - Example #5: Load the last output from the simulation without loading
+        the data
+
+        >>> LoadPart(nout=None)
+
+    - Example #6: Load the last output from the simulation with a specific
+        file number for the lp methods
+
+        >>> LoadPart(nfile_lp=1)
+
+    """
+
+    def __init__(
+        self,
+        nout: int | str | None = "last",
+        path: str | Path = "./",
+        datatype: str | None = None,
+        vars: str | list[str] | bool | None = True,
+        text: bool = True,
+        endian: str | None = None,
+        nfile_lp: int | None = None,
+    ) -> None:
+        # Check if the user wants to load the data
+        if nout is None:
+            return
+
+        # Initialization or declaration of variables (used in this file)
+        self.nout: NDArray  # Output to be loaded
+        self._d_end: dict[str | None, str | None]  # Endianess dictionary
+        self._multiple: bool  # Bool for single or multiple files
+        self._alone: bool = True  # Bool for standalone files
+        self._info: bool  # Bool for info (linked to alone)
+        self._d_vars: dict = {}  # The dictionary of variables
+
+        # Initialization or declaration of variables (used in other files)
+        self.pathdir: Path  # Path to the simulation directory
+        self.format: str | None = None  # The format of the files to be loaded
+        self._charsize: int  # The data size in the files
+        self.outlist: NDArray  # The list of outputs to be loaded
+        self.timelist: NDArray  # The list of times to be loaded
+        self._lennout: int  # The number of outputs to be loaded
+        self.ntime: NDArray  # The time array
+        self._d_info: dict[str, Any]  # Info dictionary
+        self.set_vars: set[str]  # The set of variables to be loaded
+        self.set_outs: set[int]  # The set of outputs to be loaded
+        self._matching_files: list[str]  # The list of files to be loaded
+        self._pathgrid: Path  # Path to the grid file
+        self._pathdata: Path | None = (
+            None  # Path to the data files to be loaded
+        )
+        self._filepath: Path  # The filepath to be loaded
+        self._load_vars: list[str]  # The list of variables to be loaded
+        self._offset: dict[str, int]  # The offset of the variables
+        self._shape: dict[str, tuple[int, ...]]  # The shape of the variables
+        self.geom: str  # The geometry of the simulation
+        self.dim: int  # The dimension of the simulation
+        self.nshp: int | tuple[int, ...]  # The shape of the grid
+        self._dictdim: dict  # The dictionary of dimensions
+        self.nfile_lp: int | None = nfile_lp  # File number for the lp methods
+        self.maxpart: int = 0  # Max number of particles in the simulation
+        self._vardim: NDArray  # The dimension of the variables
+
+        # Check the input endianess
+        self._d_end = {
+            "big": ">",
+            "little": "<",
+            ">": ">",
+            "<": "<",
+            None: None,
+        }  # Endianess dictionary
+
+        if endian not in self._d_end.keys():
+            raise ValueError(
+                f"Invalid endianess. \
+                             Valid values are {self._d_end.keys()}"
+            )
+
+        if not isinstance(nfile_lp, int) and nfile_lp is not None:
+            raise ValueError(
+                "Invalid value for nfile_lp. \
+                             Valid values are int or None"
+            )
+
+        # Check the path and verify that it is a folder
+        self._check_pathformat(path)
+
+        # Find the format of the data files
+        self._find_format(datatype, True)
+
+        # Find relevant informations without opening the files (e.g.
+        # the number of files to be loaded)
+        self._findfiles(nout)
+
+        # For every output, load the desired variables and store
+        # them in the class
+        for i, exout in enumerate(self.nout):
+            self._load_variables(vars, i, exout, endian)
+            if self.format != "vtk":
+                self._store_bin_particles(i)
+            else:
+                self._store_vtk_particles(i)
+
+        # Assign the variables to the class
+        for key in self._d_vars:
+            setattr(self, key, self._d_vars[key])
+
+        # Change the id variable to int depending on the format loaded
+        if self.format != "vtk":
+            self.id = self.id.astype("int")
+        else:
+            self.id = self.id.view(">i4")
+
+        # Print loaded folder and output
+        if text is not False:
+            _nout_out = self.nout[0] if len(self.nout) == 1 else list(self.nout)
+            print(f"LoadPart: folder {path},     output {_nout_out}")
+        return
+
+    def __str__(self):
+        text = f"""
+        LoadPart class.
+        It loads the particles.
+
+        File properties:
+        - Current path loaded (pathdir)      {self.pathdir}
+        - Format loaded       (format)       {self.format}
+
+        Simulation properties
+        - N. particles  (maxpart)  {self.maxpart}
+        - Output loaded (nout)     {self.nout}
+        - Time loaded   (ntime)    {self.ntime}
+
+        Variables loaded:
+        {self._d_vars.keys()}
+
+        Public methods available:
+
+        - select
+        - spectrum
+
+        Please refrain from using "private" methods and attributes.
+        """
+        return text
+
+    def __getattr__(self, name):
+        try:
+            return object.__getattribute__(self, f"_{name}")
+        except AttributeError:
+            raise AttributeError(f"'LoadPart' object has no attribute '{name}'")
+
+    from .loadfuncs.readdata_old import (
+        _assign_var,
+        _check_nout,
+        _findfiles,
+        _init_vardict,
+        _load_variables,
+    )
+    from .loadfuncs.readformat import _check_pathformat, _find_format
+    from .loadfuncs.readpart import (
+        _compute_offset,
+        _inspect_bin,
+        _inspect_vtk,
+        _store_bin_particles,
+        _store_vtk_particles,
+    )
+    from .toolfuncs.parttools import select, spectrum

pyPLUTO/loadstate.py

@@ -0,0 +1,68 @@
+"""Module that contains the LoadState class."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from numpy.typing import NDArray
+
+from pyPLUTO.baseloadstate import BaseLoadState
+
+
+@dataclass
+class LoadState(BaseLoadState):
+    """Class that stores the state of the Load class.
+
+    Its purpose is to keep track of the current state of the data loading,
+    such as the file paths, data arrays, and other properties and update the
+    key attributes through all the different classes that handle the data
+    loading at runtime.
+    """
+
+    # pylint: disable=too-many-instance-attributes
+
+    defh: dict = field(init=False, repr=False)
+    dim: int = field(init=False)
+    dx1: NDArray[Any] = field(init=False)
+    dx2: NDArray[Any] = field(init=False)
+    dx3: NDArray[Any] = field(init=False)
+    full3D: bool = False
+    geom: str = field(init=False)
+
+    gridsize: int = field(init=False)
+    gridsize_st1: int = field(init=False)
+    gridsize_st2: int = field(init=False)
+    gridsize_st3: int = field(init=False)
+    level: int = 0
+
+    nshp: int | tuple[int, ...] = field(init=False)
+    nshp_st1: int | tuple[int, ...] | None = field(init=False)
+    nshp_st2: tuple[int, ...] | None = field(init=False)
+    nshp_st3: tuple[int, ...] | None = field(init=False)
+    nx1: int = field(init=False)
+    nx2: int = field(init=False)
+    nx3: int = field(init=False)
+
+    plini: dict = field(init=False, repr=False)
+
+    x1: NDArray[Any] = field(init=False)
+    x1c: NDArray[Any] = field(init=False, repr=False)
+    x1p: NDArray[Any] = field(init=False, repr=False)
+    x1r: NDArray[Any] = field(init=False)
+    x1rc: NDArray[Any] = field(init=False, repr=False)
+    x1rp: NDArray[Any] = field(init=False, repr=False)
+    x1rt: NDArray[Any] = field(init=False, repr=False)
+    x1t: NDArray[Any] = field(init=False, repr=False)
+
+    x2: NDArray[Any] = field(init=False)
+    x2c: NDArray[Any] = field(init=False, repr=False)
+    x2p: NDArray[Any] = field(init=False, repr=False)
+    x2r: NDArray[Any] = field(init=False)
+    x2rc: NDArray[Any] = field(init=False, repr=False)
+    x2rp: NDArray[Any] = field(init=False, repr=False)
+
+    x3: NDArray[Any] = field(init=False)
+    x3c: NDArray[Any] = field(init=False, repr=False)
+    x3r: NDArray[Any] = field(init=False)
+    x3rc: NDArray[Any] = field(init=False, repr=False)
+    x3rt: NDArray[Any] = field(init=False, repr=False)
+    x3t: NDArray[Any] = field(init=False, repr=False)

pyPLUTO/newload.py

@@ -0,0 +1,81 @@
+"""The Load class loads the data (fluid) from the output files."""
+
+from typing import Any
+
+from pyPLUTO.loadfuncs.initload import InitLoadManager
+from pyPLUTO.loadfuncs.readdefplini import FiledefpliniManager
+from pyPLUTO.loadmixin import LoadMixin
+from pyPLUTO.loadstate import LoadState
+from pyPLUTO.utils.inspector import track_kwargs
+
+# mypy: ignore-errors
+
+#'''
+# from pathlib import Path
+# from typing import TypedDict, Unpack
+# class MyKwargs(TypedDict, total=False):
+#    """TypedDict for keyword arguments."""
+
+#    code: str
+#    endian: str | None
+#    level: int
+#    multiple: bool
+#    nout: str | int | None
+#    path: str | Path
+#'''
+
+
+class Load(LoadMixin):
+    """The Load class loads the data (fluid) from the output files.
+
+    The initialization corresponds to the loading, if wanted, of one or more
+    datafiles for the fluid. The data are loaded in a memory mapped numpy
+    multidimensional array. Such approach does not load the full data
+    until needed. Basic operations (i.e. no numpy) are possible, as well
+    as slicing the arrays, without fully loading the data.
+    """
+
+    @track_kwargs
+    def __init__(
+        self,
+        nout: int | str | list[int | str] | None = "last",
+        check: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the Load class."""
+        kwargs.pop("kwargscheck", check)
+
+        self.state: LoadState = LoadState()
+        self.text: bool | None = kwargs.get("text", self.text)
+        self.class_name: str = self.__class__.__name__
+        self.full3D: bool = kwargs.get("full3D", self.full3D)
+        self.level: int = kwargs.get("level", self.level)
+        InitLoadManager(self.state, nout, **kwargs)
+        FiledefpliniManager(self.state, **kwargs)
+
+        if self.text is not False:
+            print("Load: Load class initialized.")
+
+    def __getattr__(self, name: str) -> object:
+        """Get the attribute of the Image class."""
+        return getattr(self.state, name)
+
+    def __setattr__(self, name: str, value: object) -> None:
+        """Set the attribute of the Image class."""
+        if name == "state" or not hasattr(self, "state"):
+            return super().__setattr__(name, value)
+        return setattr(self.state, name, value)
+
+    from .loadfuncs.read_files import _read_dat, _read_h5, read_file
+    from .loadfuncs.write_files import _write_h5, write_file
+    from .toolfuncs.findlines import _check_var, find_contour, find_fieldlines
+    from .toolfuncs.fourier import fourier
+    from .toolfuncs.nabla import curl, divergence, gradient
+    from .toolfuncs.transform import (
+        _congrid,
+        cartesian_vector,
+        mirror,
+        reshape_cartesian,
+        reshape_uniform,
+        slices,
+    )

pyPLUTO/pytools.py

@@ -0,0 +1,145 @@
+"""PyPLUTO general tools."""
+
+import importlib.util
+import inspect
+import os
+import warnings
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+
+windows = bool(importlib.util.find_spec("winsound"))
+
+
+def find_example(name: str) -> Path:
+    """Resolve the path to a test problem.
+
+    The file location is based on the *calling script's*
+    location, or fall back to $PLUTO_DIR.
+    """
+    # Get the path of the calling file
+    caller_file = Path(inspect.stack()[1].filename).resolve()
+    base_dir = caller_file.parent
+
+    # Check if the test problem exists in the PyPLUTO Example directory
+    local_path = base_dir / "Test_Problems" / name
+    if local_path.exists():
+        return local_path
+
+    # Check if the test problem exists in the PLUTO directory
+    env_path = os.environ.get("PLUTO_DIR")
+    if env_path:
+        fallback = Path(env_path) / "Test_Problems" / name
+        if fallback.exists():
+            return fallback
+
+    # If the test problem is not found, raise an error
+    raise FileNotFoundError(
+        f"Test problem '{name}' not found near {base_dir} or in $PLUTO_DIR."
+    )
+
+
+def savefig(**_kwargs: object) -> None:
+    """Save the figure created.
+
+    This function is deprecated and will be removed in future versions.
+    Please call savefig from the Image class instead.
+    """
+    raise NotImplementedError(
+        "pyPLUTO.savefig is deprecated.\n"
+        "Please call savefig from the Image class instead"
+    )
+
+
+def show(block: bool = True) -> None:
+    """Show the figures created.
+
+    Returns
+    -------
+    - None
+
+    Parameters
+    ----------
+    - block: bool, default True
+        If True, the function blocks until the figure is closed.
+
+    ----
+
+    Examples
+    --------
+    - Example #1: Shows the image created
+
+        >>> pp.show()
+
+    """
+    plt.show(block=block)
+
+
+def ring(length: float = 0.5, freq: int = 440) -> None:
+    """Make a sound for a given length and frequency.
+
+    It works on Linux, macOS and Windows.
+
+    Parameters
+    ----------
+    - length: float, default 0.5
+        The length of the sound in seconds.
+    - freq: int, default 440
+        The frequency of the sound in Hz.
+
+    Returns
+    -------
+    - None
+
+    ----
+
+    Examples
+    --------
+    - Example #1: Make a sound with a frequency of 440 Hz and a length
+      of 0.5 seconds
+
+        >>> ring()
+
+    - Example #2: Make a sound with a frequency of 880 Hz and a length
+      of 1 second
+
+        >>> ring(freq=880)
+
+    - Example #3: Make a sound with a frequency of 220 Hz and a length
+      of 0.2 seconds
+
+        >>> ring(length=0.2, freq=220)
+
+    """
+    # Check the OS
+    if windows is not None:
+        try:
+            # Check if the 'winsound' package is available on Windows
+            winsound = importlib.import_module("winsound")
+            if hasattr(winsound, "Beep"):
+                winsound.Beep(freq, int(length * 1000))
+        except UserWarning:
+            # If the 'winsound' package is not available, raise a warning
+            text = (
+                "pyPLUTO.ring requires the 'winsound' package.\n"
+                "Please install it through the command"
+                "\n\npip install winsound\n\nand try again."
+            )
+            warnings.warn(text, UserWarning, stacklevel=2)
+    elif os.name == "posix":
+        # Check if the 'play' command is available on Linux and macOS
+        try:
+            os.system(f"play -nq -t alsa synth {length} sine {freq}")
+        except UserWarning:
+            # If the 'play' command is not available, raise a warning
+            text = (
+                "pyPLUTO.ring requires the 'play' command from the"
+                "'sox' package. \nPlease install it through the command"
+                "\n\nsudo apt install sox \n\nand try again."
+            )
+            warnings.warn(text, UserWarning, stacklevel=2)
+
+    else:
+        # If the OS is not Linux, macOS or Windows, raise a warning
+        text = f"pyPLUTO.ring is not implemented for this OS: {os.name}"
+        warnings.warn(text, UserWarning, stacklevel=2)