py-pluto 1.1.4__py3-none-any.whl

pyPLUTO/gui/main_window.py

@@ -0,0 +1,177 @@
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QMainWindow,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+from .globals import cmaps_avail, cmaps_divided, format_avail, scales, vscales
+
+
+class PyPLUTOApp(QMainWindow):
+    def __init__(self, code: str):
+        super().__init__()
+        codestr = f" ({self.code:= code})" if code != "PLUTO" else ""
+        self.setWindowTitle(f"PyPLUTO GUI{codestr}")
+        if code != "PLUTO":
+            raise NotImplementedError(f"Code {code} not yet implemented")
+
+        self.folder_path = None
+        self.datatype = None
+        self.data_loaded = False
+
+        main_widget = QWidget()
+        self.setCentralWidget(main_widget)
+        main_layout = QHBoxLayout(main_widget)
+
+        # Left control panel
+        button_layout = QVBoxLayout()
+
+        layout = QHBoxLayout()
+        self.add_combobox(
+            "datatype_selector",
+            layout,
+            ["PLUTO fluid", "PLUTO particles", "ECHO"],
+        )
+        self.add_label("Preferred format:", layout)
+        self.add_combobox("format_selector", layout, format_avail)
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_label("nout:", layout)
+        self.add_lineedit("outtext", layout, "nout")
+        self.add_label("vars:", layout)
+        self.add_lineedit("varstext", layout, "vars")
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_pushbutton("Select File", layout, self.select_folder)
+        self.add_pushbutton("Clear", layout, self.clearload)
+        self.add_pushbutton("Reload Folder", layout, self.reload_data)
+        button_layout.addLayout(layout)
+
+        self.add_line(button_layout)
+
+        layout = QHBoxLayout()
+        self.add_label("Select the variable to plot:", layout)
+        self.add_combobox("var_selector", layout, [])
+        self.add_checkbox("Transpose", layout, "transpose_checkbox")
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_label("Select the x-axis:", layout)
+        self.add_combobox("xaxis_selector", layout, [], 100)
+        self.add_label("y-axis:", layout)
+        self.add_combobox("yaxis_selector", layout, [], 100)
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_label("Slices: x", layout)
+        self.add_lineedit("xslicetext", layout, "x-slice")
+        self.add_label("y", layout)
+        self.add_lineedit("yslicetext", layout, "y-slice")
+        self.add_label("z", layout)
+        self.add_lineedit("zslicetext", layout, "z-slice")
+        button_layout.addLayout(layout)
+
+        self.add_line(button_layout)
+
+        layout = QHBoxLayout()
+        self.add_label("Insert Title:", layout)
+        self.add_lineedit("plot_title", layout, "title")
+        self.add_checkbox("Auto-ratio", layout, "ratio_checkbox")
+        self.ratio_checkbox.setChecked(True)  # type: ignore
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_label("xrange:", layout)
+        self.add_lineedit("xrange_min", layout, "xmin")
+        self.add_lineedit("xrange_max", layout, "xmax")
+        self.add_label("x-scale:", layout)
+        self.add_combobox("xscale_selector", layout, scales)
+        self.add_lineedit("xscale_tresh", layout, "x-tresh")
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_label("yrange:", layout)
+        self.add_lineedit("yrange_min", layout, "ymin")
+        self.add_lineedit("yrange_max", layout, "ymax")
+        self.add_label("y-scale:", layout)
+        self.add_combobox("yscale_selector", layout, scales)
+        self.add_lineedit("yscale_tresh", layout, "y-tresh")
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_label("vrange:", layout)
+        self.add_lineedit("vrange_min", layout, "vmin")
+        self.add_lineedit("vrange_max", layout, "vmax")
+        self.add_label("v-scale:", layout)
+        self.add_combobox("vscale_selector", layout, vscales)
+        self.add_lineedit("vscale_tresh", layout, "v-tresh")
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_label("cmap:", layout)
+        self.add_combobox("typecmap_selector", layout, cmaps_divided.keys())
+        self.add_combobox("cmap_selector", layout, cmaps_avail)
+        self.add_checkbox("reverse", layout, "reverse_checkbox")
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_pushbutton("Plot", layout, self.plot_data)
+        self.add_checkbox("Overplot       ", layout, "overplot_checkbox")
+        button_layout.addLayout(layout)
+
+        layout = QHBoxLayout()
+        self.add_pushbutton("Update plot", layout, self.update_axes)
+        self.add_pushbutton("Clear", layout, self.clear_labels)
+        self.add_pushbutton("Reload Canvas", layout, self.reload_canvas)
+        button_layout.addLayout(layout)
+
+        self.add_line(button_layout)
+
+        info_box = QTextEdit()
+        info_box.setObjectName("info_label")
+        info_box.setReadOnly(True)
+        info_box.setFixedSize(370, 200)  # keep your original fixed size
+        button_layout.addWidget(info_box)
+        self.info_label = info_box
+
+        self.add_line(button_layout)
+
+        main_layout.addLayout(button_layout)
+
+        self.typecmap_selector.currentIndexChanged.connect(
+            self.update_cmap_selector
+        )  # type: ignore
+
+        self.canvas_layout = QVBoxLayout()
+        self.create_new_figure()
+        main_layout.addLayout(self.canvas_layout)
+
+    from .config import (
+        _finalize_load_path,
+        clearload,
+        load_data,
+        reload_data,
+        select_folder,
+    )
+    from .panels import (
+        add_checkbox,
+        add_combobox,
+        add_label,
+        add_line,
+        add_lineedit,
+        add_pushbutton,
+    )
+    from .utils import (
+        check_axisparam,
+        clear_labels,
+        create_new_figure,
+        plot_data,
+        reload_canvas,
+        set_range,
+        update_axes,
+        update_cmap_selector,
+    )

pyPLUTO/gui/panels.py

@@ -0,0 +1,66 @@
+"""Utility functions to add common widgets to a layout."""
+
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QFrame,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+)
+
+
+def add_line(self, control_layout):
+    line = QFrame()
+    line.setFrameShape(QFrame.Shape.HLine)
+    line.setFrameShadow(QFrame.Shadow.Sunken)
+    control_layout.addWidget(line)
+
+
+def add_combobox(self, label, control_layout, data, width=None, height=None):
+    combo_box = QComboBox()
+    setattr(self, label, combo_box)
+    combo_box.addItems(data)
+    if isinstance(width, int):
+        combo_box.setFixedWidth(width)
+    control_layout.addWidget(combo_box)
+
+
+def add_label(self, label, control_layout, data=None, width=None, height=None):
+    labelgui = QLabel(label)
+    if isinstance(width, int):
+        labelgui.setFixedWidth(width)
+    if isinstance(height, int):
+        labelgui.setFixedHeight(height)
+    if data is not None:
+        setattr(self, data, labelgui)
+    control_layout.addWidget(labelgui)
+
+
+def add_lineedit(
+    self, label, control_layout, data=None, width=None, height=None
+):
+    lineedit = QLineEdit()
+    setattr(self, label, lineedit)
+    lineedit.setPlaceholderText(data)
+    if isinstance(width, int):
+        lineedit.setFixedWidth(width)
+    control_layout.addWidget(lineedit)
+
+
+def add_checkbox(
+    self, label, control_layout, data=None, width=None, height=None
+):
+    checkbox = QCheckBox(label)
+    if data is not None:
+        setattr(self, data, checkbox)
+    control_layout.addWidget(checkbox)
+
+
+def add_pushbutton(self, label, control_layout, data=None, width=None):
+    pushbutton = QPushButton(label)
+    setattr(self, label, pushbutton)
+    if isinstance(width, int):
+        pushbutton.setFixedWidth(width)
+    pushbutton.clicked.connect(data)  # type: ignore
+    control_layout.addWidget(pushbutton)

pyPLUTO/gui/utils.py

@@ -0,0 +1,273 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.backends.backend_qtagg import (
+    NavigationToolbar2QT as NavigationToolbar,
+)
+
+import pyPLUTO as pp
+
+from .globals import cmaps_divided as cmaps
+
+
+def update_cmap_selector(self):
+    selected_type = self.typecmap_selector.currentText()
+    self.cmap_selector.clear()
+    self.cmap_selector.addItems(cmaps.get(selected_type, []))
+
+
+def clear_labels(self):
+    self.var_selector.setCurrentIndex(0)
+    self.ratio_checkbox.setChecked(True)
+    self.transpose_checkbox.setChecked(False)
+    self.xaxis_selector.setCurrentIndex(0)
+    self.yaxis_selector.setCurrentIndex(0)
+    self.xslicetext.clear()
+    self.yslicetext.clear()
+    self.zslicetext.clear()
+    self.plot_title.clear()
+    self.xrange_min.clear()
+    self.xrange_max.clear()
+    self.yrange_min.clear()
+    self.yrange_max.clear()
+    self.vrange_min.clear()
+    self.vrange_max.clear()
+    self.xscale_selector.setCurrentIndex(0)
+    self.yscale_selector.setCurrentIndex(0)
+    self.vscale_selector.setCurrentIndex(0)
+    self.xscale_tresh.clear()
+    self.yscale_tresh.clear()
+    self.vscale_tresh.clear()
+    self.typecmap_selector.setCurrentIndex(0)
+    self.cmap_selector.setCurrentIndex(0)
+    self.reverse_checkbox.setChecked(False)
+    self.overplot_checkbox.setChecked(False)
+
+
+def update_axes(self):
+    self.check_axisparam()
+    cmap = self.datadict.pop("cmap")
+    cscale = self.datadict.pop("cscale")
+    vmin = self.datadict.pop("vmin", self.var.min())
+    vmax = self.datadict.pop("vmax", self.var.max())
+    ctresh = self.datadict.pop("tresh", max(np.abs(vmin), vmax) * 0.01)
+    norm = self.I.ImageToolsManager.set_cscale(cscale, vmin, vmax, ctresh)
+    for artist in self.I.ax[0].get_children():
+        if isinstance(
+            artist,
+            (
+                plt.matplotlib.image.AxesImage,
+                plt.matplotlib.collections.QuadMesh,
+            ),
+        ):
+            artist.set_cmap(cmap)
+            artist.set_norm(norm)
+
+    self.set_range(xlim=None, ylim=None)
+    self.I.set_axis(self.I.ax[0], **self.datadict)
+    self.datadict["cmap"] = cmap
+    self.datadict["cscale"] = cscale
+    self.datadict["tresh"] = ctresh
+    self.canvas.figure = self.I.fig
+    self.canvas.draw()
+
+
+def get_slice(text, axis_length):
+    try:
+        return eval(f"np.s_[{text}]", {"np": np, "axis_length": axis_length})
+    except Exception:
+        return int(text) if text.isdigit() else None
+
+
+def plot_data(self):
+    if not self.data_loaded:
+        print("ERROR: No data loaded.")
+        return
+
+    var_name = self.var_selector.currentText()
+    if not var_name:
+        print("ERROR: No variable selected.")
+        return
+
+    self.var = getattr(self.D, var_name)
+
+    self.var = self.var.T if self.transpose_checkbox.isChecked() else self.var
+    # Apply slicing if a valid text is provided
+    if self.zslicetext.text() and np.ndim(self.var) == 3:
+        self.zslice = get_slice(self.zslicetext.text(), self.var.shape[2])
+        self.var = self.var[:, :, self.zslice]
+
+    if self.yslicetext.text() and np.ndim(self.var) > 1:
+        self.yslice = get_slice(self.yslicetext.text(), self.var.shape[1])
+        self.var = self.var[:, self.yslice]
+
+    if self.xslicetext.text():
+        self.xslice = get_slice(self.xslicetext.text(), self.var.shape[0])
+        self.var = self.var[self.xslice]
+
+    self.vardim = len(np.shape(self.var))
+    if self.vardim < 1 or self.vardim > 2:
+        raise ValueError("ERROR: Variable shape not recognized.")
+    self.check_axisparam()
+
+    if self.D.geom == "POLAR":
+        convert_axis = {
+            "R": "x1",
+            "phi": "x2",
+            "z": "x3",
+            "x": "x1c",
+            "y": "x2c",
+        }
+    elif self.D.geom == "SPHERICAL":
+        convert_axis = {
+            "r": "x1",
+            "theta": "x2",
+            "phi": "x3",
+            "R": "x1p",
+            "z": "x2p",
+            "rt": "x1t",
+            "zt": "x3t",
+        }
+    else:
+        convert_axis = {"x": "x1", "y": "x2", "z": "x3"}
+
+    axis_convert = {
+        key: (val if self.vardim == 1 else val[:2] + "r" + val[2:])
+        for key, val in convert_axis.items()
+    }
+
+    if self.overplot_checkbox.isChecked() and self.vardim == 1:
+        self.numlines = self.numlines + 1 if self.numlines > 0 else 1
+    else:
+        self.reload_canvas()
+        self.numlines = 1
+
+    x1 = getattr(self.D, axis_convert[self.xaxis_selector.currentText()])
+    x2 = getattr(self.D, axis_convert[self.yaxis_selector.currentText()])
+
+    xlim = [x1.min(), x1.max()]
+    ylim = (
+        [x2.min(), x2.max()]
+        if self.vardim == 2
+        else [self.var.min(), self.var.max()]
+    )
+
+    self.set_range(xlim, ylim)
+
+    if self.vardim == 1:
+        cmap_temp = self.datadict.pop("cmap")
+        cscale_temp = self.datadict.pop("cscale")
+        ctresh_temp = self.datadict.pop("tresh", None)
+        self.I.plot(x1, self.var, **self.datadict, xtitle=" ", ytitle=" ")
+        self.datadict["cmap"] = cmap_temp
+        self.datadict["cscale"] = cscale_temp
+        if ctresh_temp is not None:
+            self.datadict["tresh"] = ctresh_temp
+    elif self.vardim == 2:
+        self.I.display(
+            self.var,
+            x1=x1,
+            x2=x2,
+            cpos="right",
+            **self.datadict,
+            xtitle=" ",
+            ytitle=" ",
+            clabel=" ",
+        )
+
+    self.firstplot = False
+    self.canvas.draw()
+
+
+def create_new_figure(self):
+    self.I = pp.Image(figsize=[10, 6])
+    self.firstplot = True
+    self.figure = self.I.fig
+    print(self.I.fontsize, self.I.figsize)
+
+    self.canvas = FigureCanvas(self.figure)
+    self.toolbar = NavigationToolbar(self.canvas, self)
+    self.canvas.setFixedWidth(800)
+
+    # Add a new toolbar and canvas to the layout
+    self.canvas_layout.addWidget(self.toolbar)
+    self.canvas_layout.addWidget(self.canvas)
+
+
+def reload_canvas(self):
+    # Remove old toolbar and canvas
+    self.canvas_layout.removeWidget(self.toolbar)
+    self.toolbar.deleteLater()
+    self.canvas_layout.removeWidget(self.canvas)
+    self.canvas.deleteLater()
+    self.create_new_figure()
+
+
+def check_axisparam(self):
+    self.datadict = {}
+    if self.vrange_min.text():
+        self.datadict["vmin"] = float(self.vrange_min.text())
+    if self.vrange_max.text():
+        self.datadict["vmax"] = float(self.vrange_max.text())
+
+    if not self.ratio_checkbox.isChecked():
+        self.datadict["aspect"] = "equal"
+    else:
+        self.datadict["aspect"] = "auto"
+
+    self.datadict["cmap"] = self.cmap_selector.currentText()
+    if self.reverse_checkbox.isChecked():
+        if self.datadict["cmap"][-2:] == "_r":
+            self.datadict["cmap"] = self.datadict["cmap"][:-2]
+        else:
+            self.datadict["cmap"] += "_r"
+
+    self.datadict["title"] = (
+        self.plot_title.text() if self.plot_title.text() else ""
+    )
+
+    self.datadict["xscale"] = self.xscale_selector.currentText()
+    if self.xscale_tresh.text():
+        self.datadict["xtresh"] = float(self.xscale_tresh.text())
+
+    self.datadict["yscale"] = self.yscale_selector.currentText()
+    if self.yscale_tresh.text():
+        self.datadict["ytresh"] = float(self.yscale_tresh.text())
+
+    self.datadict["cscale"] = self.vscale_selector.currentText()
+    if self.vscale_tresh.text():
+        self.datadict["tresh"] = float(self.vscale_tresh.text())
+
+
+def set_range(self, xlim, ylim):
+    if xlim is None:
+        xlim = [self.xmin, self.xmax]
+    if ylim is None:
+        ylim = [self.ymin, self.ymax]
+
+    if self.firstplot is True:
+        self.xmin, self.xmax = xlim
+        self.ymin, self.ymax = ylim
+    else:
+        self.xmin = np.minimum(xlim[0], self.xmin)
+        self.xmax = np.maximum(xlim[1], self.xmax)
+        self.ymin = np.minimum(ylim[0], self.ymin)
+        self.ymax = np.maximum(ylim[1], self.ymax)
+
+    ymin, ymax = (
+        self.I.RangeManager.range_offset(
+            self.ymin, self.ymax, self.yscale_selector.currentText()
+        )
+        if self.vardim == 1
+        else (self.ymin, self.ymax)
+    )
+
+    self.datadict["xrange"] = [
+        float(self.xrange_min.text()) if self.xrange_min.text() else self.xmin,
+        float(self.xrange_max.text()) if self.xrange_max.text() else self.xmax,
+    ]
+
+    self.datadict["yrange"] = [
+        float(self.yrange_min.text()) if self.yrange_min.text() else ymin,
+        float(self.yrange_max.text()) if self.yrange_max.text() else ymax,
+    ]

pyPLUTO/h_pypluto.py

@@ -0,0 +1,84 @@
+"""Helper functions for pyPLUTO."""
+
+import warnings
+
+
+def makelist[T](el: T | list[T]) -> list[T]:
+    """If the element is not a list, it converts it into a list.
+
+    Returns
+    -------
+    - list[Any]
+        The list of chosen elements.
+
+    Parameters
+    ----------
+    - el (not optional): Any
+        The element to be converted into a list.
+
+    ----
+
+    Examples
+    --------
+    - Example #1: element is a list
+
+        >>> makelist([1, 2, 3])
+        [1,2,3]
+
+    - Example #2: element is not a list
+
+        >>> makelist(1)
+        [1]
+
+    """
+    # Return the element as a list
+    return el if isinstance(el, list) else [el]
+
+
+def check_par(par: set[str], func: str, **kwargs: object) -> None:
+    """Check the kwargs of a PyPLUTO function/method.
+
+    Checks if a parameter is in the corresponding list depending on
+    the function. If the parameter does not belong to the list it raises
+    a warning.
+
+    Returns
+    -------
+    - None
+
+    Parameters
+    ----------
+    - func (not optional): str
+        The name of the function.
+    - par (not optional): list[str]
+        The function correct parameters.
+    - **kwargs: dict
+        The selected parameters.
+
+    ----
+
+    Examples
+    --------
+    - Example #1: check if the parameters are in the list (no warning)
+
+        **kwargs = {'a': 1, 'b': 2, 'c': 3}
+        >>> check_par({"a", "b", "c"}, "func", **kwargs)
+
+    - Example #2: check if the parameters are in the list (raises warning)
+
+        **kwargs = {'a': 1, 'd': 2, 'c': 3}
+        >>> check_par({"a", "b", "c"}, "func", **kwargs)
+
+    """
+    # Check if the parameters are in the list
+    notfound: list[str] = [(i) for i in kwargs if i not in par]
+
+    # If the parameters are not in the list, raise a warning
+    if len(notfound) > 0:
+        warn = (
+            f"WARNING: elements {notfound!s} not found!"
+            f"Please check your spelling! (function {func})"
+        )
+        warnings.warn(warn, UserWarning, stacklevel=2)
+
+    # End of the function