ansys-fluent-visualization 0.16.dev0__tar.gz → 0.17.dev0__tar.gz

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: ansys-fluent-visualization
-Version: 0.16.dev0
+Version: 0.17.dev0
 Summary: A python wrapper for ansys Fluent visualization
 Home-page: https://github.com/ansys/pyfluent-visualization
 License: MIT
@@ -17,12 +17,15 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: ansys-fluent-core (>=0.28.dev0,<1.0)
+Requires-Dist: ansys-fluent-core (>=0.29.dev0,<1.0)
+Requires-Dist: imageio (>=2.36.1)
 Requires-Dist: importlib-metadata (>=4.0,<5.0) ; python_version < "3.9"
-Requires-Dist: matplotlib (>=3.9.0)
-Requires-Dist: pyside6 (>=6.7.2,<6.8.0)
-Requires-Dist: pyvista (>=0.44.1,<0.45.0)
+Requires-Dist: matplotlib (>=3.6.0)
+Requires-Dist: plotly (>=5.24.0)
+Requires-Dist: pyside6 (>=6.8.1,<6.9.0)
+Requires-Dist: pyvista[jupyter] (>=0.44.0)
 Requires-Dist: pyvistaqt (>=0.11.1,<0.12.0)
+Requires-Dist: vtk (<9.4.0) ; python_version < "3.13"
 Project-URL: Documentation, https://visualization.fluent.docs.pyansys.com/
 Project-URL: Repository, https://github.com/ansys/pyfluent-visualization
 Project-URL: Source, https://github.com/ansys/pyfluent-visualization
@@ -82,7 +85,7 @@ the project support team, email `pyansys.core@ansys.com <pyansys.core@ansys.com>
 Installation
 ------------
 The ``ansys-fluent-visualization`` package supports Python 3.10 through Python
-3.12 on Windows and Linux.
+3.13 on Windows and Linux.
 
 If you are using Python 3.10, download and install the wheel file for the ``vtk`` package from
 `here for Windows <https://github.com/pyvista/pyvista-wheels/raw/main/vtk-9.1.0.dev0-cp310-cp310-win_amd64.whl>`_

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/README.rst

@@ -51,7 +51,7 @@ the project support team, email `pyansys.core@ansys.com <pyansys.core@ansys.com>
 Installation
 ------------
 The ``ansys-fluent-visualization`` package supports Python 3.10 through Python
-3.12 on Windows and Linux.
+3.13 on Windows and Linux.
 
 If you are using Python 3.10, download and install the wheel file for the ``vtk`` package from
 `here for Windows <https://github.com/pyvista/pyvista-wheels/raw/main/vtk-9.1.0.dev0-cp310-cp310-win_amd64.whl>`_

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 [tool.poetry]
 # Check https://python-poetry.org/docs/pyproject/ for all available sections
 name = "ansys-fluent-visualization"
-version = "0.16.dev0"
+version = "0.17.dev0"
 description = "A python wrapper for ansys Fluent visualization"
 license = "MIT"
 authors = ["ANSYS, Inc. <ansys.support@ansys.com>"]
@@ -25,11 +25,14 @@ packages = [
 [tool.poetry.dependencies]
 python = ">=3.10,<4.0"
 importlib-metadata = {version = "^4.0", python = "<3.9"}
-ansys-fluent-core = "~=0.28.dev0"
-pyvista = "~=0.44.1"
+ansys-fluent-core = "~=0.29.dev0"
+pyvista = { version = ">=0.44.0", extras = ["jupyter"]}
+matplotlib = ">=3.6.0"
+vtk = {version = "<9.4.0", python = "<3.13"}
 pyvistaqt = "~=0.11.1"
-pyside6 = "~=6.7.2"
-matplotlib = ">=3.9.0"
+pyside6 = "~=6.8.1"
+plotly = ">=5.24.0"
+imageio= ">=2.36.1"
 
 [tool.poetry.urls]
 "Documentation" = "https://visualization.fluent.docs.pyansys.com/"

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/src/ansys/fluent/visualization/__init__.py

@@ -5,9 +5,10 @@ try:
 except ModuleNotFoundError:
     import importlib_metadata
 
-_VERSION_INFO = "Build date: November 28, 2024 14:47 UTC ShaID: 463438b"
+_VERSION_INFO = "Build date: January 06, 2025 09:12 UTC ShaID: a7bfb72"
 __version__ = importlib_metadata.version(__name__.replace(".", "-"))
 PLOTTER = "matplotlib"
+INTERACTIVE = False
 
 
 def version_info() -> str:

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/src/ansys/fluent/visualization/_config.py

@@ -11,10 +11,13 @@ def get_config() -> dict:
     config : dict
         Keys are parameter names that can be passed to :func:`set_config`.
     """
+    import ansys.fluent.visualization as pyviz
+
+    _global_config["blocking"] = not pyviz.INTERACTIVE
     return _global_config.copy()
 
 
-def set_config(blocking: bool = True, set_view_on_display: str = "isometric"):
+def set_config(blocking: bool = False, set_view_on_display: str = "isometric"):
     """Set visualization configuration.
 
     Parameters

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/src/ansys/fluent/visualization/graphics/graphics_windows.py

@@ -1,6 +1,8 @@
 """A wrapper to improve the user interface of graphics."""
 
+from ansys.fluent.visualization import get_config
 from ansys.fluent.visualization.graphics import graphics_windows_manager
+from ansys.fluent.visualization.plotter.plotter_windows import PlotterWindow
 
 
 class GraphicsWindow:
@@ -14,6 +16,7 @@ class GraphicsWindow:
         object,
         position: tuple = (0, 0),
         opacity: float = 1,
+        title: str = "",
     ) -> None:
         """Add data to a plot.
 
@@ -25,27 +28,43 @@ class GraphicsWindow:
             Position of the sub-plot.
         opacity: float, optional
             Transparency of the sub-plot.
+        title: str, optional
+            Title of the sub-plot (only for plots).
         """
         self._graphics_objs.append({**locals()})
 
+    def _all_plt_objs(self):
+        from ansys.fluent.core.post_objects.post_object_definitions import PlotDefn
+
+        for obj in self._graphics_objs:
+            if not isinstance(obj["object"].obj, PlotDefn):
+                return False
+        return True
+
     def show(self) -> None:
         """Render the objects in window and display the same."""
         self.window_id = graphics_windows_manager.open_window(grid=self._grid)
-        self.graphics_window = graphics_windows_manager._post_windows.get(
-            self.window_id
-        )
-        self._renderer = self.graphics_window.renderer
-        self.plotter = self.graphics_window.renderer.plotter
-        for i in range(len(self._graphics_objs)):
-            graphics_windows_manager.add_graphics(
-                object=self._graphics_objs[i]["object"].obj,
-                window_id=self.window_id,
-                fetch_data=True,
-                overlay=True,
-                position=self._graphics_objs[i]["position"],
-                opacity=self._graphics_objs[i]["opacity"],
+        if self._all_plt_objs() and get_config()["blocking"]:
+            p = PlotterWindow(grid=self._grid)
+            for obj in self._graphics_objs:
+                p.add_plots(obj["object"], position=obj["position"], title=obj["title"])
+            p.show(self.window_id)
+        else:
+            self.graphics_window = graphics_windows_manager._post_windows.get(
+                self.window_id
             )
-        graphics_windows_manager.show_graphics(self.window_id)
+            self._renderer = self.graphics_window.renderer
+            self.plotter = self.graphics_window.renderer.plotter
+            for i in range(len(self._graphics_objs)):
+                graphics_windows_manager.add_graphics(
+                    object=self._graphics_objs[i]["object"].obj,
+                    window_id=self.window_id,
+                    fetch_data=True,
+                    overlay=True,
+                    position=self._graphics_objs[i]["position"],
+                    opacity=self._graphics_objs[i]["opacity"],
+                )
+            graphics_windows_manager.show_graphics(self.window_id)
 
     def save_graphic(
         self,

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/src/ansys/fluent/visualization/graphics/graphics_windows_manager.py

@@ -2,19 +2,30 @@
 
 from enum import Enum
 import itertools
+import os
 import threading
 from typing import Dict, List, Optional, Union
 
 from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.post_objects.check_in_notebook import in_notebook
-from ansys.fluent.core.post_objects.post_object_definitions import GraphicsDefn
+from ansys.fluent.core.post_objects.post_object_definitions import (
+    GraphicsDefn,
+    PlotDefn,
+)
 from ansys.fluent.core.post_objects.singleton_meta import AbstractSingletonMeta
 import numpy as np
 import pyvista as pv
-from pyvistaqt import BackgroundPlotter
+
+try:
+    from pyvistaqt import BackgroundPlotter
+except ModuleNotFoundError:
+    BackgroundPlotter = None
 
 from ansys.fluent.visualization import get_config
-from ansys.fluent.visualization.post_data_extractor import FieldDataExtractor
+from ansys.fluent.visualization.post_data_extractor import (
+    FieldDataExtractor,
+    XYPlotDataExtractor,
+)
 from ansys.fluent.visualization.post_windows_manager import (
     PostWindow,
     PostWindowsManager,
@@ -74,6 +85,10 @@ class GraphicsWindow(PostWindow):
         obj = self.post_object
         if obj.__class__.__name__ == "Surface":
             self._fetch_surface(obj)
+        elif obj.__class__.__name__ == "XYPlot":
+            self._fetch_xy_data(obj)
+        elif obj.__class__.__name__ == "MonitorPlot":
+            self._fetch_monitor_data(obj)
         else:
             self._fetch_data(obj, FieldDataType(obj.__class__.__name__))
 
@@ -106,6 +121,10 @@ class GraphicsWindow(PostWindow):
             self._display_vector(obj, position, opacity)
         elif obj.__class__.__name__ == "Pathlines":
             self._display_pathlines(obj, position, opacity)
+        elif obj.__class__.__name__ == "XYPlot":
+            self._display_xy_plot(position, opacity)
+        elif obj.__class__.__name__ == "MonitorPlot":
+            self._display_monitor_plot(position, opacity)
         if self.animate:
             self.renderer.write_frame()
         self.renderer._set_camera(get_config()["set_view_on_display"])
@@ -162,6 +181,31 @@ class GraphicsWindow(PostWindow):
     def _fetch_surface(self, obj):
         self._fetch_or_display_surface(obj, fetch=True)
 
+    def _fetch_xy_data(self, obj):
+        self._data["XYPlot"] = XYPlotDataExtractor(obj).fetch_data()
+        self._data["XYPlot"]["properties"] = {
+            "curves": list(self._data["XYPlot"]),
+            "title": "XY Plot",
+            "xlabel": "position",
+            "ylabel": obj.y_axis_function(),
+        }
+
+    def _fetch_monitor_data(self, obj):
+        monitors = obj._api_helper.monitors
+        indices, columns_data = monitors.get_monitor_set_data(obj.monitor_set_name())
+        xy_data = {}
+        for column_name, column_data in columns_data.items():
+            xy_data[column_name] = {"xvalues": indices, "yvalues": column_data}
+        monitor_set_name = obj.monitor_set_name()
+        self._data["MonitorPlot"] = xy_data
+        self._data["MonitorPlot"]["properties"] = {
+            "curves": list(xy_data.keys()),
+            "title": monitor_set_name,
+            "xlabel": monitors.get_monitor_set_prop(monitor_set_name, "xlabel"),
+            "ylabel": monitors.get_monitor_set_prop(monitor_set_name, "ylabel"),
+            "yscale": "log" if monitor_set_name == "residual" else "linear",
+        }
+
     def _resolve_mesh_data(self, mesh_data):
         topology = "line" if mesh_data["faces"][0] == 2 else "face"
         if topology == "line":
@@ -412,6 +456,18 @@ class GraphicsWindow(PostWindow):
                 opacity=opacity,
             )
 
+    def _display_xy_plot(self, position=(0, 0), opacity=1):
+        self.renderer.render(
+            self._data["XYPlot"],
+            position=position,
+        )
+
+    def _display_monitor_plot(self, position=(0, 0), opacity=1):
+        self.renderer.render(
+            self._data["MonitorPlot"],
+            position=position,
+        )
+
     def _get_refresh_for_plotter(self, window: "GraphicsWindow"):
         def refresh():
             with GraphicsWindowsManager._condition:
@@ -498,7 +554,11 @@ class GraphicsWindowsManager(PostWindowsManager, metaclass=AbstractSingletonMeta
         with self._condition:
             if not window_id:
                 window_id = self._get_unique_window_id()
-            if in_notebook() or get_config()["blocking"]:
+            if (
+                in_notebook()
+                or get_config()["blocking"]
+                or os.getenv("FLUENT_PROD_DIR")
+            ):
                 self._open_window_notebook(window_id, grid)
             else:
                 self._open_and_plot_console(None, window_id, grid=grid)
@@ -552,12 +612,16 @@ class GraphicsWindowsManager(PostWindowsManager, metaclass=AbstractSingletonMeta
         RuntimeError
             If the window does not support the object.
         """
-        if not isinstance(object, GraphicsDefn):
+        if not isinstance(object, (GraphicsDefn, PlotDefn)):
             raise RuntimeError("Object type currently not supported.")
         with self._condition:
             if not window_id:
                 window_id = self._get_unique_window_id()
-            if in_notebook() or get_config()["blocking"]:
+            if (
+                in_notebook()
+                or get_config()["blocking"]
+                or os.getenv("FLUENT_PROD_DIR")
+            ):
                 self._plot_notebook(object, window_id, fetch_data, overlay)
             else:
                 self._open_and_plot_console(object, window_id, fetch_data, overlay)
@@ -593,10 +657,14 @@ class GraphicsWindowsManager(PostWindowsManager, metaclass=AbstractSingletonMeta
         RuntimeError
             If the window does not support the object.
         """
-        if not isinstance(object, GraphicsDefn):
+        if not isinstance(object, (GraphicsDefn, PlotDefn)):
             raise RuntimeError("Object type currently not supported.")
         with self._condition:
-            if in_notebook() or get_config()["blocking"]:
+            if (
+                in_notebook()
+                or get_config()["blocking"]
+                or os.getenv("FLUENT_PROD_DIR")
+            ):
                 self._add_graphics_in_notebook(
                     object, window_id, fetch_data, overlay, position, opacity
                 )
@@ -608,7 +676,11 @@ class GraphicsWindowsManager(PostWindowsManager, metaclass=AbstractSingletonMeta
     def show_graphics(self, window_id: str):
         """Display the graphics window."""
         with self._condition:
-            if in_notebook() or get_config()["blocking"]:
+            if (
+                in_notebook()
+                or get_config()["blocking"]
+                or os.getenv("FLUENT_PROD_DIR")
+            ):
                 self._show_graphics_in_notebook(window_id)
 
     def save_graphic(

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/src/ansys/fluent/visualization/graphics/pyvista/graphics_defns.py

@@ -1,7 +1,12 @@
 """Module for pyVista windows management."""
 
+import numpy as np
 import pyvista as pv
-from pyvistaqt import BackgroundPlotter
+
+try:
+    from pyvistaqt import BackgroundPlotter
+except ModuleNotFoundError:
+    BackgroundPlotter = None
 
 from ansys.fluent.visualization.graphics.abstract_graphics_defns import AbstractRenderer
 
@@ -14,7 +19,7 @@ class Renderer(AbstractRenderer):
         non_interactive: bool,
         grid: tuple | None = (1, 1),
     ):
-        self.plotter: Union[BackgroundPlotter, pv.Plotter] = (
+        self.plotter: BackgroundPlotter | pv.Plotter = (
             pv.Plotter(title=f"PyFluent ({win_id})", shape=grid)
             if in_notebook or non_interactive
             else BackgroundPlotter(title=f"PyFluent ({win_id})", shape=grid)
@@ -59,7 +64,7 @@ class Renderer(AbstractRenderer):
 
     def _clear_plotter(self, in_notebook):
         if in_notebook and self.plotter.theme._jupyter_backend == "pythreejs":
-            self.plotter.remove_actor(plotter.renderer.actors.copy())
+            self.plotter.remove_actor(self.plotter.renderer.actors.copy())
         else:
             self.plotter.clear()
 
@@ -83,13 +88,68 @@ class Renderer(AbstractRenderer):
 
         Parameters
         ----------
-        mesh : pyvista.DataSet
+        mesh : pyvista.DataSet | dict
             Any PyVista or VTK mesh is supported.
         """
         if "position" in kwargs:
             self.plotter.subplot(kwargs["position"][0], kwargs["position"][1])
             del kwargs["position"]
-        self.plotter.add_mesh(mesh, **kwargs)
+        if isinstance(mesh, pv.DataSet):
+            self.plotter.add_mesh(mesh, **kwargs)
+        else:
+            y_range = None
+            chart = pv.Chart2D()
+            chart.title = mesh["properties"].get("title") or ""
+            chart.x_label = mesh["properties"].get("xlabel") or ""
+            chart.y_label = mesh["properties"].get("ylabel") or ""
+            if mesh["properties"].get("yscale") == "log":
+                chart.y_axis.log_scale = True
+                y_range = 0
+            del mesh["properties"]
+
+            color_list = ["b", "r", "g", "c", "m", "y", "k"]
+            style_list = ["-", "--", "-.", "-.."]
+
+            min_y_value = max_y_value = min_x_value = max_x_value = None
+            for count, curve in enumerate(mesh):
+                chart.line(
+                    mesh[curve]["xvalues"].tolist(),
+                    mesh[curve]["yvalues"].tolist(),
+                    width=2.5,
+                    color=color_list[count % len(color_list)],
+                    style=style_list[count % len(style_list)],
+                    label=curve,
+                )
+                min_y_value = (
+                    min(np.amin(mesh[curve]["yvalues"]), min_y_value)
+                    if min_y_value
+                    else np.amin(mesh[curve]["yvalues"])
+                )
+                max_y_value = (
+                    max(np.amax(mesh[curve]["yvalues"]), max_y_value)
+                    if max_y_value
+                    else np.amax(mesh[curve]["yvalues"])
+                )
+                min_x_value = (
+                    min(np.amin(mesh[curve]["xvalues"]), min_x_value)
+                    if min_x_value
+                    else np.amin(mesh[curve]["xvalues"])
+                )
+                max_x_value = (
+                    max(np.amax(mesh[curve]["xvalues"]), max_x_value)
+                    if max_x_value
+                    else np.amax(mesh[curve]["xvalues"])
+                )
+            if min_x_value and max_x_value:
+                chart.x_range = [min_x_value, max_x_value]
+            if min_y_value and max_y_value:
+                if y_range is None:
+                    y_range = max_y_value - min_y_value
+                chart.y_range = [
+                    min_y_value - y_range * 0.2,
+                    max_y_value + y_range * 0.2,
+                ]
+            self.plotter.add_chart(chart, **kwargs)
 
     def save_graphic(self, file_name: str):
         """Save graphics to the specified file.

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/src/ansys/fluent/visualization/plotter/matplotlib/plotter_defns.py

@@ -57,7 +57,21 @@ class Plotter(AbstractPlotter):
         self._remote_process = remote_process
         self.fig = None
 
-    def plot(self, data: dict, grid=(1, 1), position=0, show=True) -> None:
+    @staticmethod
+    def _compute_position(position: tuple) -> int:
+        x = position[0]
+        y = position[1]
+        if x == y == 0:
+            ret = 0
+        elif x < y:
+            ret = x + y
+        else:
+            ret = x + y + 1
+        return ret
+
+    def plot(
+        self, data: dict, grid=(1, 1), position=0, show=True, subplot_titles=[]
+    ) -> None:
         """Draw plot in window.
 
         Parameters
@@ -82,7 +96,10 @@ class Plotter(AbstractPlotter):
 
         if not self._remote_process:
             self.fig = plt.figure(num=self._window_id)
-        self.ax = self.fig.add_subplot(grid[0], grid[1], position + 1)
+
+        self.ax = self.fig.add_subplot(
+            grid[0], grid[1], self._compute_position(position) + 1
+        )
         if self._yscale:
             self.ax.set_yscale(self._yscale)
         self.fig.canvas.manager.set_window_title("PyFluent [" + self._window_id + "]")

ansys_fluent_visualization-0.17.dev0/src/ansys/fluent/visualization/plotter/plotly/plotter_defns.py

@@ -0,0 +1,176 @@
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+from ansys.fluent.visualization.plotter.abstract_plotter_defns import AbstractPlotter
+
+
+class Plotter(AbstractPlotter):
+    """Class for matplotlib plotter."""
+
+    def __init__(
+        self,
+        window_id: str,
+        curves: list[str] | None = None,
+        title: str | None = "XY Plot",
+        xlabel: str | None = "position",
+        ylabel: str | None = "",
+        remote_process: bool | None = False,
+    ):
+        """Instantiate a matplotlib plotter.
+
+        Parameters
+        ----------
+        window_id : str
+            Window id.
+        curves : List[str], optional
+            List of curves name.
+        title : str, optional
+            Plot title.
+        xlabel : str, optional
+            X axis label.
+        ylabel : str, optional
+            Y axis label.
+        figure : str, optional
+            Matplot lib figure.
+        axis : str, optional
+            Subplot indices.
+        remote_process: bool, optional
+            Is remote process.
+        """
+        self._curves = [] if curves is None else curves
+        self._title = title
+        self._xlabel = xlabel
+        self._ylabel = ylabel
+        self._window_id = window_id
+        self._min_y = None
+        self._max_y = None
+        self._min_x = None
+        self._max_x = None
+        self._yscale = None
+        self._data = {}
+        self._closed = False
+        self._visible = False
+        self._remote_process = remote_process
+        self.fig = None
+
+    def plot(
+        self, data: dict, grid=(1, 1), position=(0, 0), show=True, subplot_titles=[]
+    ) -> None:
+        """Draw plot in window.
+
+        Parameters
+        ----------
+        data : dict
+            Data to plot. Data consists the list of x and y
+            values for each curve.
+        """
+        if not data:
+            return
+        for curve in data:
+            if curve not in self._data:
+                self._data[curve] = {}
+            min_y_value = np.amin(data[curve]["yvalues"])
+            max_y_value = np.amax(data[curve]["yvalues"])
+            min_x_value = np.amin(data[curve]["xvalues"])
+            max_x_value = np.amax(data[curve]["xvalues"])
+            self._data[curve]["xvalues"] = data[curve]["xvalues"].tolist()
+            self._data[curve]["yvalues"] = data[curve]["yvalues"].tolist()
+            self._min_y = min(self._min_y, min_y_value) if self._min_y else min_y_value
+            self._max_y = max(self._max_y, max_y_value) if self._max_y else max_y_value
+            self._min_x = min(self._min_x, min_x_value) if self._min_x else min_x_value
+            self._max_x = max(self._max_x, max_x_value) if self._max_x else max_x_value
+
+        if not self._remote_process:
+            if not self.fig:
+                self.fig = make_subplots(
+                    rows=grid[0], cols=grid[1], subplot_titles=subplot_titles
+                )
+        for curve in self._curves:
+            self.fig.add_trace(
+                go.Scatter(
+                    x=self._data[curve]["xvalues"],
+                    y=self._data[curve]["yvalues"],
+                    mode="lines",
+                    name=curve,
+                ),
+                row=position[0] + 1,
+                col=position[1] + 1,
+            )
+        self.fig.update_yaxes(
+            title_text=self._ylabel,
+            type=self._yscale if self._yscale else "linear",
+            row=position[0] + 1,
+            col=position[1] + 1,
+        )
+        self.fig.update_xaxes(
+            title_text=self._xlabel, row=position[0] + 1, col=position[1] + 1
+        )
+
+        if show:
+            if not self._visible:
+                self._visible = True
+                self.fig.show()
+
+    def show(self):
+        if not self._visible:
+            self._visible = True
+            self.fig.show()
+
+    def close(self):
+        """Close window."""
+        del self.fig
+        self._closed = True
+
+    def is_closed(self):
+        """Check if window is closed."""
+        return self._closed
+
+    def save_graphic(self, file_name: str):
+        """Save graphics (static image (e.g., PNG, JPEG, PDF, SVG)).
+
+        Please note:
+            This requires the kaleido package.
+
+            >>> pip install kaleido
+
+        Parameters
+        ----------
+        file_name : str
+            File name to save graphic.
+        """
+        self.fig.write_image(file_name)
+
+    def set_properties(self, properties: dict):
+        """Set plot properties.
+
+        Parameters
+        ----------
+        properties : dict
+            Plot properties i.e. curves, title, xlabel and ylabel.
+        """
+        self._curves = properties.get("curves", self._curves)
+        self._title = properties.get("title", self._title)
+        self._xlabel = properties.get("xlabel", self._xlabel)
+        self._ylabel = properties.get("ylabel", self._ylabel)
+        self._yscale = properties.get("yscale", self._yscale)
+        self._data = {}
+        self._min_y = None
+        self._max_y = None
+        self._min_x = None
+        self._max_x = None
+        self._reset()
+
+    def __call__(self):
+        """Reset and show plot."""
+        self._reset()
+        self._visible = False
+
+    # private methods
+    def _reset(self):
+        for curve_name in self._curves:
+            self._data[curve_name] = {}
+            self._data[curve_name]["xvalues"] = []
+            self._data[curve_name]["yvalues"] = []
+        if not self.fig:
+            return

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/src/ansys/fluent/visualization/plotter/plotter_windows.py

@@ -5,9 +5,10 @@ class PlotterWindow:
     def __init__(self, grid: tuple = (1, 1)):
         self._grid = grid
         self._plot_objs = []
+        self._subplot_titles = []
         self.window_id = None
 
-    def add_plots(self, object, position: tuple = (0, 0)) -> None:
+    def add_plots(self, object, position: tuple = (0, 0), title: str = "") -> None:
         """Add data to a plot.
 
         Parameters
@@ -16,24 +17,20 @@ class PlotterWindow:
             Object to plot as a sub-plot.
         position: tuple, optional
             Position of the sub-plot.
+        title: str, optional
+            Title of the sub-plot.
         """
         self._plot_objs.append({**locals()})
-
-    def _compute_position(self, position: tuple):
-        x = position[0]
-        y = position[1]
-        ret = 0
-        if x == y == 0:
-            ret = 0
-        elif x < y:
-            ret = x + y
+        if title:
+            self._subplot_titles.append(title)
+        elif hasattr(object.obj, "monitor_set_name"):
+            self._subplot_titles.append(object.obj.monitor_set_name())
         else:
-            ret = x + y + 1
-        return ret
+            self._subplot_titles.append("XYPlot")
 
-    def show(self) -> None:
+    def show(self, win_id=None) -> None:
         """Render the objects in window and display the same."""
-        self.window_id = plotter_windows_manager.open_window()
+        self.window_id = plotter_windows_manager.open_window(window_id=win_id)
         self.plotter_window = plotter_windows_manager._post_windows.get(self.window_id)
         self.plotter = self.plotter_window.plotter
         for i in range(len(self._plot_objs)):
@@ -41,7 +38,8 @@ class PlotterWindow:
                 object=self._plot_objs[i]["object"].obj,
                 window_id=self.window_id,
                 grid=self._grid,
-                position=self._compute_position(self._plot_objs[i]["position"]),
+                position=self._plot_objs[i]["position"],
+                subplot_titles=self._subplot_titles,
                 show=False,
             )
         plotter_windows_manager.show_plots(window_id=self.window_id)

{ansys_fluent_visualization-0.16.dev0 → ansys_fluent_visualization-0.17.dev0}/src/ansys/fluent/visualization/plotter/plotter_windows_manager.py

@@ -13,13 +13,7 @@ from ansys.fluent.core.post_objects.post_object_definitions import (
 )
 from ansys.fluent.core.post_objects.singleton_meta import AbstractSingletonMeta
 
-from ansys.fluent.visualization import PLOTTER, get_config
-
-if PLOTTER == "matplotlib":
-    from ansys.fluent.visualization.plotter.matplotlib.plotter_defns import Plotter
-else:
-    from ansys.fluent.visualization.plotter.pyvista.plotter_defns import Plotter
-
+from ansys.fluent.visualization import get_config
 from ansys.fluent.visualization.plotter.matplotlib.plotter_defns import ProcessPlotter
 from ansys.fluent.visualization.post_data_extractor import XYPlotDataExtractor
 from ansys.fluent.visualization.post_windows_manager import (
@@ -48,7 +42,7 @@ class _ProcessPlotterHandle:
         self.plot_process.start()
         FluentConnection._monitor_thread.cbs.append(self.close)
 
-    def plot(self, data, grid=(1, 1), position=0, show=True):
+    def plot(self, data, grid=(1, 1), position=0, show=True, subplot_titles=[]):
         self.plot_pipe.send(
             {"data": data, "grid": grid, "position": position, "show": show}
         )
@@ -96,11 +90,11 @@ class PlotterWindow(PostWindow):
         """
         self.id: str = id
         self.post_object = None
-        self.plotter: Union[_ProcessPlotterHandle, Plotter] = self._get_plotter()
+        self.plotter: Union[_ProcessPlotterHandle, "Plotter"] = self._get_plotter()
         self.close: bool = False
         self.refresh: bool = False
 
-    def plot(self, grid=(1, 1), position=0, show=True):
+    def plot(self, grid=(1, 1), position=(0, 0), show=True, subplot_titles=[]):
         """Draw a plot."""
         if self.post_object is not None:
             plot = (
@@ -108,13 +102,23 @@ class PlotterWindow(PostWindow):
                 if self.post_object.__class__.__name__ == "XYPlot"
                 else _MonitorPlot(self.post_object, self.plotter)
             )
-            plot(grid=grid, position=position, show=show)
+            plot(grid=grid, position=position, show=show, subplot_titles=subplot_titles)
 
     def _show_plot(self):
         self.plotter.show()
 
     # private methods
     def _get_plotter(self):
+        import ansys.fluent.visualization as pyviz
+
+        if pyviz.PLOTTER == "matplotlib":
+            from ansys.fluent.visualization.plotter.matplotlib.plotter_defns import (
+                Plotter,
+            )
+        elif pyviz.PLOTTER == "plotly":
+            from ansys.fluent.visualization.plotter.plotly.plotter_defns import Plotter
+        else:
+            from ansys.fluent.visualization.plotter.pyvista.plotter_defns import Plotter
         return (
             Plotter(self.id)
             if in_notebook() or get_config()["blocking"]
@@ -126,7 +130,7 @@ class _XYPlot:
     """Provides for drawing an XY plot."""
 
     def __init__(
-        self, post_object: XYPlotDefn, plotter: Union[_ProcessPlotterHandle, Plotter]
+        self, post_object: XYPlotDefn, plotter: Union[_ProcessPlotterHandle, "Plotter"]
     ):
         """Instantiate an XY plot.
 
@@ -138,9 +142,9 @@ class _XYPlot:
             Plotter to plot the data.
         """
         self.post_object: XYPlotDefn = post_object
-        self.plotter: Union[_ProcessPlotterHandle, Plotter] = plotter
+        self.plotter: Union[_ProcessPlotterHandle, "Plotter"] = plotter
 
-    def __call__(self, grid=(1, 1), position=0, show=True):
+    def __call__(self, grid=(1, 1), position=0, show=True, subplot_titles=[]):
         """Draw an XY plot."""
         if not self.post_object:
             return
@@ -157,18 +161,24 @@ class _XYPlot:
             try:
                 self.plotter.set_properties(properties)
             except BrokenPipeError:
-                self.plotter: Union[_ProcessPlotterHandle, Plotter] = (
+                self.plotter: Union[_ProcessPlotterHandle, "Plotter"] = (
                     self._get_plotter()
                 )
                 self.plotter.set_properties(properties)
-        self.plotter.plot(xy_data, grid=grid, position=position, show=show)
+        self.plotter.plot(
+            xy_data,
+            grid=grid,
+            position=position,
+            show=show,
+            subplot_titles=subplot_titles,
+        )
 
 
 class _MonitorPlot:
     """Provides for drawing monitor plots."""
 
     def __init__(
-        self, post_object: MonitorDefn, plotter: Union[_ProcessPlotterHandle, Plotter]
+        self, post_object: MonitorDefn, plotter: Union[_ProcessPlotterHandle, "Plotter"]
     ):
         """Instantiate a monitor plot.
 
@@ -180,9 +190,9 @@ class _MonitorPlot:
             Plotter to plot the data.
         """
         self.post_object: MonitorDefn = post_object
-        self.plotter: Union[_ProcessPlotterHandle, Plotter] = plotter
+        self.plotter: Union[_ProcessPlotterHandle, "Plotter"] = plotter
 
-    def __call__(self, grid=(1, 1), position=(0, 0), show=True):
+    def __call__(self, grid=(1, 1), position=(0, 0), show=True, subplot_titles=[]):
         """Draw a monitor plot."""
         if not self.post_object:
             return
@@ -208,12 +218,18 @@ class _MonitorPlot:
             try:
                 self.plotter.set_properties(properties)
             except BrokenPipeError:
-                self.plotter: Union[_ProcessPlotterHandle, Plotter] = (
+                self.plotter: Union[_ProcessPlotterHandle, "Plotter"] = (
                     self._get_plotter()
                 )
                 self.plotter.set_properties(properties)
         if xy_data:
-            self.plotter.plot(xy_data, grid=grid, position=position, show=show)
+            self.plotter.plot(
+                xy_data,
+                grid=grid,
+                position=position,
+                show=show,
+                subplot_titles=subplot_titles,
+            )
 
 
 class PlotterWindowsManager(PostWindowsManager, metaclass=AbstractSingletonMeta):
@@ -268,7 +284,8 @@ class PlotterWindowsManager(PostWindowsManager, metaclass=AbstractSingletonMeta)
         object: PlotDefn,
         window_id: Optional[str] = None,
         grid=(1, 1),
-        position=0,
+        position=(0, 0),
+        subplot_titles=[],
         show=True,
     ) -> None:
         """Draw a plot.
@@ -292,7 +309,9 @@ class PlotterWindowsManager(PostWindowsManager, metaclass=AbstractSingletonMeta)
             window_id = self._get_unique_window_id()
         window = self._open_window(window_id)
         window.post_object = object
-        window.plot(grid=grid, position=position, show=show)
+        window.plot(
+            grid=grid, position=position, show=show, subplot_titles=subplot_titles
+        )
 
     def show_plots(self, window_id: str):
         window = self._open_window(window_id)
@@ -395,14 +414,11 @@ class PlotterWindowsManager(PostWindowsManager, metaclass=AbstractSingletonMeta)
 
     # private methods
 
-    def _open_window(self, window_id: str) -> Union[Plotter, _ProcessPlotterHandle]:
+    def _open_window(self, window_id: str) -> Union["Plotter", _ProcessPlotterHandle]:
         window = self._post_windows.get(window_id)
-        if (
-            window
-            and not window.plotter.is_closed()
-            and (not (in_notebook() or get_config()["blocking"]) or window.refresh)
-        ):
-            window.refresh = False
+        if window and not window.plotter.is_closed():
+            if not (in_notebook() or get_config()["blocking"]) or window.refresh:
+                window.refresh = False
         else:
             window = PlotterWindow(window_id, None)
             self._post_windows[window_id] = window