py-pluto 1.1.4__py3-none-any.whl

pyPLUTO/loadfuncs/write_files.py

@@ -0,0 +1,283 @@
+import warnings
+from typing import Any
+
+import h5py
+from numpy.typing import NDArray
+
+
+def _write_h5(
+    self,
+    data: NDArray | dict,
+    filename: str,
+    dataname: str | None = None,
+    grid: bool = False,
+    **kwargs: Any,
+) -> None:
+    """Write the data to a HDF5 file.
+
+    Returns
+    -------
+    - None
+
+    Parameters
+    ----------
+    - data (not optional): NDArray | dict
+        the data to write to the HDF5 file
+    - dataname: str
+        the name of the data to write to the HDF5 file
+    - filename (not optional): str
+        the name of the HDF5 file
+    - grid: bool
+        if True, write the grid to the HDF5 file
+
+    ----
+
+    Examples
+    --------
+    - Example #1: Write the data to a HDF5 file
+
+        >>> write_h5("data.h5")
+
+    """
+    # Create the path to the HDF5 file
+    path_h5 = self.pathdir / filename
+    if not filename.endswith(".h5"):
+        path_h5 += ".h5"
+
+    # Open the HDF5 file
+    with h5py.File(path_h5, "w") as f:
+        # Write the data to the HDF5 file
+        if isinstance(data, dict):
+            for key in data.keys():
+                f.create_dataset(key, data=data[key])
+        else:
+            dataname = "data" if dataname is None else dataname
+            f.create_dataset(dataname, data=data)
+
+        # Write the grid to the HDF5 file
+        if grid is True:
+            f.create_dataset("nx1", data=kwargs.get("nx1", self.nx1))
+            f.create_dataset("nx2", data=kwargs.get("nx2", self.nx2))
+            f.create_dataset("nx3", data=kwargs.get("nx3", self.nx3))
+            f.create_dataset("x1", data=kwargs.get("x1", self.x1))
+            f.create_dataset("x2", data=kwargs.get("x2", self.x2))
+            f.create_dataset("x3", data=kwargs.get("x3", self.x3))
+            f.create_dataset("dx1", data=kwargs.get("dx1", self.dx1))
+            f.create_dataset("dx2", data=kwargs.get("dx2", self.dx2))
+            f.create_dataset("dx3", data=kwargs.get("dx3", self.dx3))
+
+    # End of the function
+
+
+def write_vtk(self):
+    """Write the data to a VTK file.
+
+    Returns
+    -------
+    - None
+
+    Parameters
+    ----------
+    - None
+
+    ----
+
+    Examples
+    --------
+    - Example #1: Write the data to a VTK file
+
+        >>> write_vtk()
+
+    """
+    raise NotImplementedError("write_vtk() is not yet implemented.")
+    # Create the path to the VTK file
+    self._pathvtk = self.pathdir / (self.format + ".vtk")
+
+    # Open the VTK file
+    with open(self._pathvtk, "w") as f:
+        # Write the header to the VTK file
+        f.write("# vtk DataFile Version 3.0\n")
+        f.write("VTK file for " + self.format + "\n")
+        f.write("ASCII\n")
+        f.write("DATASET STRUCTURED_POINTS\n")
+        f.write(
+            "DIMENSIONS "
+            + str(self.grid["nx1"])
+            + " "
+            + str(self.grid["nx2"])
+            + " "
+            + str(self.grid["nx3"])
+            + "\n"
+        )
+        f.write(
+            "ORIGIN "
+            + str(self.grid["x1"][0])
+            + " "
+            + str(self.grid["x2"][0])
+            + " "
+            + str(self.grid["x3"][0])
+            + "\n"
+        )
+        f.write(
+            "SPACING "
+            + str(self.grid["dx1"])
+            + " "
+            + str(self.grid["dx2"])
+            + " "
+            + str(self.grid["dx3"])
+            + "\n"
+        )
+        f.write(
+            "POINT_DATA "
+            + str(self.grid["nx1"] * self.grid["nx2"] * self.grid["nx3"])
+            + "\n"
+        )
+
+        # Write the data to the VTK file
+        for key in self.data.keys():
+            f.write("SCALARS " + key + " float\n")
+            f.write("LOOKUP_TABLE default\n")
+            for i in range(self.grid["nx1"]):
+                for j in range(self.grid["nx2"]):
+                    for k in range(self.grid["nx3"]):
+                        f.write(str(self.data[key][i, j, k]) + "\n")
+
+    # End of the function
+
+
+def write_tab(self):
+    """Write the data to a tab-separated file.
+
+    Returns
+    -------
+    - None
+
+    Parameters
+    ----------
+    - None
+
+    ----
+
+    Examples
+    --------
+    - Example #1: Write the data to a tab-separated file
+
+        >>> write_tab()
+
+    """
+    raise NotImplementedError("write_tab() is not yet implemented.")
+
+    # Create the path to the tab-separated file
+    self._pathtab = self.pathdir / (self.format + ".tab")
+
+    # Open the tab-separated file
+    with open(self._pathtab, "w") as f:
+        # Write the header to the tab-separated file
+        f.write("# " + self.format + "\n")
+
+        # Write the data to the tab-separated file
+        for key in self.data.keys():
+            f.write("# " + key + "\n")
+            for i in range(self.grid["nx1"]):
+                for j in range(self.grid["nx2"]):
+                    for k in range(self.grid["nx3"]):
+                        f.write(str(self.data[key][i, j, k]) + "\t")
+                    f.write("\n")
+
+    # End of the function
+
+
+def write_bin(self):
+    """Write the data to a binary file.
+
+    Returns
+    -------
+    - None
+
+    Parameters
+    ----------
+    - None
+
+    ----
+
+    Examples
+    --------
+    - Example #1: Write the data to a binary file
+
+        >>> write_bin()
+
+    """
+    raise NotImplementedError("write_bin() is not yet implemented.")
+
+    # Create the path to the binary file
+    self._pathbin = self.pathdir / (self.format + ".bin")
+
+    # Open the binary file
+    with open(self._pathbin, "wb") as f:
+        # Write the data to the binary file
+        for key in self.data.keys():
+            f.write(self.data[key].tobytes())
+
+    # End of the function
+
+
+def write_file(
+    self,
+    data: NDArray | dict,
+    filename: str,
+    datatype: str | None = None,
+    dataname: str | None = None,
+    grid: bool = False,
+    **kwargs: Any,
+) -> None:
+    """Write the data to a file.
+
+    Returns
+    -------
+    - None
+
+    Parameters
+    ----------
+    - data (not optional): NDArray | dict
+        the data to write to the file
+    - datatype: str
+        the type of the file
+    - dataname: str
+        the name of the data to write to the file
+    - filename (not optional): str
+        the name of the file
+    - grid: bool
+        if True, write the grid to the file
+    - **kwargs: Any
+        additional keyword arguments
+
+    ----
+
+    Examples
+    --------
+    - Example #1: Write the data to a file
+
+            >>> write_file("data.h5")
+
+    """
+    # Check the datatype of the input data
+    if datatype is None:
+        datatype = filename.rsplit(".", maxsplit=1)[-1]
+    poss_types = {"dbl", "flt", "vtk", "h5", "tab"}
+    if datatype not in poss_types:
+        warn = f"Invalid datatype: {datatype}. Resetting to 'h5'"
+        warnings.warn(warn)
+        datatype = "h5"
+
+    # Check the format of the output files
+    if datatype == "h5":
+        _write_h5(self, data, filename, dataname, grid, **kwargs)
+    else:
+        warn = (
+            f"Invalid datatype: {datatype}, not implemented yet! "
+            "Resetting to 'h5'"
+        )
+        warnings.warn(warn)
+        pass
+
+    # End of the function

pyPLUTO/loadmixin.py

@@ -0,0 +1,419 @@
+"""Mixin class for load fluid handling."""
+
+from typing import Any
+
+from numpy.typing import NDArray
+
+from pyPLUTO.baseloadmixin import BaseLoadMixin
+from pyPLUTO.loadstate import LoadState
+
+
+class LoadMixin(BaseLoadMixin[LoadState]):
+    """Mixin class for load fluid handling.
+
+    It provides properties and methods related to loading fluid data.
+    """
+
+    state: LoadState
+
+    # pylint: disable=too-many-public-methods
+
+    @property
+    def defh(self) -> dict:
+        """Get the defh attribute of the load state."""
+        return self.state.defh
+
+    @defh.setter
+    def defh(self, value: dict) -> None:
+        """Set the defh attribute of the load state."""
+        self.state.defh = value
+
+    @property
+    def level(self) -> int:
+        """Get the AMR refinement level."""
+        return self.state.level
+
+    @level.setter
+    def level(self, value: int) -> None:
+        """Set the AMR refinement level."""
+        self.state.level = value
+
+    @property
+    def dim(self) -> int:
+        """Get the dim attribute of the load state."""
+        return self.state.dim
+
+    @dim.setter
+    def dim(self, value: int) -> None:
+        """Set the dim attribute of the load state."""
+        self.state.dim = value
+
+    @property
+    def dx1(self) -> NDArray[Any]:
+        """Get the dx1 attribute of the load state."""
+        return self.state.dx1
+
+    @dx1.setter
+    def dx1(self, value: NDArray[Any]) -> None:
+        """Set the dx1 attribute of the load state."""
+        self.state.dx1 = value
+
+    @property
+    def dx2(self) -> NDArray[Any]:
+        """Get the dx2 attribute of the load state."""
+        return self.state.dx2
+
+    @dx2.setter
+    def dx2(self, value: NDArray[Any]) -> None:
+        """Set the dx2 attribute of the load state."""
+        self.state.dx2 = value
+
+    @property
+    def dx3(self) -> NDArray[Any]:
+        """Get the dx3 attribute of the load state."""
+        return self.state.dx3
+
+    @dx3.setter
+    def dx3(self, value: NDArray[Any]) -> None:
+        """Set the dx3 attribute of the load state."""
+        self.state.dx3 = value
+
+    @property
+    def full3D(self) -> bool:
+        """Get the full3D attribute of the load state."""
+        return self.state.full3D
+
+    @full3D.setter
+    def full3D(self, value: bool) -> None:
+        """Set the full3D attribute of the load state."""
+        self.state.full3D = value
+
+    @property
+    def geom(self) -> str:
+        """Get the geom attribute of the load state."""
+        return self.state.geom
+
+    @geom.setter
+    def geom(self, value: str) -> None:
+        """Set the geom attribute of the load state."""
+        self.state.geom = value
+
+    @property
+    def gridsize(self) -> int:
+        """Get the gridsize attribute of the load state."""
+        return self.state.gridsize
+
+    @gridsize.setter
+    def gridsize(self, value: int) -> None:
+        """Set the gridsize attribute of the load state."""
+        self.state.gridsize = value
+
+    @property
+    def gridsize_st1(self) -> int:
+        """Get the gridsize_st1 attribute of the load state."""
+        return self.state.gridsize_st1
+
+    @gridsize_st1.setter
+    def gridsize_st1(self, value: int) -> None:
+        """Set the gridsize_st1 attribute of the load state."""
+        self.state.gridsize_st1 = value
+
+    @property
+    def gridsize_st2(self) -> int:
+        """Get the gridsize_st2 attribute of the load state."""
+        return self.state.gridsize_st2
+
+    @gridsize_st2.setter
+    def gridsize_st2(self, value: int) -> None:
+        """Set the gridsize_st2 attribute of the load state."""
+        self.state.gridsize_st2 = value
+
+    @property
+    def gridsize_st3(self) -> int:
+        """Get the gridsize_st3 attribute of the load state."""
+        return self.state.gridsize_st3
+
+    @gridsize_st3.setter
+    def gridsize_st3(self, value: int) -> None:
+        """Set the gridsize_st3 attribute of the load state."""
+        self.state.gridsize_st3 = value
+
+    @property
+    def nshp(self) -> int | tuple[int, ...]:
+        """Get the nshp attribute of the load state."""
+        return self.state.nshp
+
+    @nshp.setter
+    def nshp(self, value: int | tuple[int, ...]) -> None:
+        """Set the nshp attribute of the load state."""
+        self.state.nshp = value
+
+    @property
+    def nshp_st1(self) -> int | tuple[int, ...] | None:
+        """Get the nshp_st1 attribute of the load state."""
+        return self.state.nshp_st1
+
+    @nshp_st1.setter
+    def nshp_st1(self, value: int | tuple[int, ...] | None) -> None:
+        """Set the nshp_st1 attribute of the load state."""
+        self.state.nshp_st1 = value
+
+    @property
+    def nshp_st2(self) -> tuple[int, ...] | None:
+        """Get the nshp_st2 attribute of the load state."""
+        return self.state.nshp_st2
+
+    @nshp_st2.setter
+    def nshp_st2(self, value: tuple[int, ...] | None) -> None:
+        """Set the nshp_st2 attribute of the load state."""
+        self.state.nshp_st2 = value
+
+    @property
+    def nshp_st3(self) -> tuple[int, ...] | None:
+        """Get the nshp_st3 attribute of the load state."""
+        return self.state.nshp_st3
+
+    @nshp_st3.setter
+    def nshp_st3(self, value: tuple[int, ...] | None) -> None:
+        """Set the nshp_st3 attribute of the load state."""
+        self.state.nshp_st3 = value
+
+    @property
+    def nx1(self) -> int:
+        """Get the nx1 attribute of the load state."""
+        return self.state.nx1
+
+    @nx1.setter
+    def nx1(self, value: int) -> None:
+        """Set the nx1 attribute of the load state."""
+        self.state.nx1 = value
+
+    @property
+    def nx2(self) -> int:
+        """Get the nx2 attribute of the load state."""
+        return self.state.nx2
+
+    @nx2.setter
+    def nx2(self, value: int) -> None:
+        """Set the nx2 attribute of the load state."""
+        self.state.nx2 = value
+
+    @property
+    def nx3(self) -> int:
+        """Get the nx3 attribute of the load state."""
+        return self.state.nx3
+
+    @nx3.setter
+    def nx3(self, value: int) -> None:
+        """Set the nx3 attribute of the load state."""
+        self.state.nx3 = value
+
+    @property
+    def plini(self) -> dict:
+        """Get the plini attribute of the load state."""
+        return self.state.plini
+
+    @plini.setter
+    def plini(self, value: dict) -> None:
+        """Set the plini attribute of the load state."""
+        self.state.plini = value
+
+    @property
+    def x1(self) -> NDArray[Any]:
+        """Get the x1 attribute of the load state."""
+        return self.state.x1
+
+    @x1.setter
+    def x1(self, value: NDArray[Any]) -> None:
+        """Set the x1 attribute of the load state."""
+        self.state.x1 = value
+
+    @property
+    def x1c(self) -> NDArray[Any]:
+        """Get the x1c attribute of the load state."""
+        return self.state.x1c
+
+    @x1c.setter
+    def x1c(self, value: NDArray[Any]) -> None:
+        """Set the x1c attribute of the load state."""
+        self.state.x1c = value
+
+    @property
+    def x1p(self) -> NDArray[Any]:
+        """Get the x1p attribute of the load state."""
+        return self.state.x1p
+
+    @x1p.setter
+    def x1p(self, value: NDArray[Any]) -> None:
+        """Set the x1p attribute of the load state."""
+        self.state.x1p = value
+
+    @property
+    def x1r(self) -> NDArray[Any]:
+        """Get the x1r attribute of the load state."""
+        return self.state.x1r
+
+    @x1r.setter
+    def x1r(self, value: NDArray[Any]) -> None:
+        """Set the x1r attribute of the load state."""
+        self.state.x1r = value
+
+    @property
+    def x1rc(self) -> NDArray[Any]:
+        """Get the x1rc attribute of the load state."""
+        return self.state.x1rc
+
+    @x1rc.setter
+    def x1rc(self, value: NDArray[Any]) -> None:
+        """Set the x1rc cattribute of the load state."""
+        self.state.x1rc = value
+
+    @property
+    def x1rp(self) -> NDArray[Any]:
+        """Get the x1rp attribute of the load state."""
+        return self.state.x1rp
+
+    @x1rp.setter
+    def x1rp(self, value: NDArray[Any]) -> None:
+        """Set the x1rp attribute of the load state."""
+        self.state.x1rp = value
+
+    @property
+    def x1rt(self) -> NDArray[Any]:
+        """Get the x1rt attribute of the load state."""
+        return self.state.x1rt
+
+    @x1rt.setter
+    def x1rt(self, value: NDArray[Any]) -> None:
+        """Set the x1rt attribute of the load state."""
+        self.state.x1rt = value
+
+    @property
+    def x1t(self) -> NDArray[Any]:
+        """Get the x1t attribute of the load state."""
+        return self.state.x1t
+
+    @x1t.setter
+    def x1t(self, value: NDArray[Any]) -> None:
+        """Set the x1t attribute of the load state."""
+        self.state.x1t = value
+
+    @property
+    def x2(self) -> NDArray[Any]:
+        """Get the x2 attribute of the load state."""
+        return self.state.x2
+
+    @x2.setter
+    def x2(self, value: NDArray[Any]) -> None:
+        """Set the x2 attribute of the load state."""
+        self.state.x2 = value
+
+    @property
+    def x2c(self) -> NDArray[Any]:
+        """Get the x2c attribute of the load state."""
+        return self.state.x2c
+
+    @x2c.setter
+    def x2c(self, value: NDArray[Any]) -> None:
+        """Set the x2c attribute of the load state."""
+        self.state.x2c = value
+
+    @property
+    def x2p(self) -> NDArray[Any]:
+        """Get the x2p attribute of the load state."""
+        return self.state.x2p
+
+    @x2p.setter
+    def x2p(self, value: NDArray[Any]) -> None:
+        """Set the x2p attribute of the load state."""
+        self.state.x2p = value
+
+    @property
+    def x2r(self) -> NDArray[Any]:
+        """Get the x2r attribute of the load state."""
+        return self.state.x2r
+
+    @x2r.setter
+    def x2r(self, value: NDArray[Any]) -> None:
+        """Set the x2r attribute of the load state."""
+        self.state.x2r = value
+
+    @property
+    def x2rc(self) -> NDArray[Any]:
+        """Get the x2rc attribute of the load state."""
+        return self.state.x2rc
+
+    @x2rc.setter
+    def x2rc(self, value: NDArray[Any]) -> None:
+        """Set the x2rc attribute of the load state."""
+        self.state.x2rc = value
+
+    @property
+    def x2rp(self) -> NDArray[Any]:
+        """Get the x2rp attribute of the load state."""
+        return self.state.x2rp
+
+    @x2rp.setter
+    def x2rp(self, value: NDArray[Any]) -> None:
+        """Set the x2rp attribute of the load state."""
+        self.state.x2rp = value
+
+    @property
+    def x3(self) -> NDArray[Any]:
+        """Get the x3 attribute of the load state."""
+        return self.state.x3
+
+    @x3.setter
+    def x3(self, value: NDArray[Any]) -> None:
+        """Set the x3 attribute of the load state."""
+        self.state.x3 = value
+
+    @property
+    def x3c(self) -> NDArray[Any]:
+        """Get the x3c attribute of the load state."""
+        return self.state.x3c
+
+    @x3c.setter
+    def x3c(self, value: NDArray[Any]) -> None:
+        """Set the x3c attribute of the load state."""
+        self.state.x3c = value
+
+    @property
+    def x3r(self) -> NDArray[Any]:
+        """Get the x3r attribute of the load state."""
+        return self.state.x3r
+
+    @x3r.setter
+    def x3r(self, value: NDArray[Any]) -> None:
+        """Set the x3r attribute of the load state."""
+        self.state.x3r = value
+
+    @property
+    def x3rc(self) -> NDArray[Any]:
+        """Get the x3rc attribute of the load state."""
+        return self.state.x3rc
+
+    @x3rc.setter
+    def x3rc(self, value: NDArray[Any]) -> None:
+        """Set the x3rc attribute of the load state."""
+        self.state.x3rc = value
+
+    @property
+    def x3rt(self) -> NDArray[Any]:
+        """Get the x3rt attribute of the load state."""
+        return self.state.x3rt
+
+    @x3rt.setter
+    def x3rt(self, value: NDArray[Any]) -> None:
+        """Set the x3rt attribute of the load state."""
+        self.state.x3rt = value
+
+    @property
+    def x3t(self) -> NDArray[Any]:
+        """Get the x3t attribute of the load state."""
+        return self.state.x3t
+
+    @x3t.setter
+    def x3t(self, value: NDArray[Any]) -> None:
+        """Set the x3t attribute of the load state."""
+        self.state.x3t = value