ansys-systemcoupling-core 0.4.1__py3-none-any.whl → 0.6__py3-none-any.whl

ansys/systemcoupling/core/charts/plotter.py

@@ -0,0 +1,343 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import math
+import sys
+from typing import Callable, Optional, Union
+
+from matplotlib.animation import FuncAnimation
+from matplotlib.figure import Figure
+from matplotlib.lines import Line2D
+import matplotlib.pyplot as plt
+
+from ansys.systemcoupling.core.charts.chart_datatypes import (
+    InterfaceInfo,
+    SeriesData,
+    TimestepData,
+)
+from ansys.systemcoupling.core.charts.plotdefinition_manager import (
+    PlotDefinitionManager,
+)
+
+
+def _process_timestep_data(
+    timestep_data: TimestepData,
+) -> tuple[list[int], list[float]]:
+    if not timestep_data.timestep:
+        return [], []
+
+    # TODO: for a dynamically updating case, it should be possible to do a partial update.
+    time_indexes = [0]
+    times = [None]
+    curr_step = timestep_data.timestep[0]
+    for i, step in enumerate(timestep_data.timestep):
+        time = timestep_data.time[i]
+        if step == curr_step:
+            # Still in the same step, so update
+            times[-1] = time
+            time_indexes[-1] = i
+        else:
+            # New step
+            times.append(time)
+            time_indexes.append(i)
+            curr_step = step
+    return (time_indexes, times)
+
+
+def _calc_new_ylimits_linear(
+    ynew: list[float], old_lim: Optional[tuple[float, float]]
+) -> tuple[float, float]:
+    resize_tol = 0.02
+    resize_delta = 0.1
+
+    min_y = min(ynew)
+    max_y = max(ynew)
+
+    # Try to do something reasonable while we still don't have much data.
+    # Try to account for case where we don't have much data and range & value both zero.
+    data_range = min_y if abs(max_y - min_y) < 1.0e-7 else max_y - min_y
+    data_range = abs(data_range)
+    if data_range < 1.0e-7:
+        delta_limits = 1.0e-7
+    else:
+        delta_limits = resize_delta * data_range
+
+    if old_lim is None:
+        # First update - force calculation
+        old_l = min_y + 1
+        old_u = max_y - 1
+    else:
+        new_l, new_u = old_l, old_u = old_lim
+
+    if min_y < old_l + resize_tol * data_range:
+        new_l = min_y - delta_limits
+    if max_y > old_u - resize_tol * data_range:
+        new_u = max_y + delta_limits
+
+    return new_l, new_u
+
+
+def _calc_new_ylimits_log(
+    ynew: list[float], old_lim: Optional[tuple[float, float]]
+) -> tuple[float, float]:
+
+    min_y = min(ynew)
+    max_y = max(ynew)
+
+    if old_lim is not None:
+        new_l, new_u = old_lim
+
+    if old_lim is None or min_y < old_lim[0]:
+        log_l = math.log10(min_y)
+        exponent = math.floor(log_l)
+        new_l = math.pow(10.0, exponent)
+    if old_lim is None or max_y > old_lim[1]:
+        log_u = math.log10(max_y)
+        exponent = math.ceil(log_u)
+        new_u = math.pow(10.0, exponent)
+        # We do this in the GUI - is it needed?
+        new_u *= 1.0 + 1.0e-7
+
+    return new_l, new_u
+
+
+def _update_xy_data(
+    time_info: Optional[tuple[list[int], list[float]]],
+    x_curr,  # ArrayLike
+    y_curr,  # ArrayLike
+    series_data: list[float],
+    new_start_index: int,
+) -> tuple[Union[list[float], list[int]], list[float]]:
+
+    new_total_data_len = new_start_index + len(series_data)
+    x_new = []
+    y_new = []
+    if time_info:
+        time_indexes, time_values = time_info
+        # IMPORTANT: Assume that time data is updated ahead of any series data
+        # This means that (new_data_len - 1) should always be <= maximum known
+        # time index.
+        # time_indexes[-1] is the latest known 0-based iteration index that belongs
+        # to the latest timestep.
+        for i, time_iter in enumerate(time_indexes):
+            # Straight copy if not overlapping with new data yet
+            if time_iter < new_start_index:
+                x_new.append(time_values[i])
+                y_new.append(y_curr[i])
+
+            # Don't assume we have data yet for all known timesteps
+            elif time_iter < new_total_data_len:
+                x_new.append(time_values[i])
+                y_new.append(series_data[time_iter - new_start_index])
+    else:
+        for i in range(new_total_data_len):
+            if i < new_start_index:
+                x_new.append(x_curr[i])
+                y_new.append(y_curr[i])
+            else:
+                x_new.append(i + 1)
+                y_new.append(series_data[i - new_start_index])
+    return (x_new, y_new)
+
+
+# TODO: Only handles one interface at the moment! Generalise to multiple
+class Plotter:
+    def __init__(
+        self,
+        mgr: PlotDefinitionManager,
+        request_update: Optional[Callable[[], None]] = None,
+    ):
+        self._mgr = mgr
+        self._request_update = request_update
+
+        self._fig: Figure = plt.figure()
+        self._subplot_lines: list[list[Line2D]] = []
+        self._subplot_limits_set: list[bool] = []
+        self._metadata: Optional[InterfaceInfo] = None
+
+        # Empty if not transient:
+        self._times: list[float] = []  # Time value at each time step
+        self._time_indexes: list[int] = []  # Iteration to take value at time i from
+
+    def set_metadata(self, metadata: InterfaceInfo):
+        self._metadata = metadata
+        self._mgr.set_metadata(metadata)
+        # We now have enough information to create the (empty) plots
+        self._init_plots()
+
+    def set_timestep_data(self, timestep_data: TimestepData):
+
+        if timestep_data.timestep and not self._metadata.is_transient:
+            raise RuntimeError("Attempt to set timestep data on non-transient case")
+
+        self._time_indexes, self._times = _process_timestep_data(timestep_data)
+
+    def update_line_series(self, series_data: SeriesData):
+        """Update the line series determined by the provided ``series_data`` with the
+        incremental data that it contains.
+
+        The ``series_data`` contains the "start index" in the full series, the index
+        to start writing the new data.
+        """
+        if not self._metadata:
+            raise RuntimeError(
+                "Attempt to add series data to plot before metadata provided."
+            )
+
+        trans = self._metadata.transfer_info[series_data.transfer_index]
+        offset = (
+            series_data.component_index
+            if series_data.component_index is not None
+            else 0
+        )
+        subplot_defn, subplot_line_index = self._mgr.subplot_for_data_index(
+            self._metadata.name, trans.data_index + offset
+        )
+        if subplot_defn is None:
+            # This can happen if the list of plots being show is filtered.
+            return
+
+        subplot_line = self._subplot_lines[subplot_defn.index][subplot_line_index]
+
+        # We don't assume that all provided series_data are fully up to
+        # date with the latest iteration or timestep that pertains globally
+        # over all plots.
+
+        if len(series_data.data) == 0:
+            return
+
+        x_curr, y_curr = subplot_line.get_data()
+        x_new, y_new = _update_xy_data(
+            (self._time_indexes, self._times) if self._times else None,
+            x_curr,
+            y_curr,
+            series_data.data,
+            series_data.start_index,
+        )
+
+        self.update_limits(subplot_defn.index, subplot_defn.is_log_y, x_new, y_new)
+        subplot_line.set_data(x_new, y_new)
+
+    def update_limits(self, subplot_index, is_log_y, x_new, y_new):
+        axes = self._fig.axes[subplot_index]
+
+        are_limits_initialised = self._subplot_limits_set[subplot_index]
+
+        old_xlim = (0, 0)
+        old_ylim = None
+        if are_limits_initialised:
+            old_xlim = axes.get_xlim()
+            old_ylim = axes.get_ylim()
+
+        new_ylimits = (
+            _calc_new_ylimits_log(y_new, old_ylim)
+            if is_log_y
+            else _calc_new_ylimits_linear(y_new, old_ylim)
+        )
+
+        new_xlimits = old_xlim
+        if self._times:
+            if x_new[-1] >= old_xlim[1] * 0.95:
+                new_xlimits = (0.0, x_new[-1] * 1.1)
+        else:
+            if len(x_new) >= old_xlim[1] - 1:
+                new_xlimits = (1, len(x_new) + 1)
+
+        axes.set_xlim(new_xlimits)
+        axes.set_ylim(new_ylimits)
+
+        self._subplot_limits_set[subplot_index] = True
+
+    def close(self):
+        if self._fig:
+            plt.close(self._fig)
+
+    def show_plot(self, noblock=False):
+        if noblock:
+            plt.ion()
+        plt.show()
+
+    def show_animated(self):
+        # NB: if using the wait_for_metadata() approach
+        # supported by MessageDispatcher, do it here like
+        # this (assume the wait function is stored as an
+        # attribute):
+        #
+        # assert self._wait_for_metadata is not None
+        # metadata = self._wait_for_metadata()
+        # if metadata is not None:
+        #     self.set_metadata(metadata)
+        # else:
+        #     return
+        assert self._request_update is not None
+
+        self.ani = FuncAnimation(
+            self._fig,
+            self._update_animation,
+            # frames=x_axis_pts,
+            save_count=sys.maxsize,
+            # init_func=self._init_plots,
+            blit=False,
+            interval=200,
+            repeat=False,
+        )
+        plt.show()
+
+    def _update_animation(self, frame: int):
+        # print("calling update animation")
+        return self._request_update()
+
+    def _init_plots(self):
+        # plt.ion()
+        nrow, ncol = self._mgr.get_layout()
+        self._fig.subplots(nrow, ncol, gridspec_kw={"hspace": 0.5})
+        subplot_defns = self._mgr.subplots
+        if len(subplot_defns) != 1 and len(subplot_defns) % 2 == 1:
+            self._fig.delaxes(self._fig.axes[-1])
+
+        # Add labels and legends
+        for axes, subplot_defn in zip(self._fig.axes, subplot_defns):
+            axes.set_title(subplot_defn.title, fontsize=8)
+            if subplot_defn.is_log_y:
+                axes.set_yscale("log")
+            axes.set_xlabel(subplot_defn.x_axis_label, fontsize=8)
+            axes.set_ylabel(subplot_defn.y_axis_label, fontsize=8)
+            lines = []
+            for label in subplot_defn.series_labels:
+                (ln,) = axes.plot([], [], label=label)
+                lines.append(ln)
+            axes.legend(fontsize=6)
+
+            # Set arbitrary axes limits
+            if self._metadata.is_transient:
+                axes.set_xlim(0.0, 1.0)
+            else:
+                axes.set_xlim(1, 5)
+            if subplot_defn.is_log_y:
+                axes.set_ylim(1e-20, 1)
+            else:
+                axes.set_ylim(0, 1.0)
+
+            # Keep hold of lines so that we can assign data when it's available
+            self._subplot_lines.append(lines)
+            # The limits on this subplot are essentially unset until we start getting data
+            self._subplot_limits_set.append(False)

ansys/systemcoupling/core/client/grpc_client.py

@@ -119,6 +119,7 @@ class SycGrpc(object):
         working_dir = kwargs.pop("working_dir", None)
         port = kwargs.pop("port", None)
         version = kwargs.pop("version", None)
+        start_output = kwargs.pop("start_output", None)
 
         if os.environ.get("SYC_LAUNCH_CONTAINER") == "1":
             mounted_from = working_dir if working_dir else "./"
@@ -137,6 +138,8 @@ class SycGrpc(object):
             )
             LOG.debug("...started")
             self._connect(_LOCALHOST_IP, port)
+        if start_output:
+            self.start_output()
 
     def start_container_and_connect(
         self,
@@ -153,7 +156,7 @@ class SycGrpc(object):
         LOG.debug("...started")
         self._connect(_LOCALHOST_IP, port)
 
-    def start_pim_and_connect(self, version: str = None):
+    def start_pim_and_connect(self, version: str = None, start_output: bool = False):
         """Start PIM-managed instance.
 
         Currently for internal use only.
@@ -171,6 +174,8 @@ class SycGrpc(object):
         self.__pim_instance = instance
         channel = instance.build_grpc_channel()
         self._connect(channel=channel)
+        if start_output:
+            self.start_output()
 
     def upload_file(self, *args, **kwargs):
         """Supports file upload to remote instance.

ansys/systemcoupling/core/participant/manager.py

@@ -24,6 +24,7 @@ import threading
 from typing import Dict, List, Tuple
 
 from ansys.systemcoupling.core.participant.protocol import ParticipantProtocol
+from ansys.systemcoupling.core.syc_version import compare_versions
 from ansys.systemcoupling.core.util.logging import LOG
 
 
@@ -54,10 +55,11 @@ class ParticipantManager:
         until more participant types support the protocol.
     """
 
-    def __init__(self, syc_session):
+    def __init__(self, syc_session, server_version: str):
         self.__participants: Dict[str, ParticipantProtocol] = {}
         self.__syc_session = syc_session
         self.__connection_lock = threading.Lock()
+        self.__server_version = server_version
         self.clear()
 
     def clear(self):
@@ -66,6 +68,11 @@ class ParticipantManager:
         self.__solve_exception = None
 
     def add_participant(self, participant_session: ParticipantProtocol) -> str:
+        if compare_versions(self.__server_version, "24.1") < 0:
+            raise RuntimeError(
+                f"System Coupling server version '{self.__server_version}' is too low to"
+                "support this form of 'add_participant'. Minimum version is '24.1'."
+            )
         participant_name = (
             f"{participant_session.participant_type}-{len(self.__participants) + 1}"
         )
@@ -96,14 +103,23 @@ class ParticipantManager:
             )
 
         for region in participant_session.get_regions():
-            part_state.region.create(region.name).set_state(
-                {
-                    "topology": region.topology,
-                    "input_variables": region.input_variables,
-                    "output_variables": region.output_variables,
-                    "display_name": region.display_name,
-                }
-            )
+            region_state = {
+                "topology": region.topology,
+                "input_variables": region.input_variables,
+                "output_variables": region.output_variables,
+                "display_name": region.display_name,
+            }
+            if compare_versions(self.__server_version, "24.2") >= 0:
+                region_state.update(
+                    {
+                        "region_discretization_type": (
+                            region.region_discretization_type
+                            if hasattr(region, "region_discretization_type")
+                            else "Mesh Region"
+                        )
+                    }
+                )
+            part_state.region.create(region.name).set_state(region_state)
 
         self.__participants[participant_name] = participant_session
         return participant_name

ansys/systemcoupling/core/participant/protocol.py

@@ -41,6 +41,7 @@ class Region(Protocol):
     topology: str
     input_variables: List[str]
     output_variables: List[str]
+    region_discretization_type: str = "Mesh Region"
 
 
 class ParticipantProtocol(Protocol):

ansys/systemcoupling/core/session.py

@@ -83,7 +83,7 @@ class Session:
         self.__rpc = rpc
         self.__native_api = None
         self.__syc_version = None
-        self.__part_mgr = ParticipantManager(self)
+        self.__part_mgr = None
 
     def exit(self) -> None:
         """Close the System Coupling server instance.
@@ -176,10 +176,10 @@ class Session:
             version = sycproxy.get_version()
             self.__syc_version = version.replace(".", "_")
         root = get_root(sycproxy, category=category, version=self.__syc_version)
+        if self.__part_mgr is None:
+            self.__part_mgr = ParticipantManager(self, self.__syc_version)
         sycproxy.set_injected_commands(
-            get_injected_cmd_map(
-                self.__syc_version, category, root, self.__part_mgr, self.__rpc
-            )
+            get_injected_cmd_map(category, self, self.__part_mgr, self.__rpc)
         )
         return (root, sycproxy)
 

ansys/systemcoupling/core/syc_version.py

@@ -25,7 +25,7 @@ from typing import Tuple
 # Define constants relating to the default/current version of System Coupling
 
 SYC_MAJOR_VERSION = 24
-SYC_MINOR_VERSION = 1
+SYC_MINOR_VERSION = 2
 
 SYC_VERSION_CONCAT = f"{SYC_MAJOR_VERSION}{SYC_MINOR_VERSION}"
 SYC_VERSION_DOT = f"{SYC_MAJOR_VERSION}.{SYC_MINOR_VERSION}"

ansys/systemcoupling/core/util/file_transfer.py

@@ -88,6 +88,10 @@ class PimFileTransferService:  # pragma: no cover
         """
         if os.path.isfile(file_name):
             remote_file_name = remote_file_name or os.path.basename(file_name)
+            if os.path.dirname(file_name):
+                raise IsADirectoryError(
+                    f"{remote_file_name} is not in the current working directory"
+                )
             if not overwrite and self.file_service.file_exist(remote_file_name):
                 raise FileExistsError(f"{remote_file_name} already exists remotely.")
             self.file_service.upload_file(file_name, remote_file_name)

ansys/systemcoupling/core/util/logging.py

@@ -55,7 +55,7 @@ class Logger:
     """
 
     def __init__(self, level: Any = logging.ERROR):
-        self.logger = logging.getLogger()
+        self.logger = logging.getLogger("pysystem-coupling")
         self.stream_handler = None
         self.file_handler = None
         self.log_filepath = None

{ansys_systemcoupling_core-0.4.1.dist-info → ansys_systemcoupling_core-0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ansys-systemcoupling-core
-Version: 0.4.1
+Version: 0.6
 Summary: A Python wrapper for Ansys System Coupling.
 Author-email: "ANSYS, Inc." <pyansys.support@ansys.com>
 Maintainer-email: PyAnsys developers <pyansys.maintainers@ansys.com>
@@ -20,34 +20,35 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: ansys-api-systemcoupling==0.1.0
 Requires-Dist: ansys-platform-instancemanagement~=1.0
 Requires-Dist: grpcio>=1.30.0
-Requires-Dist: grpcio-status>=1.30.0,<1.60.2
+Requires-Dist: grpcio-status>=1.30.0,<1.64.2
 Requires-Dist: googleapis-common-protos>=1.50.0
 Requires-Dist: protobuf>=3.20.1,<4.0.0
 Requires-Dist: psutil>=5.7.0
 Requires-Dist: pyyaml
 Requires-Dist: appdirs>=1.4.0
 Requires-Dist: importlib-metadata>=4.0
+Requires-Dist: matplotlib>=3.8.2
 Requires-Dist: build ; extra == "build"
-Requires-Dist: black==24.1.1 ; extra == "classesgen"
+Requires-Dist: black==24.4.2 ; extra == "classesgen"
 Requires-Dist: isort==5.13.2 ; extra == "classesgen"
-Requires-Dist: ansys-sphinx-theme==0.13.3 ; extra == "doc"
+Requires-Dist: ansys-sphinx-theme==0.16.6 ; extra == "doc"
 Requires-Dist: jupyter_sphinx==0.5.3 ; extra == "doc"
 Requires-Dist: matplotlib ; extra == "doc"
-Requires-Dist: numpydoc==1.6.0 ; extra == "doc"
-Requires-Dist: pypandoc==1.12 ; extra == "doc"
-Requires-Dist: pytest-sphinx==0.6.0 ; extra == "doc"
-Requires-Dist: Sphinx==7.2.6 ; extra == "doc"
-Requires-Dist: sphinx-autobuild==2024.2.4 ; extra == "doc"
-Requires-Dist: sphinx-autodoc-typehints==1.25.2 ; extra == "doc"
+Requires-Dist: numpydoc==1.7.0 ; extra == "doc"
+Requires-Dist: pypandoc==1.13 ; extra == "doc"
+Requires-Dist: pytest-sphinx==0.6.3 ; extra == "doc"
+Requires-Dist: Sphinx==7.3.7 ; extra == "doc"
+Requires-Dist: sphinx-autobuild==2024.4.16 ; extra == "doc"
+Requires-Dist: sphinx-autodoc-typehints==2.2.2 ; extra == "doc"
 Requires-Dist: sphinx-copybutton==0.5.2 ; extra == "doc"
-Requires-Dist: sphinx-gallery==0.15.0 ; extra == "doc"
-Requires-Dist: sphinx-notfound-page==1.0.0 ; extra == "doc"
+Requires-Dist: sphinx-gallery==0.16.0 ; extra == "doc"
+Requires-Dist: sphinx-notfound-page==1.0.2 ; extra == "doc"
 Requires-Dist: sphinxcontrib-websupport==1.2.7 ; extra == "doc"
 Requires-Dist: sphinxemoji==0.3.1 ; extra == "doc"
 Requires-Dist: ansys-fluent-core ; extra == "doc"
 Requires-Dist: ansys-dpf-core ; extra == "doc"
-Requires-Dist: codespell==2.2.6 ; extra == "style"
-Requires-Dist: flake8==7.0.0 ; extra == "style"
+Requires-Dist: codespell==2.3.0 ; extra == "style"
+Requires-Dist: flake8==7.1.0 ; extra == "style"
 Requires-Dist: pytest ; extra == "tests"
 Requires-Dist: pytest-cov ; extra == "tests"
 Requires-Dist: psutil>=5.7.0 ; extra == "tests"
@@ -136,12 +137,12 @@ in this order:
 
 * ``SYSC_ROOT``
 * ``AWP_ROOT``
-* ``AWP_ROOT241``
+* ``AWP_ROOT242``
 
 If a variable is set but does not refer to a valid installation, PySystemCoupling
 fails at that point, rather than attempting to use the next variable.
 
-In a standard user installation, the expectation is that only ``AWP_ROOT241`` is set.
+In a standard user installation, the expectation is that only ``AWP_ROOT242`` is set.
 
 (It is also possible to provide a different version number as an argument to the ``launch()``
 function. This will affect which ``AWP_ROOT<version>`` environment variable is examined.)