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

ansys/systemcoupling/core/adaptor/impl/types.py

@@ -241,7 +241,7 @@ class SettingsBase(Base, Generic[StateT]):
 
     def get_property_state(self, prop):
         """Get the state of the ``prop`` property ."""
-        return self.sycproxy.get_state(self.syc_path + "/" + self.to_syc_name(prop))
+        return self.sycproxy.get_property_state(self.syc_path, self.to_syc_name(prop))
 
     @staticmethod
     def _print_state_helper(state, out, indent=0, indent_factor=2):

ansys/systemcoupling/core/charts/chart_datatypes.py

@@ -0,0 +1,169 @@
+# 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.
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+"""Common data types for the storage of metadata and data for chart series.
+
+All series are assumed to belong to an interface and to a data transfer within the interface
+
+Raw data should be processed into this format from whatever source is available (CSV file
+or streamed data, for example) and the actual charts will be built from this.
+"""
+
+
+class SeriesType(Enum):
+    CONVERGENCE = 1
+    SUM = 2
+    WEIGHTED_AVERAGE = 3
+
+
+@dataclass
+class TransferSeriesInfo:
+    """Information about the chart series data associated with a data transfer.
+
+    Attributes
+    ----------
+    data_index : int
+        This is used by the data source processor to associate this information (likely
+        obtained from heading or other metadata) with the correct data series.
+        It indexes into the full list of series associated with a given interface.
+    series_type : SeriesType
+        The type of line series.
+    transfer_display_name : str
+        The display name of the data transfer. This is a primary identifier for data
+        transfers because CSV data sources do not currently include information about
+        the underlying data model names of data transfers.
+    disambiguation_index: int
+        This should be set to 0, unless there is more than one data transfer with the
+        same display name. A contiguous range of indexes starting at 0 should be assigned
+        to the list of data transfers with the same display name.
+    participant_display_name : str, optional
+        The display name of the participant. This is required for transfer value series
+        but not for convergence series.
+    line_suffixes: list[str]
+        This should always be empty for convergence series. For transfer value series,
+        it should contain the suffixes for any component series that exist. That is,
+        suffixes for complex components, "real" or "imag", and suffixes for vector
+        components, "x", "y", "z", or a combination of complex and vector component
+        types. The data indexes for individual components of the transfer are assumed
+        to be contiguous from ``data_index``.
+    """
+
+    data_index: int
+    series_type: SeriesType
+    transfer_display_name: str
+    disambiguation_index: int
+    # Remainder for non-CONVERGENCE series only
+    participant_display_name: Optional[str] = None
+    line_suffixes: list[str] = field(default_factory=list)
+
+
+@dataclass
+class InterfaceInfo:
+    """Information about the chart series data associated with a single interface.
+
+    Attributes
+    ----------
+    name : str
+        The name of the coupling interface data model object.
+    display_name : str, optional
+        The display name of the interface object. This may be unassigned initially.
+    is_transient : bool
+        Whether the data on this interface is associated with a transient analysis.
+    transfer_info : list[TransferSeriesInfo]
+        The list of ``TransferSeriesInfo`` associated with this interface.
+    """
+
+    name: str
+    display_name: str = ""  # TODO: check whether this is actually needed.
+    is_transient: bool = False
+    transfer_info: list[TransferSeriesInfo] = field(default_factory=list)
+
+
+@dataclass
+class SeriesData:
+    """The plot data for a single chart line series and information to allow
+    it to be associated with chart metadata.
+
+    An instance of this type is assumed to be associated externally with a
+    single interface.
+
+    Attributes
+    ----------
+    transfer_index : int
+        Index of the ``TransferSeriesInfo`` metadata for this series within the
+        ``InterfaceInfo`` for the interface this series is associated with.
+    component_index : int, optional
+        The component index if this series is one of a set of complex and/or
+        vector components of the transfer. Otherwise is ``None``.
+    start_index : int, optional
+        The starting iteration of the ``data`` field. This defaults to 0 and
+        only needs to be set to a different value if incremental data, such
+        as might arise during "live" update of plots, has become available.
+    data : list[float]
+        The series data. This is always indexed by iteration. Extract time
+        step-based data by using a time step to iteration mapping.
+    """
+
+    transfer_index: int  # Index into transfer_info of associated InterfaceInfo
+    component_index: Optional[int] = None  # Component index if applicable
+
+    start_index: int = 0  # Use when providing incremental data
+
+    data: list[float] = field(default_factory=list)
+
+
+@dataclass
+class InterfaceSeriesData:
+    """The series data for given interface.
+
+    Attributes
+    ----------
+    info : InterfaceInfo
+        The metadata for the interface.
+    series : list[SeriesData]
+        The data for all series associated with the interface.
+    """
+
+    info: InterfaceInfo
+    series: list[SeriesData] = field(default_factory=list)
+
+
+@dataclass
+class TimestepData:
+    """Mappings from iteration to time step and time.
+
+    Attributes
+    ----------
+    timestep : list[int]
+        Timestep indexes, indexed by iteration. Typically, multiple consecutive
+        iteration indexes map to the same timestep index.
+    time: list[float]
+        Time values, indexed by iteration. Typically, multiple consecutive iteration
+        indexes map to the same time value.
+    """
+
+    timestep: list[int] = field(default_factory=list)  # iter -> step index
+    time: list[float] = field(default_factory=list)  # iter -> time

ansys/systemcoupling/core/charts/csv_chartdata.py

@@ -0,0 +1,299 @@
+# 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.
+
+# from dataclasses import dataclass, field
+import csv
+from typing import TextIO, Union
+
+from ansys.systemcoupling.core.charts.chart_datatypes import (
+    InterfaceInfo,
+    InterfaceSeriesData,
+    SeriesData,
+    SeriesType,
+    TimestepData,
+    TransferSeriesInfo,
+)
+
+HeaderList = list[str]
+ChartData = list[list[float]]
+
+
+class CsvReader:
+    def __init__(self, file_or_filename: Union[str, TextIO]):
+        self._file_or_filename = file_or_filename
+        self._headers: HeaderList = []
+        self._data: ChartData = []
+        self._started = False
+
+    def read_data(self) -> bool:
+        try:
+            if not self._started:
+                self._read_data_initial()
+                self._started = True
+            else:
+                self._read_data_incr()
+                # print("incremental data read")
+            return True  # File exists - haven't necessarily read anything yet
+        except FileNotFoundError:
+            # It is expected that the file is not necessarily immediately available
+            print(f"Failed to open {self._file_or_filename}")
+            return False
+        except Exception as e:
+            # Temporary - see if anything else goes wrong
+            print(e)
+            return False
+
+    @property
+    def headers(self) -> HeaderList:
+        return self._headers
+
+    @property
+    def data(self) -> ChartData:
+        return self._data
+
+    def _read_data_initial(self):
+        f = None
+        try:
+            f = self._get_file()
+            reader = csv.reader(f)
+            header = None
+            for row in reader:
+                if header is None:
+                    header = row
+                else:
+                    self._append_row(row)
+        finally:
+            self._close_file(f)
+
+        self._headers = header
+
+    def _read_data_incr(self):
+        f = None
+        try:
+            f = self._get_file()
+            reader = csv.reader(f)
+            nlines = len(self._data) + 1
+            # TODO: try using seek/tell
+            for i, row in enumerate(reader):
+                if i < nlines:
+                    continue
+                self._append_row(row)
+        finally:
+            self._close_file(f)
+
+    def _append_row(self, row_data: list[str]) -> None:
+        self._data.append([float(f) for f in row_data])
+
+    def _get_file(self) -> TextIO:
+        if isinstance(self._file_or_filename, str):
+            return open(self._file_or_filename, newline="")
+        else:
+            return self._file_or_filename
+
+    def _close_file(self, f: TextIO):
+        # Only close if we opened it ourself
+        if f and isinstance(self._file_or_filename, str):
+            f.close()
+
+
+class CsvChartDataReader:
+    """Reader of chart data and metadata from a single CSV file, which
+    contains data for a single coupling interface.
+
+    The metadata is derived from the column headings in the file.
+    """
+
+    def __init__(self, interface_name: str, csvfile: Union[str, TextIO]) -> None:
+        self._interface_name = interface_name
+        self._csv_reader = CsvReader(csvfile)
+        self._metadata: InterfaceInfo = None
+        self._data: InterfaceSeriesData = None
+        self._timestep_data = TimestepData()
+
+    def read_metadata(self) -> bool:
+        if not self._csv_reader.read_data():
+            return False
+        self._metadata = parse_csv_metadata(
+            self._interface_name, self._csv_reader.headers
+        )
+        self._init_data()
+        return True
+
+    @property
+    def metadata(self) -> InterfaceInfo:
+        return self._metadata
+
+    @property
+    def data(self) -> InterfaceSeriesData:
+        return self._data
+
+    @property
+    def timestep_data(self) -> TimestepData:
+        return self._timestep_data
+
+    def read_new_data(self):
+        self._csv_reader.read_data()
+        self._process_curr_data()
+
+    def _init_data(self):
+        series_data_list: list[SeriesData] = []
+        for i, trans_info in enumerate(self._metadata.transfer_info):
+            if not trans_info.line_suffixes:
+                series_data_list.append(SeriesData(transfer_index=i))
+            else:
+                for j in range(len(trans_info.line_suffixes)):
+                    series_data_list.append(
+                        SeriesData(transfer_index=i, component_index=j)
+                    )
+        self._data = InterfaceSeriesData(self._metadata, series=series_data_list)
+
+    def _process_curr_data(self):
+        raw_data = self._csv_reader.data
+        last_data_len = len(self._data.series[0].data)
+
+        has_time = self._metadata.is_transient
+        for i in range(last_data_len, len(raw_data)):
+            row = raw_data[i]
+            self._timestep_data.timestep.append(round(row[1]))
+            start_index = 2
+            if has_time:
+                self._timestep_data.time.append(row[2])
+                start_index += 1
+            for j in range(start_index, len(row)):
+                self._data.series[j - start_index].data.append(row[j])
+
+
+def _extract_transfer_value_type(header: str) -> str:
+    for value_type in ("Sum", "Weighted Average"):
+        if f" ({value_type}):" in header:
+            return value_type
+    return None
+
+
+def _parse_header(header: str) -> tuple[SeriesType, str, str]:
+    if header.startswith("Data Transfer Convergence (RMS Change in Target Value):"):
+        ipfx = header.find(":")
+        isep = header.find(" - ", ipfx)
+        intf_disp_name = header[ipfx + 1 : isep].strip()
+        trans_disp_name = header[isep + 3 :].strip()
+        return SeriesType.CONVERGENCE, intf_disp_name, trans_disp_name
+    elif value_type := _extract_transfer_value_type(header):
+        trans_disp_name = header[: header.find(f"({value_type})")].strip()
+        part_disp_name = header[header.find(":") + 1 :].strip()
+        part_disp_name = _remove_suffix(part_disp_name)
+        return (
+            SeriesType.SUM if value_type == "Sum" else SeriesType.WEIGHTED_AVERAGE,
+            part_disp_name,
+            trans_disp_name,
+        )
+    raise ValueError(f"Invalid column header in CSV file: {header}")
+
+
+def _remove_suffix(label: str) -> str:
+    def remove_partial_suffix(str_in: str, suffixes: tuple[str]) -> str:
+        for suffix in suffixes:
+            suffix = f" {suffix}"
+            if str_in.endswith(suffix):
+                return str_in[: len(str_in) - len(suffix)]
+        return str_in
+
+    # Suffix has format "[ <x|y|z>][ <real|imag>]" so remove real/imag first
+    label = remove_partial_suffix(label, ("real", "imag"))
+    label = remove_partial_suffix(label, ("x", "y", "z"))
+    return label
+
+
+def _parse_suffix(header: str, part_disp_name: str) -> str:
+    idx = header.find(f": {part_disp_name} ")
+    if idx == -1:
+        return ""
+    return header[idx + len(part_disp_name) + 3 :].strip()
+
+
+def parse_csv_metadata(interface_name: str, headers: list[str]) -> InterfaceInfo:
+    intf_info = InterfaceInfo(name=interface_name)
+    assert headers[0] == "Iteration"
+    assert headers[1] == "Step"
+    intf_info.is_transient = headers[2] == "Time"
+
+    start_index = 3 if intf_info.is_transient else 2
+    prev_part_name = ""
+
+    transfer_disambig: dict[str, int] = {}
+    for i in range(start_index, len(headers)):
+        header = headers[i]
+        data_index = i - start_index
+        series_type, intf_or_part_disp_name, trans_disp_name = _parse_header(header)
+        if series_type == SeriesType.CONVERGENCE:
+            prev_part_name = ""
+            if trans_disp_name in transfer_disambig:
+                transfer_disambig[trans_disp_name] += 1
+            else:
+                transfer_disambig[trans_disp_name] = 0
+
+            intf_disp_name = intf_or_part_disp_name
+            if data_index == 0:
+                assert intf_info.display_name == ""
+                intf_info.display_name = intf_disp_name
+            series_info = TransferSeriesInfo(
+                data_index,
+                series_type,
+                transfer_display_name=trans_disp_name,
+                disambiguation_index=transfer_disambig[trans_disp_name],
+            )
+            intf_info.transfer_info.append(series_info)
+        else:
+            part_disp_name = intf_or_part_disp_name
+            suffix = _parse_suffix(header, part_disp_name)
+            if suffix:
+                if prev_part_name != part_disp_name:
+                    # Start a new series info for a group of components
+                    # Thus if there are 3 components, say, they will
+                    # implicitly have data indexes, data_index, data_index+1,
+                    # data_index+2, and the next TransferSeriesInfo will
+                    # have index data_index+3.
+                    intf_info.transfer_info.append(
+                        TransferSeriesInfo(
+                            data_index,
+                            series_type,
+                            transfer_display_name=trans_disp_name,
+                            disambiguation_index=transfer_disambig[trans_disp_name],
+                            participant_display_name=part_disp_name,
+                            line_suffixes=[suffix],
+                        )
+                    )
+                    prev_part_name = part_disp_name
+                else:
+                    # Append component info to current series info
+                    intf_info.transfer_info[-1].line_suffixes.append(suffix)
+            else:
+                prev_part_name = ""
+                intf_info.transfer_info.append(
+                    TransferSeriesInfo(
+                        data_index,
+                        series_type,
+                        transfer_display_name=trans_disp_name,
+                        disambiguation_index=transfer_disambig[trans_disp_name],
+                        participant_display_name=part_disp_name,
+                    )
+                )
+    return intf_info

ansys/systemcoupling/core/charts/live_csv_datasource.py

@@ -0,0 +1,87 @@
+# 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 threading
+import time
+from typing import Callable, TextIO, Union
+
+from ansys.systemcoupling.core.charts.chart_datatypes import SeriesData
+from ansys.systemcoupling.core.charts.csv_chartdata import CsvChartDataReader
+from ansys.systemcoupling.core.charts.message_dispatcher import Message, MsgType
+
+
+class LiveCsvDataSource:
+    def __init__(
+        self,
+        interface_name: str,
+        csvfile: Union[str, TextIO],
+        put_msg: Callable[[Message], None],
+    ):
+        self._csv_reader = CsvChartDataReader(interface_name, csvfile)
+        self._put_msg = put_msg
+        self._is_cancelled = threading.Event()
+        self._last_data_len = []
+
+    def cancel(self):
+        self._is_cancelled.set()
+
+    def read_data(self):
+
+        while not self._is_cancelled.is_set():
+            if not self._csv_reader.read_metadata():
+                time.sleep(0.5)
+            else:
+                self._put_msg(
+                    Message(type=MsgType.METADATA, data=self._csv_reader.metadata)
+                )
+                break
+
+        last_round = False
+        while True:
+            self._csv_reader.read_new_data()
+            data = self._csv_reader.data
+            if not self._last_data_len:
+                self._last_data_len = [0] * len(data.series)
+            for i, line_series in enumerate(data.series):
+                start_index = self._last_data_len[i]
+                new_data_len = len(line_series.data)
+
+                if new_data_len - start_index == 0:
+                    continue
+
+                line_series_incr = SeriesData(
+                    line_series.transfer_index,
+                    line_series.component_index,
+                    start_index=start_index,
+                    data=line_series.data[start_index:],
+                )
+                self._put_msg(Message(type=MsgType.SERIES_DATA, data=line_series_incr))
+                self._last_data_len[i] = new_data_len
+
+            if last_round:
+                self._put_msg(Message(type=MsgType.END_OF_DATA))
+                break
+            elif self._is_cancelled.is_set():
+                # Allow opportunity for any trailing updates to file
+                last_round = True
+
+            time.sleep(0.5)

ansys/systemcoupling/core/charts/message_dispatcher.py

@@ -0,0 +1,84 @@
+# 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.
+
+from dataclasses import dataclass
+from enum import IntEnum
+import queue
+from typing import Protocol, Union
+
+from ansys.systemcoupling.core.charts.chart_datatypes import (
+    InterfaceInfo,
+    SeriesData,
+    TimestepData,
+)
+
+
+class PlotterProtocol(Protocol):
+    def set_metadata(self, metadata: InterfaceInfo): ...
+    def set_timestep_data(self, timestep_data: TimestepData): ...
+    def update_line_series(self, series_data: SeriesData): ...
+    def close(self): ...
+
+
+class MsgType(IntEnum):
+    NO_DATA_AVAILABLE = 1
+    END_OF_DATA = 2
+    CLOSE_PLOT = 3
+    METADATA = 4
+    TIMESTEP_DATA = 5
+    SERIES_DATA = 6
+
+
+@dataclass
+class Message:
+    type: MsgType
+    data: Union[InterfaceInfo, TimestepData, SeriesData, None] = None
+
+
+class MessageDispatcher:
+    def __init__(self):
+        self._q = queue.Queue()
+
+    def set_plotter(self, plotter: PlotterProtocol):
+        self._plotter = plotter
+
+    def put_msg(self, msg: Message):
+        self._q.put(msg)
+
+    def dispatch_messages(self):
+        while True:
+            try:
+                msg: Message = self._q.get(timeout=0.001)
+                msg_t = msg.type
+                print(f"dispatch message of type: {msg.type.name}")
+                if msg_t == MsgType.METADATA:
+                    self._plotter.set_metadata(msg.data)
+                elif msg_t == MsgType.TIMESTEP_DATA:
+                    self._plotter.set_timestep_data(msg.data)
+                elif msg_t == MsgType.SERIES_DATA:
+                    self._plotter.update_line_series(msg.data)
+                elif msg_t in (MsgType.END_OF_DATA, MsgType.NO_DATA_AVAILABLE):
+                    return
+                elif msg_t == MsgType.CLOSE_PLOT:
+                    self._plotter.close()
+            except queue.Empty:
+                return