ansys-systemcoupling-core 0.4.dev0__py3-none-any.whl → 0.5.0__py3-none-any.whl

ansys/systemcoupling/core/adaptor/api_24_2/update_control.py

@@ -0,0 +1,43 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class update_control(Container):
+    """
+    Configure update controls.
+    """
+
+    syc_name = "UpdateControl"
+
+    property_names_types = [
+        ("option", "Option", "str"),
+        ("update_frequency", "UpdateFrequency", "int"),
+    ]
+
+    @property
+    def option(self) -> str:
+        """Specifies how often the participant will perform updates.
+
+        Possible values:
+
+        - \"ProgramControlled\"
+        - \"EveryIteration\"
+        - \"StepInterval\"
+        - \"Suspended\" """
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def update_frequency(self) -> int:
+        """Specify update frequency."""
+        return self.get_property_state("update_frequency")
+
+    @update_frequency.setter
+    def update_frequency(self, value: int):
+        self.set_property_state("update_frequency", value)

ansys/systemcoupling/core/adaptor/api_24_2/update_participant.py

@@ -0,0 +1,61 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class update_participant(Command):
+    """
+    Given the name of a server participant, updates the state of the participant.
+
+    Available for server participants. Currently, only DEFAULT-SRV,
+    CFD-SRV, MECH-SRV, and SCDT-SRV participants may be updated.
+
+    As part of the update, System Coupling updates all regions and
+    variables defined in the participant, including all variable
+    attributes. Variables and regions may be added to the participant but
+    may not be removed.
+
+    You may specify an input file using an optional argument. If an input
+    file is not provided, then the original input file will be reimported.
+
+    If the update process fails, System Coupling displays an error. In this
+    case, you can either update the setup in the participant application to
+    remove any issues with the update process or delete the participant
+    from the analysis and then re-add it using the updated input file.
+
+    Parameters
+    ----------
+    participant_name : str
+        Participant name. Must be the name of an existing participant.
+        Participant type can be either DEFAULT-SRV, CFD-SRV, MECH-SRV, or SCDT-SRV.
+    input_file : str, optional
+        Name of the input file for the participant to be added.
+        Currently supported formats are SCP files, Forte input (FTSIM)
+        files, mechanical server (\*.rst) files, cfd server (\*.csv) files,
+        FMU (.fmu) files (Beta), and system coupling data server (\*.scdt/axdt/csv) files.
+
+    """
+
+    syc_name = "UpdateParticipant"
+
+    argument_names = ["participant_name", "input_file"]
+
+    class participant_name(String):
+        """
+        Participant name. Must be the name of an existing participant.
+        Participant type can be either DEFAULT-SRV, CFD-SRV, MECH-SRV, or SCDT-SRV.
+        """
+
+        syc_name = "ParticipantName"
+
+    class input_file(String):
+        """
+        Name of the input file for the participant to be added.
+        Currently supported formats are SCP files, Forte input (FTSIM)
+        files, mechanical server (\*.rst) files, cfd server (\*.csv) files,
+        FMU (.fmu) files (Beta), and system coupling data server (\*.scdt/axdt/csv) files.
+        """
+
+        syc_name = "InputFile"

ansys/systemcoupling/core/adaptor/api_24_2/variable.py

@@ -0,0 +1,20 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .variable_child import variable_child
+
+
+class variable(NamedContainer[variable_child]):
+    """
+    Configure a variable for the coupling participant.
+    """
+
+    syc_name = "Variable"
+
+    child_object_type: variable_child = variable_child
+    """
+    child_object_type of variable.
+    """

ansys/systemcoupling/core/adaptor/api_24_2/variable_child.py

@@ -0,0 +1,231 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .attribute import attribute
+
+
+class variable_child(Container):
+    """
+    Configure a variable for the coupling participant.
+    """
+
+    syc_name = "child_object_type"
+
+    child_names = ["attribute"]
+
+    attribute: attribute = attribute
+    """
+    attribute child of variable_child.
+    """
+    property_names_types = [
+        ("quantity_type", "QuantityType", "str"),
+        ("location", "Location", "str"),
+        ("participant_display_name", "ParticipantDisplayName", "str"),
+        ("display_name", "DisplayName", "str"),
+        ("data_type", "DataType", "str"),
+        ("real_initial_value", "RealInitialValue", "RealType"),
+        ("integer_initial_value", "IntegerInitialValue", "int"),
+        ("logical_initial_value", "LogicalInitialValue", "bool"),
+        ("string_initial_value", "StringInitialValue", "str"),
+        ("enumeration_initial_value", "EnumerationInitialValue", "int"),
+        ("real_min", "RealMin", "RealType"),
+        ("real_max", "RealMax", "RealType"),
+        ("integer_min", "IntegerMin", "int"),
+        ("integer_max", "IntegerMax", "int"),
+        ("enumeration_min", "EnumerationMin", "int"),
+        ("enumeration_max", "EnumerationMax", "int"),
+        ("tensor_type", "TensorType", "str"),
+        ("is_extensive", "IsExtensive", "bool"),
+    ]
+
+    @property
+    def quantity_type(self) -> str:
+        """Quantity type of the variable.
+
+        Allowed values:
+
+        - \"Unspecified\"
+        - \"Force\"
+        - \"Incremental Displacement\"
+        - \"Temperature\"
+        - \"Heat Rate\"
+        - \"Heat Transfer Coefficient\"
+        - \"Convection Reference Temperature\"
+        - \"Mode Shape\"
+        - \"Electrical Conductivity\" """
+        return self.get_property_state("quantity_type")
+
+    @quantity_type.setter
+    def quantity_type(self, value: str):
+        self.set_property_state("quantity_type", value)
+
+    @property
+    def location(self) -> str:
+        """Data location of the variable (\"Node\" or \"Element\")."""
+        return self.get_property_state("location")
+
+    @location.setter
+    def location(self, value: str):
+        self.set_property_state("location", value)
+
+    @property
+    def participant_display_name(self) -> str:
+        """Variable's display name as defined by the participant solver."""
+        return self.get_property_state("participant_display_name")
+
+    @participant_display_name.setter
+    def participant_display_name(self, value: str):
+        self.set_property_state("participant_display_name", value)
+
+    @property
+    def display_name(self) -> str:
+        """Variable's display name as defined in System Coupling."""
+        return self.get_property_state("display_name")
+
+    @display_name.setter
+    def display_name(self, value: str):
+        self.set_property_state("display_name", value)
+
+    @property
+    def data_type(self) -> str:
+        """Variable's data type as reported by the participant.
+
+        Allowed values (non-FMU case):
+
+        - Real
+        - Complex
+
+        Allowed values (FMU):
+
+        - Real
+        - Integer
+        - Logical
+        - String
+        - Enumeration"""
+        return self.get_property_state("data_type")
+
+    @data_type.setter
+    def data_type(self, value: str):
+        self.set_property_state("data_type", value)
+
+    @property
+    def real_initial_value(self) -> RealType:
+        """Real data start value."""
+        return self.get_property_state("real_initial_value")
+
+    @real_initial_value.setter
+    def real_initial_value(self, value: RealType):
+        self.set_property_state("real_initial_value", value)
+
+    @property
+    def integer_initial_value(self) -> int:
+        """Integer data start value."""
+        return self.get_property_state("integer_initial_value")
+
+    @integer_initial_value.setter
+    def integer_initial_value(self, value: int):
+        self.set_property_state("integer_initial_value", value)
+
+    @property
+    def logical_initial_value(self) -> bool:
+        """Logical data start value."""
+        return self.get_property_state("logical_initial_value")
+
+    @logical_initial_value.setter
+    def logical_initial_value(self, value: bool):
+        self.set_property_state("logical_initial_value", value)
+
+    @property
+    def string_initial_value(self) -> str:
+        """String data start value."""
+        return self.get_property_state("string_initial_value")
+
+    @string_initial_value.setter
+    def string_initial_value(self, value: str):
+        self.set_property_state("string_initial_value", value)
+
+    @property
+    def enumeration_initial_value(self) -> int:
+        """Enumeration data start value."""
+        return self.get_property_state("enumeration_initial_value")
+
+    @enumeration_initial_value.setter
+    def enumeration_initial_value(self, value: int):
+        self.set_property_state("enumeration_initial_value", value)
+
+    @property
+    def real_min(self) -> RealType:
+        """Real data minimum value."""
+        return self.get_property_state("real_min")
+
+    @real_min.setter
+    def real_min(self, value: RealType):
+        self.set_property_state("real_min", value)
+
+    @property
+    def real_max(self) -> RealType:
+        """Real data maximum value."""
+        return self.get_property_state("real_max")
+
+    @real_max.setter
+    def real_max(self, value: RealType):
+        self.set_property_state("real_max", value)
+
+    @property
+    def integer_min(self) -> int:
+        """Integer data minimum value."""
+        return self.get_property_state("integer_min")
+
+    @integer_min.setter
+    def integer_min(self, value: int):
+        self.set_property_state("integer_min", value)
+
+    @property
+    def integer_max(self) -> int:
+        """Integer data maximum value."""
+        return self.get_property_state("integer_max")
+
+    @integer_max.setter
+    def integer_max(self, value: int):
+        self.set_property_state("integer_max", value)
+
+    @property
+    def enumeration_min(self) -> int:
+        """Enumeration data minimum value."""
+        return self.get_property_state("enumeration_min")
+
+    @enumeration_min.setter
+    def enumeration_min(self, value: int):
+        self.set_property_state("enumeration_min", value)
+
+    @property
+    def enumeration_max(self) -> int:
+        """Enumeration data maximum value."""
+        return self.get_property_state("enumeration_max")
+
+    @enumeration_max.setter
+    def enumeration_max(self, value: int):
+        self.set_property_state("enumeration_max", value)
+
+    @property
+    def tensor_type(self) -> str:
+        """Indicates the variable tensor type (\"Scalar\" or \"Vector\").
+
+        \"Vector\" is not supported for the FMU case."""
+        return self.get_property_state("tensor_type")
+
+    @tensor_type.setter
+    def tensor_type(self, value: str):
+        self.set_property_state("tensor_type", value)
+
+    @property
+    def is_extensive(self) -> bool:
+        """Indicates whether this is an extensive property."""
+        return self.get_property_state("is_extensive")
+
+    @is_extensive.setter
+    def is_extensive(self, value: bool):
+        self.set_property_state("is_extensive", value)

ansys/systemcoupling/core/adaptor/api_24_2/write_csv_chart_files.py

@@ -0,0 +1,21 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class write_csv_chart_files(Command):
+    """
+    For each coupling interface, exports a CSV file containing chart data
+    (convergence and source/target quantity transfer values) for
+    that interface.
+
+    Each file is named according to the convention ``<interface>.csv``, where
+    ``<interface>`` is the object name of the corresponding coupling interface.
+
+    This command will overwrite any CSV charting files that already exist,
+    including any that were written during the solution.
+    """
+
+    syc_name = "WriteCsvChartFiles"

ansys/systemcoupling/core/adaptor/api_24_2/write_ensight.py

@@ -0,0 +1,46 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class write_ensight(Command):
+    """
+    Write a file with mesh and results which can be loaded into Ensight for
+    post processing.
+
+    Parameters
+    ----------
+    file_name : str
+        Base name for Ensight files. It will generate <base>.encas file which
+        should be loaded into Ensight. Other files are generated for geometry
+        and variables.
+    binary : bool, optional
+        To control if file is to be written in binary format or ASCII. ASCII
+        slows down performance, but may be useful for debugging and seeing
+        raw data.
+
+    """
+
+    syc_name = "WriteEnSight"
+
+    argument_names = ["file_name", "binary"]
+
+    class file_name(String):
+        """
+        Base name for Ensight files. It will generate <base>.encas file which
+        should be loaded into Ensight. Other files are generated for geometry
+        and variables.
+        """
+
+        syc_name = "FileName"
+
+    class binary(Boolean):
+        """
+        To control if file is to be written in binary format or ASCII. ASCII
+        slows down performance, but may be useful for debugging and seeing
+        raw data.
+        """
+
+        syc_name = "Binary"

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

@@ -63,6 +63,13 @@ def get_injected_cmd_map(
             "abort": lambda **kwargs: rpc.abort(**kwargs),
         }
 
+    if category == "case":
+        ret = {
+            "clear_state": lambda **kwargs: _wrap_clear_state(
+                root_object, part_mgr, **kwargs
+            )
+        }
+
     return ret
 
 
@@ -102,6 +109,13 @@ def _wrap_add_participant(
     return root_object._add_participant(**kwargs)
 
 
+def _wrap_clear_state(
+    root_object: Container, part_mgr: ParticipantManager, **kwargs
+) -> None:
+    part_mgr.clear()
+    root_object._clear_state(**kwargs)
+
+
 def _wrap_solve(root_object: Container, part_mgr: ParticipantManager) -> None:
     if part_mgr is None:
         root_object._solve()
@@ -309,4 +323,8 @@ _cmd_yaml = """
     essentialArgNames: []
     optionalArgNames: []
     args: []
+-   name: ClearState
+    pyname: clear_state
+    isInjected: true
+    pysyc_internal_name: _clear_state
 """

ansys/systemcoupling/core/client/grpc_client.py

@@ -26,8 +26,10 @@ import json
 import os
 import socket
 import threading
+from typing import Optional
 
 import ansys.api.systemcoupling.v0.command_pb2 as command_pb2
+import ansys.platform.instancemanagement as pypim
 import grpc
 
 from ansys.systemcoupling.core.client.services.command_query import CommandQueryService
@@ -37,13 +39,15 @@ from ansys.systemcoupling.core.client.services.solution import SolutionService
 from ansys.systemcoupling.core.client.syc_container import start_container
 from ansys.systemcoupling.core.client.syc_process import SycProcess
 from ansys.systemcoupling.core.client.variant import from_variant, to_variant
+from ansys.systemcoupling.core.syc_version import normalize_version
+from ansys.systemcoupling.core.util.file_transfer import file_transfer_service
 from ansys.systemcoupling.core.util.logging import LOG
 
 _CHANNEL_READY_TIMEOUT_SEC = 15
 _LOCALHOST_IP = "127.0.0.1"
 
 
-def _find_port():
+def _find_port() -> int:
     with socket.socket() as s:
         s.bind(("", 0))
         return s.getsockname()[1]
@@ -95,6 +99,8 @@ class SycGrpc(object):
         self.__process = None
         self.__channel = None
         self.__output_thread = None
+        self.__pim_instance = None
+        self.__skip_exit = False
 
     @classmethod
     def _cleanup(cls):
@@ -147,6 +153,39 @@ class SycGrpc(object):
         LOG.debug("...started")
         self._connect(_LOCALHOST_IP, port)
 
+    def start_pim_and_connect(self, version: str = None):
+        """Start PIM-managed instance.
+
+        Currently for internal use only.
+        """
+        product_version = "latest"
+        if version is not None:
+            maj_v, min_v = normalize_version(version)
+            product_version = f"{maj_v}{min_v}"
+
+        pim = pypim.connect()
+        instance = pim.create_instance(
+            product_name="systemcoupling", product_version=product_version
+        )
+        instance.wait_for_ready()
+        self.__pim_instance = instance
+        channel = instance.build_grpc_channel()
+        self._connect(channel=channel)
+
+    def upload_file(self, *args, **kwargs):
+        """Supports file upload to remote instance.
+
+        Currently for internal use only.
+        """
+        file_transfer_service(self.__pim_instance).upload_file(*args, **kwargs)
+
+    def download_file(self, *args, **kwargs):
+        """Supports file download from remote instance.
+
+        Currently for internal use only.
+        """
+        file_transfer_service(self.__pim_instance).download_file(*args, **kwargs)
+
     def connect(self, host, port):
         """Connect to an already running System Coupling server running on a known
         host and port.
@@ -161,20 +200,34 @@ class SycGrpc(object):
             # Discard the sentinel
             del SycGrpc._instances[-1]
 
-    def _connect(self, host, port):
+    def _connect(
+        self,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        channel: Optional[grpc.Channel] = None,
+    ):
+        if (channel is None and (host is None or port is None)) or (
+            channel is not None and (host is not None or port is not None)
+        ):
+            raise ValueError("Internal error: _connect needs host and port OR channel")
+
         LOG.debug("Connecting...")
         self._register_for_cleanup()
-        self.__channel = grpc.insecure_channel(f"{host}:{port}")
-
-        # Wait for server to be ready
-        timeout = _CHANNEL_READY_TIMEOUT_SEC
-        try:
-            grpc.channel_ready_future(self.__channel).result(timeout=timeout)
-        except grpc.FutureTimeoutError:
-            raise RuntimeError(
-                "Stopping attempt to connect to gRPC channel "
-                f"after {timeout} seconds."
-            )
+        if channel is None:
+            self.__channel = grpc.insecure_channel(f"{host}:{port}")
+
+            # Wait for server to be ready
+            timeout = _CHANNEL_READY_TIMEOUT_SEC
+            try:
+                grpc.channel_ready_future(self.__channel).result(timeout=timeout)
+            except grpc.FutureTimeoutError:
+                raise RuntimeError(
+                    "Stopping attempt to connect to gRPC channel "
+                    f"after {timeout} seconds."
+                )
+
+        else:
+            self.__channel = channel
 
         LOG.debug("...connected")
 
@@ -183,6 +236,49 @@ class SycGrpc(object):
         self.__process_service = SycProcessService(self.__channel)
         self.__solution_service = SolutionService(self.__channel)
 
+    @property
+    def _channel_str(self):
+        """The channel target string.
+
+        Generally of the form of "ip:port", like "127.0.0.1:50052".
+
+        """
+
+        # Note: this impl was taken from pymapdl and does more than SyC needs
+        # at the moment as we don't use interceptors.
+
+        channel = self.__channel
+        while channel is not None:
+            # When creating interceptors, channels have a nested "_channel" member
+            # containing the intercepted channel.
+            # Only the actual channel contains the "target" member describing the address
+            if hasattr(channel, "target"):
+                return channel.target().decode()
+            channel = getattr(channel, "_channel", None)
+        # This method is relying on grpc channel's private attributes, fallback in case
+        # it does not exist
+        return "unknown"  #  pragma: no cover Unreachable in the current gRPC version
+
+    @property
+    def _channel(self) -> grpc.Channel:
+        """Access the gRPC Channel object
+
+        Provided for testing purposes.
+        """
+        return self.__channel
+
+    @property
+    def _skip_exit(self) -> bool:
+        return self.__skip_exit
+
+    @_skip_exit.setter
+    def _skip_exit(self, value: bool) -> None:
+        """Make ``exit`` call a no-op for this instance.
+
+        Provided for testing purposes.
+        """
+        self.__skip_exit = value
+
     def exit(self):
         """Shut down the remote System Coupling server.
 
@@ -193,7 +289,7 @@ class SycGrpc(object):
             # Remove from atexit cleanup list
             del SycGrpc._instances[self.__id]
 
-        if self.__channel is not None:
+        if self.__channel is not None and not self.__skip_exit:
             try:
                 self.__ostream_service.end_streaming()
             except Exception as e:
@@ -203,6 +299,9 @@ class SycGrpc(object):
         if self.__process:
             self.__process.end()
             self.__process = None
+        if self.__pim_instance is not None:
+            self.__pim_instance.delete()
+            self.__pim_instance = None
         self._reset()
 
     def start_output(self, handle_output=None):