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

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

@@ -0,0 +1,46 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class automatic_alignment_options(Container):
+    """
+    Automatic alignment settings.
+    """
+
+    syc_name = "AutomaticAlignmentOptions"
+
+    property_names_types = [
+        ("alignment_type", "AlignmentType", "str"),
+        ("singular_value_tolerance", "SingularValueTolerance", "RealType"),
+        ("verbosity", "Verbosity", "int"),
+    ]
+
+    @property
+    def alignment_type(self) -> str:
+        """Alignment type (\"Covariance\" or \"Moment Covariance\" or \"Inertial Axes\")."""
+        return self.get_property_state("alignment_type")
+
+    @alignment_type.setter
+    def alignment_type(self, value: str):
+        self.set_property_state("alignment_type", value)
+
+    @property
+    def singular_value_tolerance(self) -> RealType:
+        """Tolerance used to compare singular values"""
+        return self.get_property_state("singular_value_tolerance")
+
+    @singular_value_tolerance.setter
+    def singular_value_tolerance(self, value: RealType):
+        self.set_property_state("singular_value_tolerance", value)
+
+    @property
+    def verbosity(self) -> int:
+        """Set to 1 to print additional information about the alignment"""
+        return self.get_property_state("verbosity")
+
+    @verbosity.setter
+    def verbosity(self, value: int):
+        self.set_property_state("verbosity", value)

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

@@ -0,0 +1,40 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class available_ports(Container):
+    """
+    Specify ports available for co-simulation.
+    """
+
+    syc_name = "AvailablePorts"
+
+    property_names_types = [("option", "Option", "str"), ("range", "Range", "str")]
+
+    @property
+    def option(self) -> str:
+        """Specify how available ports are determined.
+
+        - \"ProgramControlled\" - System Coupling will find an
+          available port.
+        - \"UserDefined\" - An available port will be chosen,
+          if possible, from a specified range."""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def range(self) -> str:
+        """Port range expressed as a comma-separated list of integers and/or
+        integer ranges. An integer range is a pair of integers separated
+        with a "-" character, specify an inclusive range of port numbers."""
+        return self.get_property_state("range")
+
+    @range.setter
+    def range(self, value: str):
+        self.set_property_state("range", value)

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

@@ -0,0 +1,46 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class avoid_data_reconstruction(Container):
+    """
+    Control whether data reconstruction should be done for elemental intensive data.
+    """
+
+    syc_name = "AvoidDataReconstruction"
+
+    property_names_types = [
+        ("volume_mapping", "VolumeMapping", "bool"),
+        ("surface_mapping", "SurfaceMapping", "bool"),
+        ("surface_volume_mapping", "SurfaceVolumeMapping", "bool"),
+    ]
+
+    @property
+    def volume_mapping(self) -> bool:
+        """UNDOCUMENTED"""
+        return self.get_property_state("volume_mapping")
+
+    @volume_mapping.setter
+    def volume_mapping(self, value: bool):
+        self.set_property_state("volume_mapping", value)
+
+    @property
+    def surface_mapping(self) -> bool:
+        """UNDOCUMENTED"""
+        return self.get_property_state("surface_mapping")
+
+    @surface_mapping.setter
+    def surface_mapping(self, value: bool):
+        self.set_property_state("surface_mapping", value)
+
+    @property
+    def surface_volume_mapping(self) -> bool:
+        """UNDOCUMENTED"""
+        return self.get_property_state("surface_volume_mapping")
+
+    @surface_volume_mapping.setter
+    def surface_volume_mapping(self, value: bool):
+        self.set_property_state("surface_volume_mapping", value)

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

@@ -0,0 +1,62 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+SHASH = "0fbfd3e7593591d8e52193a6e92828c6174e531b26437aee17285b3d0d114664"
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .clear_state import clear_state
+from .delete_snapshot import delete_snapshot
+from .get_snapshots import get_snapshots
+from .open import open
+from .open_snapshot import open_snapshot
+from .save import save
+from .save_snapshot import save_snapshot
+
+
+class case_root(Container):
+    """
+    'root' object
+    """
+
+    syc_name = "CaseCommands"
+
+    command_names = [
+        "clear_state",
+        "delete_snapshot",
+        "get_snapshots",
+        "open",
+        "open_snapshot",
+        "save",
+        "save_snapshot",
+    ]
+
+    clear_state: clear_state = clear_state
+    """
+    clear_state command of case_root.
+    """
+    delete_snapshot: delete_snapshot = delete_snapshot
+    """
+    delete_snapshot command of case_root.
+    """
+    get_snapshots: get_snapshots = get_snapshots
+    """
+    get_snapshots command of case_root.
+    """
+    open: open = open
+    """
+    open command of case_root.
+    """
+    open_snapshot: open_snapshot = open_snapshot
+    """
+    open_snapshot command of case_root.
+    """
+    save: save = save
+    """
+    save command of case_root.
+    """
+    save_snapshot: save_snapshot = save_snapshot
+    """
+    save_snapshot command of case_root.
+    """

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

@@ -0,0 +1,16 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class clear_state(Command):
+    """
+    Clears the state of the entire System Coupling service, removing all
+    data model items, parameter values, and calculated values.
+
+    Cannot be run after participants have been started.
+    """
+
+    syc_name = "ClearState"

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

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

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

@@ -0,0 +1,42 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .data_transfer import data_transfer
+from .mapping_control import mapping_control
+from .side import side
+
+
+class coupling_interface_child(Container):
+    """
+    Configure a coupling interface.
+    """
+
+    syc_name = "child_object_type"
+
+    child_names = ["side", "data_transfer", "mapping_control"]
+
+    side: side = side
+    """
+    side child of coupling_interface_child.
+    """
+    data_transfer: data_transfer = data_transfer
+    """
+    data_transfer child of coupling_interface_child.
+    """
+    mapping_control: mapping_control = mapping_control
+    """
+    mapping_control child of coupling_interface_child.
+    """
+    property_names_types = [("display_name", "DisplayName", "str")]
+
+    @property
+    def display_name(self) -> str:
+        """Set the display name of an object."""
+        return self.get_property_state("display_name")
+
+    @display_name.setter
+    def display_name(self, value: str):
+        self.set_property_state("display_name", value)

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

@@ -0,0 +1,23 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .coupling_participant_child import coupling_participant_child
+
+
+class coupling_participant(NamedContainer[coupling_participant_child]):
+    """
+    Configure a coupling participant.
+
+    These settings are typically populated by using the ``add_participant``
+    command.
+    """
+
+    syc_name = "CouplingParticipant"
+
+    child_object_type: coupling_participant_child = coupling_participant_child
+    """
+    child_object_type of coupling_participant.
+    """

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

@@ -0,0 +1,230 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .execution_control import execution_control
+from .external_data_file import external_data_file
+from .fmu_parameter import fmu_parameter
+from .parameter import parameter
+from .region import region
+from .update_control import update_control
+from .variable import variable
+
+
+class coupling_participant_child(Container):
+    """
+    Configure a coupling participant.
+
+    These settings are typically populated by using the ``add_participant``
+    command.
+    """
+
+    syc_name = "child_object_type"
+
+    child_names = [
+        "variable",
+        "parameter",
+        "region",
+        "update_control",
+        "fmu_parameter",
+        "execution_control",
+        "external_data_file",
+    ]
+
+    variable: variable = variable
+    """
+    variable child of coupling_participant_child.
+    """
+    parameter: parameter = parameter
+    """
+    parameter child of coupling_participant_child.
+    """
+    region: region = region
+    """
+    region child of coupling_participant_child.
+    """
+    update_control: update_control = update_control
+    """
+    update_control child of coupling_participant_child.
+    """
+    fmu_parameter: fmu_parameter = fmu_parameter
+    """
+    fmu_parameter child of coupling_participant_child.
+    """
+    execution_control: execution_control = execution_control
+    """
+    execution_control child of coupling_participant_child.
+    """
+    external_data_file: external_data_file = external_data_file
+    """
+    external_data_file child of coupling_participant_child.
+    """
+    property_names_types = [
+        ("participant_type", "ParticipantType", "str"),
+        ("participant_display_name", "ParticipantDisplayName", "str"),
+        ("display_name", "DisplayName", "str"),
+        ("dimension", "Dimension", "str"),
+        ("input_variables", "InputVariables", "StringListType"),
+        ("output_variables", "OutputVariables", "StringListType"),
+        ("input_parameters", "InputParameters", "StringListType"),
+        ("output_parameters", "OutputParameters", "StringListType"),
+        ("participant_file_loaded", "ParticipantFileLoaded", "str"),
+        ("logging_on", "LoggingOn", "bool"),
+        ("participant_analysis_type", "ParticipantAnalysisType", "str"),
+        ("use_new_apis", "UseNewAPIs", "bool"),
+        ("restarts_supported", "RestartsSupported", "bool"),
+        ("can_serialize_fmu_state", "CanSerializeFmuState", "bool"),
+        ("instancing", "Instancing", "str"),
+    ]
+
+    @property
+    def participant_type(self) -> str:
+        """Coupling participant type.
+
+        Allowed values:
+        - \"DEFAULT\"
+        - \"CFX\"
+        - \"FLUENT\"
+        - \"MAPDL\"
+        - \"AEDT\"
+        - \"FMU\"
+        - \"EXTERNALDATA\"
+        - \"FORTE\"
+        - \"DEFAULT-SRV\"
+        - \"MECH-SRV\"
+        - \"CFD-SRV\"
+        - \"SCDT-SRV\" """
+        return self.get_property_state("participant_type")
+
+    @participant_type.setter
+    def participant_type(self, value: str):
+        self.set_property_state("participant_type", value)
+
+    @property
+    def participant_display_name(self) -> str:
+        """Participant's display name as defined by the participant solver (as
+        opposed to System Coupling's ``display_name`` for the participant)."""
+        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:
+        """Participant'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 dimension(self) -> str:
+        """Dimension of the participant (\"2D\" or \"3D\")."""
+        return self.get_property_state("dimension")
+
+    @dimension.setter
+    def dimension(self, value: str):
+        self.set_property_state("dimension", value)
+
+    @property
+    def input_variables(self) -> StringListType:
+        """Input variables for the region or FMU."""
+        return self.get_property_state("input_variables")
+
+    @input_variables.setter
+    def input_variables(self, value: StringListType):
+        self.set_property_state("input_variables", value)
+
+    @property
+    def output_variables(self) -> StringListType:
+        """Output variables for the region or FMU."""
+        return self.get_property_state("output_variables")
+
+    @output_variables.setter
+    def output_variables(self, value: StringListType):
+        self.set_property_state("output_variables", value)
+
+    @property
+    def input_parameters(self) -> StringListType:
+        """Input parameters for the solver."""
+        return self.get_property_state("input_parameters")
+
+    @input_parameters.setter
+    def input_parameters(self, value: StringListType):
+        self.set_property_state("input_parameters", value)
+
+    @property
+    def output_parameters(self) -> StringListType:
+        """Output parameters for the solver."""
+        return self.get_property_state("output_parameters")
+
+    @output_parameters.setter
+    def output_parameters(self, value: StringListType):
+        self.set_property_state("output_parameters", value)
+
+    @property
+    def participant_file_loaded(self) -> str:
+        """File used to generate the participant."""
+        return self.get_property_state("participant_file_loaded")
+
+    @participant_file_loaded.setter
+    def participant_file_loaded(self, value: str):
+        self.set_property_state("participant_file_loaded", value)
+
+    @property
+    def logging_on(self) -> bool:
+        """Specifies whether logging is activated for the participant."""
+        return self.get_property_state("logging_on")
+
+    @logging_on.setter
+    def logging_on(self, value: bool):
+        self.set_property_state("logging_on", value)
+
+    @property
+    def participant_analysis_type(self) -> str:
+        """Coupling participant analysis type (\"Steady\" or \"Transient\")."""
+        return self.get_property_state("participant_analysis_type")
+
+    @participant_analysis_type.setter
+    def participant_analysis_type(self, value: str):
+        self.set_property_state("participant_analysis_type", value)
+
+    @property
+    def use_new_apis(self) -> bool:
+        """Controls whether Fluent/MAPDL/AEDT/CFX participant should communicate using new APIs."""
+        return self.get_property_state("use_new_apis")
+
+    @use_new_apis.setter
+    def use_new_apis(self, value: bool):
+        self.set_property_state("use_new_apis", value)
+
+    @property
+    def restarts_supported(self) -> bool:
+        """Indicates whether the participant supports restarts."""
+        return self.get_property_state("restarts_supported")
+
+    @restarts_supported.setter
+    def restarts_supported(self, value: bool):
+        self.set_property_state("restarts_supported", value)
+
+    @property
+    def can_serialize_fmu_state(self) -> bool:
+        """Indicates whether the FMU can state can be serialized."""
+        return self.get_property_state("can_serialize_fmu_state")
+
+    @can_serialize_fmu_state.setter
+    def can_serialize_fmu_state(self, value: bool):
+        self.set_property_state("can_serialize_fmu_state", value)
+
+    @property
+    def instancing(self) -> str:
+        """Set instancing on the participant."""
+        return self.get_property_state("instancing")
+
+    @instancing.setter
+    def instancing(self, value: str):
+        self.set_property_state("instancing", value)

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

@@ -0,0 +1,29 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class create_restart_point(Command):
+    """
+    Interactive command that creates a restart point at the end of the
+    last completed coupling step.
+
+    Signals the System Coupling service and all coupling participants that a
+    restart point should be created before the next coupling step begins. The
+    restart point is created in addition to restart points created by the
+    ``output_control`` setting in the data model.
+
+    Note that some participants write their restart files only when the
+    coupling run resumes, so their files will not be available immediately
+    after the command is issued.
+
+    Results information for the coupling step is written to a file named
+    according to the convention ``Results_#.h5``, where ``_#`` is the number of
+    the coupling step. By default, the restart files are written to the ``SyC``
+    directory, which is automatically created by the System Coupling service
+    when restart points are created.
+    """
+
+    syc_name = "CreateRestartPoint"

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

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