ansys-systemcoupling-core 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

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

@@ -0,0 +1,44 @@
+#
+# 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\"
+        - \"FirstCouplingIteration\" """
+        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_1/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_1/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_1/variable_child.py

@@ -0,0 +1,232 @@
+#
+# 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
+        - None"""
+        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_1/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_1/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/get_syc_version.py

@@ -0,0 +1,35 @@
+from ansys.systemcoupling.core.syc_version import SYC_VERSION_DOT
+
+
+def get_syc_version(api) -> str:
+    """Get the System Coupling version.
+
+    The version is returned in a string like ``"23.2"``.
+
+    System Coupling versions earlier than 23.2 (2023 R2) do not expose
+    the ``GetVersion`` query. Because the first version of the server
+    that PySystemCoupling is able to connect to is 23.1 (2023 R1), the
+    version is assumed to be 23.1 if no version query exists.
+
+    Parameters
+    ----------
+    api : NativeApi
+        Object providing access to the System Coupling *native API* .
+    """
+
+    def clean_version_string(version_in: str) -> str:
+        year, _, release = version_in.partition(" ")
+        if len(year) == 4 and year.startswith("20") and release.startswith("R"):
+            try:
+                year = int(year[2:])
+                release = int(release[1:])
+                return f"{year}.{release}"
+            except:
+                pass
+        raise RuntimeError(
+            f"Version string {version_in} has invalid format (expect '20yy Rn')."
+        )
+
+    cmds = api.GetCommandAndQueryMetadata()
+    exists = any(cmd["name"] == "GetVersion" for cmd in cmds)
+    return clean_version_string(api.GetVersion()) if exists else SYC_VERSION_DOT

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

@@ -1,6 +1,8 @@
 from copy import deepcopy
 from typing import Callable, Dict
 
+from ansys.systemcoupling.core.participant.manager import ParticipantManager
+from ansys.systemcoupling.core.syc_version import compare_versions
 from ansys.systemcoupling.core.util.yaml_helper import yaml_load_from_string
 
 from .get_status_messages import get_status_messages
@@ -8,26 +10,74 @@ from .types import Container
 
 
 def get_injected_cmd_map(
-    category: str, root_object: Container, rpc
+    version: str,
+    category: str,
+    root_object: Container,
+    part_mgr: ParticipantManager,
+    rpc,
 ) -> Dict[str, Callable]:
     """Gets a dictionary that maps names to functions that implement the injected command.
 
     The map returned pertains to the commands in the specified category.
     """
+    ret = {}
+
     if category == "setup":
-        return {
+        ret = {
             "get_setup_summary": lambda **kwargs: rpc.GetSetupSummary(**kwargs),
             "get_status_messages": lambda **kwargs: get_status_messages(
                 rpc, root_object, **kwargs
             ),
+            "add_participant": lambda **kwargs: _wrap_add_participant(
+                version, root_object, part_mgr, **kwargs
+            ),
         }
+
     if category == "solution":
-        return {
-            "solve": lambda **kwargs: rpc.solve(),
+        ret = {
+            "solve": lambda **kwargs: _wrap_solve(root_object, part_mgr, **kwargs),
             "interrupt": lambda **kwargs: rpc.interrupt(**kwargs),
             "abort": lambda **kwargs: rpc.abort(**kwargs),
         }
-    return {}
+
+    return ret
+
+
+def _wrap_add_participant(
+    server_version: str, root_object: Container, part_mgr: ParticipantManager, **kwargs
+) -> str:
+    if session := kwargs.get("participant_session", None):
+        if len(kwargs) != 1:
+            raise RuntimeError(
+                "If a 'participant_session' argument is passed to "
+                "'add_participant', it must be the only argument."
+            )
+        if part_mgr is None:
+            raise RuntimeError("Internal error: participant manager is not available.")
+
+        if compare_versions(server_version, "24.1") < 0:
+            raise RuntimeError(
+                f"System Coupling server version '{server_version}' is too low to"
+                "support this form of 'add_participant'. Minimum version is '24.1'."
+            )
+
+        if not hasattr(session, "system_coupling"):
+            raise RuntimeError(
+                "The 'participant_session' parameter does not provide a "
+                "'system_coupling' attribute and therefore cannot support this "
+                "form of 'add_participant'."
+            )
+
+        return part_mgr.add_participant(participant_session=session.system_coupling)
+
+    return root_object._add_participant(**kwargs)
+
+
+def _wrap_solve(root_object: Container, part_mgr: ParticipantManager) -> None:
+    if part_mgr is None:
+        root_object._solve()
+    else:
+        part_mgr.solve()
 
 
 def get_injected_cmd_data() -> list:
@@ -60,6 +110,48 @@ _cmd_yaml = """
 -   name: Solve
     pyname: solve
     isInjected: true
+    pysyc_internal_name: _solve
+-   name: AddParticipant
+    pyname: add_participant
+    isInjected: true
+    pysyc_internal_name: _add_participant
+    doc_prefix: |-
+        This command operates in one of two modes, depending on how it is called.
+        *Either* a single argument, ``participant_session``, should be provided, *or* some
+        combination of the other optional arguments not including ``participant_session``
+        should be provided.
+
+        In the ``participant_session`` mode, the session object is queried to
+        extract the information needed to define a new ``coupling_participant``
+        object in the setup datamodel. A reference to the session is also retained,
+        and this will play a further role if ``solve`` is called later. In that case,
+        the participant solver will be driven from the Python environment in which the
+        participant and PySystemCoupling sessions are active and System Coupling will
+        regard the participant solver as "externally managed" (see the `execution_control`
+        settings in `coupling_participant` for details of this mode).
+
+        .. note::
+            The ``participant_session`` mode currently has limited support in the
+            broader Ansys Python ecosystem - at present, only PyFluent supports
+            the API required of the session object and product versions of Fluent and
+            System Coupling need to be at least 24.1. This capability should be
+            regarded as *Beta* as it may be subject to revision when extended to other
+            products.
+
+        The remainder of the documentation describes the more usual non-session mode.
+
+
+    essentialArgNames_extra: []
+    optionalArgNames_extra:
+    - participant_session
+    args_extra:
+    - #!!python/tuple
+        - participant_session
+        -   pyname: participant_session
+            Type: <class 'object'>
+            type: ParticipantSession
+            doc: |-
+                Participant session object conforming to the ``ParticipantProtocol`` protocol class.
 -   name: interrupt
     pyname: interrupt
     exposure: solution

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

@@ -46,6 +46,7 @@ _property_types = {
 
 # Command arguments still defined as settings classes
 _arg_types = {
+    "ParticipantSession": ParticipantSession,
     "Integer": Integer,
     "Logical": Boolean,
     "Real": Real,
@@ -211,6 +212,7 @@ def _get_cls(name, info, parent):
             # pylint: disable=no-member
             cls.command_names.append(ccls.__name__)
             setattr(cls, ccls.__name__, ccls)
+        cls.command_names.sort()
 
     arguments = info.get("args")
     if arguments: