py-pluto 1.1.4__py3-none-any.whl

pyPLUTO/loadfuncs/defpluto.py

@@ -0,0 +1,123 @@
+import re
+
+
+def _convert_value(value):
+    """Convert a string value to its appropriate type. This function
+    attempts to convert a string value into a boolean, integer, float,
+    or leave it as a string if it cannot be converted.
+
+    Returns
+    -------
+    bool | int | float | str
+        The converted value, which can be a boolean, integer, float, or the
+        original string if conversion is not possible.
+
+    Parameters
+    ----------
+    value : str
+        The string value to convert.
+
+    """
+    # Convert the value to uppercase to handle case-insensitive comparisons
+    value_upper = value.upper()
+
+    # Check for boolean values first
+    if value_upper in {"YES", "TRUE"}:
+        return True
+    if value_upper in {"NO", "FALSE"}:
+        return False
+
+    # Try to convert to an integer or float, if possible
+    try:
+        return float(value) if "." in value or "e" in value else int(value)
+    except ValueError:
+        return value
+
+
+def _read_defh(self, filepath):
+    """Read a header file and extract definitions.
+
+    This function reads a header file, extracts lines that start with
+    '#define', and converts the values to their appropriate types (boolean,
+    integer, float, or string).
+
+    Returns
+    -------
+    dict
+        A dictionary where keys are the defined names and values are the
+        converted values.
+
+    Parameters
+    ----------
+    filepath : str
+        The path to the header file to read.
+
+    """
+    # Read the file, check if a line starts with '#define',
+    # and split the line into key and value.
+    # Convert the value using _convert_value function.
+    with open(filepath) as file:
+        # Return a dictionary comprehension that processes each line
+        return {
+            key: _convert_value(value)
+            for line in file
+            if line.strip().startswith("#define")
+            for _, key, value in [re.split(r"\s+", line.strip(), maxsplit=2)]
+        }
+
+
+def _read_plini(self, path):
+    """Read the pluto.ini file and extract relevant sections.
+
+    This function reads the pluto.ini file, extracts sections that are of
+    interest (Solver, Parameters, Boundary, Time), and converts the values to
+    their appropriate types (boolean, integer, float, or string).
+
+    Returns
+    -------
+    dict
+        A dictionary where keys are the parameter names and values are the
+        converted values.
+
+    Parameters
+    ----------
+    path : str
+        The path to the pluto.ini file to read.
+
+    """
+    # Define the sections we are interested in
+    wanted_sections = {"Solver", "Parameters", "Boundary", "Time"}
+    plini = {}
+
+    # Regular expressions to match sections and entries in the pluto.ini file
+    section_re = re.compile(r"\[(.+)]")
+    entry_re = re.compile(r"^(\w[\w\-\d]*)\s+(.*)$")
+
+    current_sec = None
+
+    # Open the file and read it line by line
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+
+            if not line or line.startswith("#"):
+                continue
+
+            # Check if the line is a section header or an entry
+            if section_match := section_re.match(line):
+                section = section_match.group(1)
+                current_sec = section if section in wanted_sections else None
+                continue
+
+            # If we are not in a wanted section, skip the line
+            if not current_sec:
+                continue
+
+            # If we are in a wanted section, check for entries
+            # and convert the values using _convert_value function
+            if entry_match := entry_re.match(line):
+                key, value = entry_match.groups()
+                plini[key] = _convert_value(value.strip())
+
+    # Return the dictionary containing the extracted parameters
+    return plini

pyPLUTO/loadfuncs/descriptor.py

@@ -0,0 +1,102 @@
+"""Descriptor management utilities for reading PLUTO descriptor files."""
+
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from pyPLUTO.loadfuncs.baseloadtools import BaseLoadTools
+from pyPLUTO.loadmixin import LoadMixin
+from pyPLUTO.loadstate import LoadState
+
+
+class DescriptorManager(LoadMixin):
+    """Class that manages the descriptor files for loading data."""
+
+    def __init__(
+        self,
+        state: LoadState,
+        nout: int | str | list[int | str],
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the DescriptorManager class."""
+        self.state = state
+        self.LoadToolManager = BaseLoadTools(self.state)
+        self.load_descriptor(nout, **kwargs)
+
+    def load_descriptor(
+        self, nout: int | str | list[int | str], **kwargs: Any
+    ) -> None:
+        """Read the datatype.out file and stores the information.
+
+        Such information are the time array, the output variables, the file type
+        (single or multiples), the endianess, the simulation path and the bin
+        format. All these information are relevant in order to open the output
+        files and access the data.
+
+        Returns
+        -------
+        - None
+
+        Parameters
+        ----------
+        - endian (not optional): str
+            The endianess of the files.
+        - nout (not optional): int
+            The output file to be opened. If default ('last'), the code assumes
+            the last file should be opened. Other options available are 'last'
+            (all the files should be opened) and -1 (same as 'last').
+
+        ----
+
+        Examples
+        --------
+        - Example #1: Read the 'filetype'.out file
+
+            >>> _read_outfile(0, "big")
+
+        """
+        if self.format is None:
+            raise ValueError("Format not defined. Cannot read descriptor file.")
+
+        # Read and parse the 'filetype'.out file — pure Python split, no Pandas
+        pathdata = self.pathdir / Path(self.format + ".out")
+        rows = [
+            line.split()
+            for line in pathdata.read_text().splitlines()
+            if line.strip()
+        ]
+
+        # Store the output and the time full list
+        self.outlist = np.array([r[0] for r in rows], dtype=np.int32)
+        self.timelist = np.array([r[1] for r in rows], dtype=np.float64)
+        self.lennoutlist = len(self.outlist)
+
+        # Check the output lines
+        self.LoadToolManager.check_nout(nout)
+        self.ntimelist = self.timelist[self.noutlist]
+        self.lennout = len(self.noutlist)
+
+        # Initialize the info dictionary
+        self.d_info = {
+            "typefile": np.array([rows[k][4] for k in self.outlist]),
+            "endianess": np.array(
+                [">" if rows[k][5] == "big" else "<" for k in self.outlist]
+            ),
+        }
+
+        # Compute the endianess (vtk always big endian).
+        # If endian is given, it is used instead of the one in the file.
+        self.d_info["endianess"][:] = (
+            ">" if self.format == "vtk" else self.d_info["endianess"]
+        )
+        self.d_info["endianess"][:] = (
+            self.endian if self.endian is not None else self.d_info["endianess"]
+        )
+        self.d_info["varslist"] = [rows[k][6:] for k in self.outlist]
+
+        self.d_info["binformat"] = np.char.add(
+            self.d_info["endianess"], "f" + str(self.charsize)
+        )
+        format_string = f".%04d.{self.format}"
+        self.d_info["endpath"] = np.char.mod(format_string, self.outlist)

pyPLUTO/loadfuncs/findfiles.py

@@ -0,0 +1,182 @@
+"""Docstring for findfiles.py."""
+
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from pyPLUTO.baseloadmixin import BaseLoadMixin
+from pyPLUTO.baseloadstate import BaseLoadState
+from pyPLUTO.loadfuncs.baseloadtools import BaseLoadTools
+
+
+class FindFilesManager(BaseLoadMixin[BaseLoadState]):
+    """Class that manages file finding operations."""
+
+    def __init__(
+        self,
+        state: BaseLoadState,
+        nout: int | str | list[int | str],
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the FindFilesManager class."""
+        self.state = state
+        self.LoadToolManager = BaseLoadTools(self.state)
+        self.find_files(nout, **kwargs)
+
+    def find_files(
+        self, nout: int | str | list[int | str], **kwargs: Any
+    ) -> None:
+        """Find the files to be loaded.
+
+        If nout is a list, the function loops over the list and finds the
+        corresponding files. If nout is an integer, the function finds the
+        corresponding file. If nout is 'last', the function finds the last file.
+        If nout is 'all', the function finds all the files. Then, the function
+        stores the relevant information in a dictionary d_info.
+
+        Returns
+        -------
+        - None
+
+        Parameters
+        ----------
+        - nout (not optional): int | str | list[int|str]
+            The output file to be loaded
+
+        ----
+
+        Examples
+        --------
+        - Example #1: Load the last file
+
+            >>> _findfiles("last")
+
+        - Example #2: Load the first file
+
+            >>> _findfiles(0)
+
+        - Example #3: Load all the files
+
+            >>> _findfiles("all")
+
+        - Example #4: Load multiple specific files
+
+            >>> _findfiles([0, 1, 2, 3])
+
+        """
+        # Initialization or declaration of variables
+        set_vars: set[str] = set()
+        set_outs: set[str] = set()
+        self.d_info = {}
+
+        if self.matching_files is None:
+            raise ValueError("No files are found! Cannot proceed.")
+        # Find the files to be loaded
+        for elem in self.matching_files:
+            self.varsout(elem, set_vars, set_outs)
+
+        # Check if the files are present
+        if len(set_vars) == 0 or len(set_outs) == 0:
+            raise FileNotFoundError(f"No files found in {self.pathdir}!")
+
+        self.outlist = np.array(sorted(set_outs))
+        self.lennoutlist = len(self.outlist)
+        self.LoadToolManager.check_nout(nout)
+        self.lennout = len(self.noutlist)
+        self.ntimelist = np.full(self.lennout, np.nan)
+        self.timelist = np.full(len(self.outlist), np.nan)
+
+        # Find the max size of the output numbers to allow for loading if some
+        # files are missing
+        d_info_size = int(np.max(self.outlist)) + 1
+
+        # Initialize the info dictionary and initialize some relevant variables
+        self.d_info["typefile"] = np.empty(d_info_size, dtype="U20")
+        self.d_info["endianess"] = np.empty(d_info_size, dtype="U20")
+        self.d_info["binformat"] = np.empty(d_info_size, dtype="U20")
+        if self.class_name == "LoadPart":
+            raise NotImplementedError(
+                "FindFilesManager for LoadPart is not implemented yet."
+            )
+        elif self.class_name == "Load":
+            # Check if the fluid files are present as multiple files
+            if "data" not in set_vars or self.multiple is True:
+                # If the files are multiple, the typefile is set accordingly
+                self.d_info["typefile"][:] = "multiple_files"
+                self.d_info["varslist"] = [[] for _ in range(d_info_size)]
+                for elem in self.matching_files:
+                    raw_str = Path(elem).name.split(".")
+                    self.d_info["varslist"][int(raw_str[1])].append(raw_str[0])
+            else:
+                # If the files are single, the typefile is set to 'single_file'
+                self.d_info["typefile"][:] = "single_file"
+                self.d_info["varslist"] = [[] for _ in range(d_info_size)]
+        else:
+            raise ValueError(f"Unknown class name: {self.class_name}")
+
+        # Sparse map indexed by output number
+        endpath = np.empty(d_info_size, dtype=f"<U{len(self.format) + 6}")
+        endpath[:] = ""
+        for out in self.outlist:
+            endpath[int(out)] = f".{int(out):04d}.{self.format}"
+        self.d_info["endpath"] = endpath
+
+    def varsout(
+        self,
+        elem: str,
+        set_vars: set,
+        set_outs: set,
+    ) -> None:
+        """Find the variables and the outputs for the fluid and particles files.
+
+        Returns
+        -------
+        - None
+
+        Parameters
+        ----------
+        - class_name (not optional): str
+            The name of the class. Supported classes are 'Load' or 'LoadPart'.
+        - elem (not optional): str
+            The matching file.
+
+        ----
+
+        Examples
+        --------
+        - Example #1: Find the outputs (particles, non LP)
+
+            >>> _varsouts_p("particles.0000.dbl")
+
+        - Example #2: Find the outputs (fluid)
+
+            >>> _varsouts_f("rho.0000.dbl")
+
+        - Example #3: Find the outputs (LP)
+
+            >>> _varsouts_lp("particles.0000_ch_00.dbl")
+
+        """
+        # Splits the matching filename (variable/data and output number)
+        raw_str = Path(elem).name.split(".")
+        var = raw_str[0]
+        out = raw_str[1]
+
+        # Set the conditions if the file is fluid or particles
+        isfluid = var != "particles" and self.class_name == "Load"
+        ispart = var == "particles" and self.class_name == "LoadPart"
+
+        if isfluid or (ispart and "_" not in out):
+            # Control variable set to True
+            outc = True
+        elif ispart and "_" in out:
+            pass
+        else:
+            # Control variable set to False
+            outc = False
+
+            # Add the variables and the outputs
+        if outc is True:
+            set_vars.add(var)
+            set_outs.add(int(out))

pyPLUTO/loadfuncs/findformat.py

@@ -0,0 +1,245 @@
+"""Module to find the format of the PLUTO output files."""
+
+import glob
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from pyPLUTO.baseloadmixin import BaseLoadMixin
+from pyPLUTO.baseloadstate import BaseLoadState
+from pyPLUTO.utils.inspector import track_kwargs
+
+
+class FindFormat(BaseLoadMixin[BaseLoadState]):
+    """Class to find the format of the PLUTO output files."""
+
+    @track_kwargs
+    def __init__(self, state: BaseLoadState, **kwargs: Any) -> None:
+        """Initialize the FindFormat class."""
+        self.state = state
+
+        datatype = kwargs.get("datatype")
+        alone = kwargs.get("alone")
+        self.check_format(datatype, alone)
+
+    def check_format(
+        self,
+        datatype: str | None,
+        alone: bool | None,
+    ) -> None:
+        """Find the format of the data files to load.
+
+        This checks whether outputs are fluid or particles and searches for
+        available filetypes in the target directory. Depending on the requested
+        datatype and whether files are standalone, it probes formats in order
+        and sets self.format, self._alone and self._charsize accordingly.
+        Supported types are dbl, flt, vtk, dbl.h5 and flt.h5; hdf5 and tab are
+        not implemented.
+
+        Parameters
+        ----------
+        alone: bool | None
+            If the output files are standalone or they require a .out
+            file to be loaded. Only suggested for fluid files, .vtk
+            format and standalone files, otherwise the code finds
+            the alone property by itself.
+        datatype: str | None
+            The file format. If None the format is recovered between
+            (in order) dbl, flt, vtk, dbl.h5 and flt.h5.
+            Formats hdf5 (AMR) and tab have not been implemented yet.
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        - Example #1: Find the format of the fluid files
+
+            >>> find_format("dbl", False)
+
+        - Example #2: Find the format of the standalone files
+
+            >>> find_format("vtk", True)
+
+        - Example #3: Find the format of the fluid files (no format given)
+
+            >>> find_format(None, False)
+
+        - Example #4: Find the format of the particles files
+
+            >>> find_format("dbl", True)        --------
+
+        """
+        # Initialization or declaration of variables
+        dbl = {"dbl", "dbl.h5"}  # The set of double filetypes
+
+        # Define the possible filetypes and set the keyword "alone" accordingly
+        if self.class_name == "Load":
+            # Divide the formats between standalone and not standalone
+            type_out = ["dbl", "flt", "vtk", "dbl.h5", "flt.h5", "tab"]
+            type_lon = ["vtk", "dbl.h5", "flt.h5", "tab", "hdf5"]
+            # If datatype is dbl or flt the files are not standalone
+            if datatype in {"dbl", "flt"}:
+                alone = False
+        elif self.class_name == "LoadPart":
+            # Particle files are always standalone
+            alone = True
+            type_out = []
+            type_lon = ["dbl", "flt", "vtk"]
+        else:
+            # If the class name is not recognized, raise an error
+            raise NameError("Invalid class name.")
+
+        # Check if the given datatype is valid, if not raise an error
+        if datatype not in type_out + type_lon + [None]:
+            if self.class_name == "Load":
+                err = (
+                    f"Invalid datatype {datatype}.\n"
+                    f"Possible formats are: dbl, flt, vtk, dbl.h5, flt.h5, tab"
+                )
+            elif self.class_name == "LoadPart":
+                err = (
+                    f"Invalid datatype {datatype}.\n"
+                    f"Possible formats are: dbl, flt, vtk"
+                )
+            else:
+                err = f"Invalid class name: {self.class_name}"
+            raise ValueError(err)
+
+        # Create the list of types to iterate over. If the datatype is None
+        # then the list is the full list of types, otherwise the list is the
+        # datatype itself.
+        typeout0, typelon0 = (
+            ([], []) if datatype is not None else (type_out, type_lon)
+        )
+        type_out = [datatype] if datatype in type_out else typeout0
+        type_lon = [datatype] if datatype in type_lon else typelon0
+
+        if alone is True:
+            type_out = []
+
+        # Create the list of functions to be called (.out or alone)
+        funcf: list[Callable[[list[str]], None]] = []
+        funcf += (
+            [self.check_typeout]
+            if len(type_out) > 0 and alone is not True
+            else []
+        )
+        funcf += (
+            [self.check_typelon]
+            if len(type_lon) > 0 and alone is not False
+            else []
+        )
+
+        # Iterate over the functions to be called
+        for do_check, arg in (
+            (self.check_typeout, type_out),
+            (self.check_typelon, type_lon),
+        ):
+            do_check([x for x in arg if x is not None])
+            # Check if the format has been found
+            if self.format != "Unknown":
+                # Store the charsize depending on the format
+                self.charsize = 8 if self.format in dbl else 4
+                # If the format is found, end the function
+                return None
+
+        # No file has been found, so raise an error depending on the case.
+        # If the datatype is None, raise a general error, otherwise raise
+        # an error for the specific datatype.
+        scrh = f"No available type has been found in {self.pathdir}."
+
+        if datatype is not None:
+            scrh = f"Type {datatype} not found."
+        raise FileNotFoundError(scrh)
+
+    def check_typeout(self, type_out: list[str]) -> None:
+        """Loop over possible formats in order to findthe descriptor files.
+
+        If the datatype.out file is found, the file format is selected and the
+        flag alone is set to False.
+
+        Returns
+        -------
+        - None
+
+        Parameters
+        ----------
+        - type_out (not optional): list[str]
+            The list of possible formats for the output file.
+
+        ----
+
+        Examples
+        --------
+        - Example #1: Check the format of the output files
+
+            >>> _check_typeout(["dbl", "flt", "vtk", "dbl.h5", "flt.h5", "tab"])
+
+        - Example #2: Check the format of the output files (no format given)
+
+            >>> _check_typeout([])
+
+        """
+        # Loop over the possible formats
+        for try_type in type_out:
+            # Create the path to the grid.out and datatype.out files
+            pathgrid = self.pathdir / Path("grid.out")
+            pathdata = self.pathdir / Path(try_type + ".out")
+
+            # Check if the datatype.out file is present
+            if pathdata.is_file() and pathgrid.is_file():
+                # Store the format and set the flag alone to False
+                self.format = try_type
+                self.alone = False
+                # Format is found, break the loop
+                break
+
+        # End of the function
+
+    def check_typelon(self, type_lon: list[str]) -> None:
+        """Loop over possible formats in order to find the datatype.
+
+        If the file is found, the file format is selected and the flag alone is
+        set to True.
+
+        Returns
+        -------
+        - None
+
+        Parameters
+        ----------
+        - type_lon (not optional): list[str]
+            The list of possible formats for the output file.
+
+        ----
+
+        Examples
+        --------
+        - Example #1: Check the format of the output files
+
+            >>> _check_typelon(["dbl", "flt", "vtk"])
+
+        - Example #2: Check the format of the output files (no format given)
+
+            >>> _check_typelon([])
+
+        """
+        # Loop over the possible formats
+        for try_type in type_lon:
+            # Create the pattern to be searched
+            pattern = self.pathdir / Path("*.*." + try_type)
+
+            # Find the files matching the pattern
+            self.matching_files = glob.glob(str(pattern))
+
+            # Check if the file is present
+            if self.matching_files:
+                # Store the format and set the flag alone to True
+                self.format = try_type
+                self.alone = True
+                # Format is found, break the loop
+                break
+
+        # End of the function