py-pluto 1.1.4__py3-none-any.whl

pyPLUTO/imagefuncs/plot.py

@@ -0,0 +1,311 @@
+"""PlotManager class."""
+
+from typing import Any
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from pyPLUTO.imagefuncs.imagetools import ImageToolsManager
+from pyPLUTO.imagefuncs.legend import LegendManager
+from pyPLUTO.imagefuncs.range import RangeManager
+from pyPLUTO.imagefuncs.set_axis import AxisManager
+from pyPLUTO.imagemixin import ImageMixin
+from pyPLUTO.imagestate import ImageState
+from pyPLUTO.utils.inspector import track_kwargs
+
+
+class PlotManager(ImageMixin):
+    """PlotManager class.
+
+    It provides methods to create and manage plots in the
+    image. It is designed to work with the Image class and allows for dynamic
+    creation of plots based on the current state of the image. The class uses
+    the AxisManager, ImageToolsManager, LegendManager, and RangeManager to
+    handle the display and plotting of the images, axes, legends, and ranges,
+    respectively.
+    """
+
+    def __init__(self, state: ImageState) -> None:
+        """Initialize the PlotManager with the given state."""
+        self.state = state
+        self.AxisManager = AxisManager(state)
+        self.ImageToolsManager = ImageToolsManager(state)
+        self.LegendManager = LegendManager(state)
+        self.RangeManager = RangeManager(state)
+
+    @track_kwargs
+    def plot(
+        self,
+        x: ArrayLike | list[float],
+        y: ArrayLike | list[float] | None = None,
+        check: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Creation of a 1D function plot (or a 1D slice plot).
+
+        This function plots a 1D function or a 1D slice. It creates a
+        simple figure and a single axis if none are given prior. If a single
+        function argument is given, it plots the graph of that function using
+        a linear variable as x parameter. However, if a pair of arrays is
+        provided, it plots the second as a function of the first one.
+
+        Returns
+        -------
+        - None
+
+        Parameters
+        ----------
+        - alpha: float, default 1.0
+            Sets the opacity of the plot, where 1.0 means total opaque and 0.0
+            means total transparent.
+        - aspect: 'auto' | 'equal' | float, default 'auto'
+            Sets the aspect ratio of the plot.
+            The 'auto' keyword is the default option (most likely the plot will
+            be squared). The 'equal' keyword will set the same scaling for x and
+            y. A float will fix the ratio between the y-scale and the x-scale
+            (1.0 is the same as 'equal').
+        - ax: ax | int | None, default None
+            The axis where to plot the lines. If None, a new axis is created or
+            the last axis is selected.
+        - bottom: float, default 0.1
+            The space from the bottom border to the last row of plots.
+        - c: str, default self.color
+            Determines the line color. If not defined, the program will loop
+            over an array of 10 color which are different for the most common
+            vision deficiencies.
+        - figsize: [float, float], default [8,5]
+            Sets the figure size. The default value is computed from the number
+            of rows and columns.
+        - fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'},
+            default 'full'
+            Sets the marker filling. The default value is the fully filled
+            marker ('full').
+        - fontsize: float, default 17.0
+            Sets the fontsize for all the axes.
+        - grid: bool, default False
+            If enabled, creates a grid on the plot.
+        - label: str, default None
+            Associates a label to each line. Such labels will be used for the
+            creation of the legend.
+        - labelsize: float, default fontsize
+            Sets the labels fontþsize (which is the same for both labels).
+            The default value corresponds to the value of the keyword
+            'fontsize'.
+        - legalpha: float, default 0.8
+            Sets the opacity of the legend.
+        - left: float, default 0.125
+            The space from the left border to the leftmost column of plots.
+        - legcols: int, default 1
+            Sets the number of columns that the legend should have.
+        - legpad: float, default 0.8
+            Sets the space between the lines (or symbols) and the correspondibg
+            text in the legend.
+        - legpos: int | str, default None
+            If enabled, creates a legend. This keyword selects the legend
+            location.
+        - legsize: float, default fontsize
+            Sets the fontsize of the legend. The default value is the default
+            fontsize value.
+        - legspace: float, default 2
+            Sets the space between the legend columns, in font-size units.
+        - ls: {'-', '--', '-.', ':', ' ', ect.}, default '-'
+            Sets the linestyle. The choices available are the ones defined in
+            the matplotlib package. Here are reported the most common ones.
+        - lw: float, default 1.3
+            Sets the linewidth of each line.
+        - marker: {'o', 'v', '^', '<', '>', 'X', ' ', etc.}, default ' '
+            Sets an optional symbol for every point. The default value is no
+            marker (' ').
+        - minorticks: str, default None
+            If not None enables the minor ticks on the plot (for both grid
+            axes).
+        - ms: float, default 3
+            Sets the marker size.
+        - mscale: fload, default 1.0
+            Sets the marker size scale in the legend.
+        - proj: str, default None
+            Custom projection for the plot (e.g. 3D). Recommended only if
+            needed. This keyword should be used only if the axis is created.
+            WARNING: pyPLUTO does not support 3D plotting for now, only 3D axes.
+            The 3D plot feature will be available in future releases.
+        - right: float, default 0.9
+            The space from the right border to the rightmost column of plots.
+        - ticksdir: {'in', 'out'}, default 'in'
+            Sets the ticks direction. The default option is 'in'.
+        - tickssize: float, default fontsize
+            Sets the ticks fontsize (which is the same for both grid axes).
+            The default value corresponds to the value of the keyword
+            'fontsize'.
+        - title: str, default None
+            Places the title of the plot on top of it.
+        - titlesize: float, default fontsize
+            Sets the title fontsize. The default value corresponds to the value
+            of the keyword 'fontsize'.
+        - top: float, default 0.9
+            The space from the top border to the first row of plots.
+        - x (not optional): 1D array
+            This is the x-axis variable. If y is not defined, then this becomes
+            the y-axis variable.
+        - xrange: [float, float], default 'Default'
+            Sets the range in the x-direction. If not defined or set to
+            'Default', the code will compute the range while plotting the data
+            by taking the minimum and the maximum values of the x-array. In case
+            of multiple lines, the code will also adapt to the previous ranges.
+        - xscale: {'linear','log'}, default 'linear'
+            If enabled (and different from default), sets automatically the
+            scale on the x-axis. Data in log scale should be used with the
+            keyword 'log', while data in linear scale should be used with the
+            keyword 'linear'.
+        - xticks: [float] | None | bool, default True
+            If enabled (and different from True), sets manually ticks on
+            x-axis. In order to completely remove the ticks the keyword should
+            be used with None.
+        - xtickslabels: [str] | None | bool, default True
+            If enabled (and different from True), sets manually the ticks
+            labels on the x-axis. In order to completely remove the ticks the
+            keyword should be used with None. Note that fixed tickslabels should
+            always correspond to fixed ticks.
+        - xtitle: str, default None
+            Sets and places the label of the x-axis.
+        - y: 1D array, default [None]
+            The y-axis variable.
+        - yrange: [float, float], default 'Default'
+            Sets the range in the y-direction. If not defined or set to
+            'Default' the code will compute the range while plotting the data by
+            taking the minimum and the maximum values of the y-array. In case of
+            multiple lines, the code will also adapt to the previous ranges. It
+            also adds a small offset.
+        - yscale: {'linear','log'}, default 'linear'
+            If enabled (and different from True), sets automatically the scale
+            on the y-axis. Data in log scale should be used with the keyword
+            'log', while data in linear scale should be used with the keyword
+            'linear'.
+        - yticks: [float] | None | bool, default True
+            If enabled (and different from True), sets manually ticks on
+            y-axis. In order to completely remove the ticks the keyword should
+            be used with None.
+        - ytickslabels: [str] | None | bool, default True
+            If enabled (and different from True), sets manually the ticks
+            labels on the y-axis. In order to completely remove the ticks the
+            keyword should be used with None. Note that fixed tickslabels should
+            always correspond to fixed ticks.
+        - ytitle: str, default None
+            Sets and places the label of the y-axis.
+
+        ----
+
+        Examples
+        --------
+        - Example #1: create a simple plot of y as function of x
+
+            >>> import pyPLUTO as pp
+            >>> I = pp.Image()
+            >>> I.plot(x, y)
+
+        - Example #2: create a plot of y as function of x with custom range of
+            the axes and titles
+
+            >>> import pyPLUTO as pp
+            >>> I = pp.Image()
+            >>> I.plot(x, y, xrange = [0,100], yrange = [0.0,1.0],
+                title = 'y in function of x', xtitle = 'x', ytitle = 'y')
+
+        - Example #3: create a plot with logarithmic scale on y-axis
+
+            >>> import pyPLUTO as pp
+            >>> I = pp.Image()
+            >>> I.plot(x, y, yscale="log")
+
+        - Example #4: create a plot with a legend and custom ticks on x-axis
+
+            >>> import pyPLUTO as pp
+            >>> I = pp.Image()
+            >>> I.plot(x, y, label = 'y', legpos = 'lower right',
+                xticks = [0.2,0.4,0.6,0.8])
+
+        - Example #5: create plots on already existing axes
+
+            >>> import pypLUTO as pp
+            >>> I = pp.Image()
+            >>> I.create_axes(ncol=2)
+            >>> I.plot(x, y, ax=I.ax[0])
+            >>> I.plot(x, y * y, ax=I.ax[1])
+            >>> I.plot(x, z, ax=I.ax[0])
+
+        """
+        # Check parameters
+        kwargs.pop("check", check)
+
+        # If only one argument is given, it is the y-axis
+        if y is None:
+            y = np.asarray(x, dtype=float)
+            x = np.arange(y.size, dtype=float)
+        else:
+            # Convert x and y in numpy arrays
+            x = np.asarray(x, dtype=float)
+            y = np.asarray(y, dtype=float)
+
+        if self.fig is None:
+            raise ValueError(
+                "No figure is present. Please create a figure first."
+            )
+
+        # Set or create figure and axes
+        ax, nax = self.ImageToolsManager.assign_ax(
+            kwargs.pop("ax", None), **kwargs
+        )
+
+        # Set ax parameters
+        self.AxisManager.set_axis(ax=ax, check=False, **kwargs)
+        self.ImageToolsManager.hide_text(nax, ax.texts)
+
+        # Keyword xrange and yrange
+        self.RangeManager.set_xrange(
+            ax,
+            nax,
+            [np.nanmin(x), np.nanmax(x)],
+            self.setax[nax],
+        )
+        self.RangeManager.set_yrange(
+            ax,
+            nax,
+            [np.nanmin(y), np.nanmax(y)],
+            self.setay[nax],
+            data=(x.astype(np.float64), y),
+            #    x=x.astype(np.float64),
+            #    y=y,
+        )
+
+        # Set color line and increase the number of lines (if default color)
+        col_line = kwargs.get(
+            "c", self.color[self.nline[nax] % len(self.color)]
+        )
+        if not kwargs.get("c"):
+            self.nline[nax] = self.nline[nax] + 1
+
+        # Start plotting procedure
+        ax.plot(
+            x,
+            y,
+            c=col_line,
+            ls=kwargs.get("ls", "-"),
+            lw=kwargs.get("lw", 1.3),
+            marker=kwargs.get("marker", ""),
+            ms=kwargs.get("ms", 3.0),
+            label=kwargs.get("label", ""),
+            fillstyle=kwargs.get("fillstyle", "full"),
+        )
+
+        # Creation of the legend
+        self.legpos[nax] = kwargs.get("legpos", self.legpos[nax])
+        if self.legpos[nax] is not None:
+            copy_label: str | None = kwargs.get("label")
+            kwargs["label"] = None
+            self.LegendManager.legend(ax, check=False, fromplot=True, **kwargs)
+            kwargs["label"] = copy_label
+
+        # If tight_layout is enabled, is re-inforced
+        if self.tight:
+            self.fig.tight_layout()
+
+        # End of the function

pyPLUTO/imagefuncs/range.py

@@ -0,0 +1,242 @@
+"""RangeManager class."""
+
+import warnings
+
+import numpy as np
+from matplotlib.axes import Axes
+from numpy.typing import NDArray
+
+from pyPLUTO.imagemixin import ImageMixin
+from pyPLUTO.imagestate import ImageState
+
+
+class RangeManager(ImageMixin):
+    """RangeManager class.
+
+    It provides methods to set the x and y axis limits for a set of axes in a
+    plot.
+    """
+
+    def __init__(self, state: ImageState) -> None:
+        """Initialize the RangeManager with the given state."""
+        self.state = state
+        self.changerange = 0
+        self.adaptrange = 2
+        self.fixrange = 3
+
+    def set_xrange(
+        self, ax: Axes, nax: int, xlim: list[float], case: int
+    ) -> None:
+        """Set the lower and upper limits of the x-axis of a set of axes.
+
+        Returns
+        -------
+        - None
+
+        Parameters
+        ----------
+        - ax (not optional): ax
+            The selected set of axes.
+        - case (not optional): int
+            The case in exam (if range is fixed or variable).
+        - nax (not optional): int
+            The number of the selected set of axes.
+        - xlim (not optional): list[float]
+            The limits of the x-axis.
+
+        ----
+
+        Examples
+        --------
+        - Example #1: Set the x-axis limits of the selected set of axes
+
+            >>> _set_xrange(ax, nax, xlim, case)
+
+        """
+        # Case 0: the x-axis limits are set automatically (no previous limit)
+        if case == self.changerange:
+            ax.set_xlim(xlim[0], xlim[1])
+
+            # Case switched to 2 (previous limits are present now)
+            self.setax[nax] = 2
+
+        # Case 1: limits are already set and they should not be changed
+        #         (aka do nothing)
+
+        # Case 2: the x-axis limit are changed automatically
+        #         (previous limit present)
+        if case == self.adaptrange:
+            xmin = min(xlim[0], ax.get_xlim()[0])
+            xmax = max(xlim[1], ax.get_xlim()[1])
+            ax.set_xlim(xmin, xmax)
+
+        # Case 3: x-axis limits are set manually
+        if case == self.fixrange:
+            ax.set_xlim(xlim[0], xlim[1])
+
+            # Case switched to 1 (no change unless stated explicitly otherwise)
+            self.setax[nax] = 1
+
+        # End of the function
+
+    def set_yrange(
+        self,
+        ax: Axes,
+        nax: int,
+        ylim: list[float],
+        case: int,
+        data: tuple[NDArray[np.float64] | None, NDArray[np.float64] | None] = (
+            None,
+            None,
+        ),
+        # x: NDArray[np.float64] | None = None,
+        # y: NDArray[np.float64] | None = None,
+    ) -> None:
+        """Set the lower and upper limits of the y-axis of a set of.
+
+        Unlike the x-axis, the y-axis limits are recovered depending on both the
+        x-data and the y-data.
+
+        Returns
+        -------
+        - None
+
+        Parameters
+        ----------
+        - ax (not optional): ax
+            The selected set of axes.
+        - case (not optional): int
+            The case in exam (if range is fixed or variable).
+        - nax (not optional): int
+            The number of the selected set of axes.
+        - x: np.ndarray
+            The x-array (to limit the y-range automatically).
+        - y: np.ndarray
+            The y-array (to limit the y-range automatically).
+        - ylim (not optional): list[float]
+            The limits of the y-axis.
+
+
+        ----
+
+        Examples
+        --------
+        - Example #1: Set the y-axis limits of the selected set of axes
+
+            >>> _set_yrange(ax, nax, ylim, case)
+
+        """
+        x, y = data
+        # Case 0: the y-axis limits are set automatically (no previous limit)
+        if case == self.changerange:
+            if x is None or y is None:
+                raise ValueError("x and y arrays must be provided if case is 0")
+
+            # Find the limits of the x-axis
+            yrange = np.where(np.logical_and(x >= x.min(), x <= x.max()))
+            smally = y[yrange]
+
+            # Extend slightly the range
+            ymin, ymax = self.range_offset(
+                smally.min(), smally.max(), self.yscale[nax]
+            )
+            # ymin   = smally.min() - 0.02*np.abs(smally.min())
+            # ymax   = smally.max() + 0.02*np.abs(smally.max())
+            ax.set_ylim(ymin, ymax)
+
+            # Switch to case 2 (previous limits are present now)
+            self.setay[nax] = 2
+
+        # Case 1: limits are already set and they should not be changed
+        # (aka do nothing)
+
+        # Case 2: the y-axis limit are changed automatically
+        # (previous limit present)
+        if case == self.adaptrange:
+            if x is None or y is None:
+                raise ValueError("x and y arrays must be provided if case is 2")
+
+            # Find the limits of the x-axis
+            yrange = np.where(np.logical_and(x >= x.min(), x <= x.max()))
+            smally = y[yrange]
+
+            # Extend slightly the range (not perfect method)
+            ymin, ymax = self.range_offset(
+                smally.min(), smally.max(), self.yscale[nax]
+            )
+            # ymin   = smally.min() - 0.02*np.abs(smally.min())
+            # ymax   = smally.max() + 0.02*np.abs(smally.max())
+
+            # Check if the limits should be changed
+            ymin = np.minimum(ymin, ax.get_ylim()[0])
+            ymax = np.maximum(ymax, ax.get_ylim()[1])
+            ax.set_ylim(ymin, ymax)
+
+        # Case 3: y-axis limits must be set manually
+        if case == self.fixrange:
+            ax.set_ylim(ylim[0], ylim[1])
+
+            # Case switched to 1 (no change unless stated explicitly otherwise)
+            self.setay[nax] = 1
+
+        # End of the function
+
+    def range_offset(
+        self, ymin: float, ymax: float, scale: str, margin: float = 0.1
+    ) -> tuple[float, float]:
+        """Return the offsetted data range for the y-axis limits.
+
+        Returns
+        -------
+        - ymin: float
+            The lower limit of the y-axis.
+        - ymax: float
+            The upper limit of the y-axis.
+
+        Parameters
+        ----------
+        - ymin (not optional): float
+            The lower limit of the y-axis.
+        - ymax (not optional): float
+            The upper limit of the y-axis.
+        - scale (not optional): str
+            The scale of the y-axis.
+        - margin (optional): float
+            The margin of the data range.
+
+        ----
+
+        Examples
+        --------
+        - Example #1: Set the y-axis limits of the selected set of axes
+
+            >>> ymin, ymax = _range_offset(ymin, ymax, scale)
+
+        """
+        # Find the data range
+        data_range = ymax - ymin
+        if data_range == 0:
+            data_range = ymax * 0.1
+
+        # Find the padding (with non-inear scale adjustments)
+        padding = margin * data_range
+        range_maxval = 10
+        if np.log10(np.abs(data_range)) > range_maxval and scale != "linear":
+            padding *= 2 * np.abs(np.log10(np.abs(data_range)))
+            print(padding)
+
+        # Set the limits (additional check if the scale is logarithmic)
+        if scale in ["linear", "symlog", "asinh"]:
+            return (ymin - padding, ymax + padding)
+        if scale == "log":
+            if ymin <= 0 or ymax <= 0:
+                ymin = min(np.abs(ymin), np.abs(ymax))
+                ymax = max(np.abs(ymin), np.abs(ymax))
+                warnings.warn(
+                    "Negative range for logarithmic scale!",
+                    UserWarning,
+                    stacklevel=2,
+                )
+            return (max(ymin - padding, ymin * 0.5), ymax + padding)
+
+        return (ymin, ymax)