ansys-systemcoupling-core 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

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

@@ -0,0 +1,272 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .attribute import attribute
+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 .properties import properties
+from .record_interactions import record_interactions
+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",
+        "attribute",
+        "region",
+        "properties",
+        "update_control",
+        "fmu_parameter",
+        "execution_control",
+        "external_data_file",
+        "record_interactions",
+    ]
+
+    variable: variable = variable
+    """
+    variable child of coupling_participant_child.
+    """
+    parameter: parameter = parameter
+    """
+    parameter child of coupling_participant_child.
+    """
+    attribute: attribute = attribute
+    """
+    attribute child of coupling_participant_child.
+    """
+    region: region = region
+    """
+    region child of coupling_participant_child.
+    """
+    properties: properties = properties
+    """
+    properties 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.
+    """
+    record_interactions: record_interactions = record_interactions
+    """
+    record_interactions 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"),
+        ("can_get_and_set_fmu_state", "CanGetAndSetFmuState", "bool"),
+        ("free_fmu_state", "FreeFmuState", "bool"),
+        ("instancing", "Instancing", "str"),
+    ]
+
+    @property
+    def participant_type(self) -> str:
+        """Coupling participant type.
+
+        Allowed values:
+        - \"DEFAULT\"
+        - \"CFX\"
+        - \"FLUENT\"
+        - \"MAPDL\"
+        - \"AEDT\"
+        - \"FMU\"
+        - \"FMU-PROXY\"
+        - \"EXTERNALDATA\"
+        - \"FORTE\"
+        - \"DEFAULT-SRV\"
+        - \"MECH-SRV\"
+        - \"CFD-SRV\"
+        - \"SCDT-SRV\"
+        - \"THERMAL-DESKTOP\"
+        - \"LS-DYNA\"
+        - \"ROCKY\" """
+        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 can_get_and_set_fmu_state(self) -> bool:
+        """Indicates whether the FMU can get and set its state."""
+        return self.get_property_state("can_get_and_set_fmu_state")
+
+    @can_get_and_set_fmu_state.setter
+    def can_get_and_set_fmu_state(self, value: bool):
+        self.set_property_state("can_get_and_set_fmu_state", value)
+
+    @property
+    def free_fmu_state(self) -> bool:
+        """Optionally Frees the FMU state prior to calling CanGetAndSetFmuState"""
+        return self.get_property_state("free_fmu_state")
+
+    @free_fmu_state.setter
+    def free_fmu_state(self, value: bool):
+        self.set_property_state("free_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_25_2/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_25_2/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.
+    """

ansys/systemcoupling/core/adaptor/api_25_2/data_transfer_child.py

@@ -0,0 +1,187 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .stabilization import stabilization
+
+
+class data_transfer_child(Container):
+    """
+    Configure data transfers for a coupling interface.
+    """
+
+    syc_name = "child_object_type"
+
+    child_names = ["stabilization"]
+
+    stabilization: stabilization = stabilization
+    """
+    stabilization child of data_transfer_child.
+    """
+    property_names_types = [
+        ("display_name", "DisplayName", "str"),
+        ("suppress", "Suppress", "bool"),
+        ("target_side", "TargetSide", "str"),
+        ("option", "Option", "str"),
+        ("source_variable", "SourceVariable", "str"),
+        ("target_variable", "TargetVariable", "str"),
+        ("value", "Value", "RealType"),
+        ("ramping_option", "RampingOption", "str"),
+        ("relaxation_factor", "RelaxationFactor", "RealType"),
+        ("convergence_target", "ConvergenceTarget", "RealType"),
+        ("mapping_type", "MappingType", "str"),
+        ("unmapped_value_option", "UnmappedValueOption", "str"),
+        ("time_step_initialization_option", "TimeStepInitializationOption", "str"),
+    ]
+
+    @property
+    def display_name(self) -> str:
+        """Display name of the data transfer."""
+        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 suppress(self) -> bool:
+        """Controls whether this data transfer is suppressed"""
+        return self.get_property_state("suppress")
+
+    @suppress.setter
+    def suppress(self, value: bool):
+        self.set_property_state("suppress", value)
+
+    @property
+    def target_side(self) -> str:
+        """Target side (\"One\" or \"Two\") of this data transfer."""
+        return self.get_property_state("target_side")
+
+    @target_side.setter
+    def target_side(self, value: str):
+        self.set_property_state("target_side", value)
+
+    @property
+    def option(self) -> str:
+        """How the transfer data is specified.
+
+        Allowed values:
+
+        - \"UsingVariable\" - The data being transferred is defined as a
+          single source-side variable.
+
+        - \"UsingExpression\" - The data being transferred is defined as
+          an expression in terms of source-side variables."""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def source_variable(self) -> str:
+        """Variable associated with the source side of the interface.
+
+        Specified only for variable-based transfers (and not expression-based)."""
+        return self.get_property_state("source_variable")
+
+    @source_variable.setter
+    def source_variable(self, value: str):
+        self.set_property_state("source_variable", value)
+
+    @property
+    def target_variable(self) -> str:
+        """Variable associated with the target side of the interface."""
+        return self.get_property_state("target_variable")
+
+    @target_variable.setter
+    def target_variable(self, value: str):
+        self.set_property_state("target_variable", value)
+
+    @property
+    def value(self) -> RealType:
+        """Expression string (or constant real value) defining the data being
+        transferred from the source.
+
+        Specified only for expression-based transfers.
+
+        Any variable referenced must be a source side variable."""
+        return self.get_property_state("value")
+
+    @value.setter
+    def value(self, value: RealType):
+        self.set_property_state("value", value)
+
+    @property
+    def ramping_option(self) -> str:
+        """Specify whether to apply ramping to the data transfer.
+
+        Ramping is used to slow the application of the source-side value on the
+        target side of the interface.
+
+        Allowed values:
+
+        - \"None\" - No ramping to be applied.
+
+        - \"Linear\" - Apply linear ramping."""
+        return self.get_property_state("ramping_option")
+
+    @ramping_option.setter
+    def ramping_option(self, value: str):
+        self.set_property_state("ramping_option", value)
+
+    @property
+    def relaxation_factor(self) -> RealType:
+        """Factor multiplying the current data transfer values for specified quantity when
+        under-relaxing them against the previous values."""
+        return self.get_property_state("relaxation_factor")
+
+    @relaxation_factor.setter
+    def relaxation_factor(self, value: RealType):
+        self.set_property_state("relaxation_factor", value)
+
+    @property
+    def convergence_target(self) -> RealType:
+        """RMS-based target value used when evaluating convergence of the specified
+        quantity within a coupling iteration."""
+        return self.get_property_state("convergence_target")
+
+    @convergence_target.setter
+    def convergence_target(self, value: RealType):
+        self.set_property_state("convergence_target", value)
+
+    @property
+    def mapping_type(self) -> str:
+        """Type of mapping used for the data transfer. (**Read only**.)
+
+        Possible values:
+
+        - \"Conservative\" - A conservative mapping algorithm is used
+          for transfers of `extensive` quantities.
+        - \"ProfilePreserving\" - A profile-preserving mapping algorithm
+          is used for transfers of `intensive` quantities."""
+        return self.get_property_state("mapping_type")
+
+    @mapping_type.setter
+    def mapping_type(self, value: str):
+        self.set_property_state("mapping_type", value)
+
+    @property
+    def unmapped_value_option(self) -> str:
+        """Option to fill target values not mapped by the regular mapping algorithm"""
+        return self.get_property_state("unmapped_value_option")
+
+    @unmapped_value_option.setter
+    def unmapped_value_option(self, value: str):
+        self.set_property_state("unmapped_value_option", value)
+
+    @property
+    def time_step_initialization_option(self) -> str:
+        """Method to initialize first transfer in new coupling step."""
+        return self.get_property_state("time_step_initialization_option")
+
+    @time_step_initialization_option.setter
+    def time_step_initialization_option(self, value: str):
+        self.set_property_state("time_step_initialization_option", value)

ansys/systemcoupling/core/adaptor/api_25_2/delete_snapshot.py

@@ -0,0 +1,28 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class delete_snapshot(Command):
+    """
+    Deletes a snapshot if it exists.
+
+    Parameters
+    ----------
+    snapshot_name : str
+        Name of the snapshot to be deleted.
+
+    """
+
+    syc_name = "DeleteSnapshot"
+
+    argument_names = ["snapshot_name"]
+
+    class snapshot_name(String):
+        """
+        Name of the snapshot to be deleted.
+        """
+
+        syc_name = "SnapshotName"

ansys/systemcoupling/core/adaptor/api_25_2/delete_transformation.py

@@ -0,0 +1,42 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class delete_transformation(Command):
+    """
+    Delete a transformation from a reference frame
+
+    In addition to deleting the transformation object, it will also remove the
+    transformation from ``transformation_order`` (if it exists in that list).
+
+    Parameters
+    ----------
+    reference_frame : str
+        Name of the reference frame from which the transformation will be
+        deleted.
+    transformation_name : str
+        Name of the transformation which will be deleted.
+
+    """
+
+    syc_name = "DeleteTransformation"
+
+    argument_names = ["reference_frame", "transformation_name"]
+
+    class reference_frame(String):
+        """
+        Name of the reference frame from which the transformation will be
+        deleted.
+        """
+
+        syc_name = "ReferenceFrame"
+
+    class transformation_name(String):
+        """
+        Name of the transformation which will be deleted.
+        """
+
+        syc_name = "TransformationName"

ansys/systemcoupling/core/adaptor/api_25_2/dimensionality.py

@@ -0,0 +1,96 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class dimensionality(Container):
+    """
+    Configure attribute dimensionality.
+    """
+
+    syc_name = "Dimensionality"
+
+    property_names_types = [
+        ("length", "Length", "RealType"),
+        ("time", "Time", "RealType"),
+        ("mass", "Mass", "RealType"),
+        ("temperature", "Temperature", "RealType"),
+        ("amount_of_substance", "AmountOfSubstance", "RealType"),
+        ("current", "Current", "RealType"),
+        ("luminous_intensity", "LuminousIntensity", "RealType"),
+        ("angle", "Angle", "RealType"),
+    ]
+
+    @property
+    def length(self) -> RealType:
+        """Exponent of length dimension."""
+        return self.get_property_state("length")
+
+    @length.setter
+    def length(self, value: RealType):
+        self.set_property_state("length", value)
+
+    @property
+    def time(self) -> RealType:
+        """Exponent of time dimension."""
+        return self.get_property_state("time")
+
+    @time.setter
+    def time(self, value: RealType):
+        self.set_property_state("time", value)
+
+    @property
+    def mass(self) -> RealType:
+        """Exponent of mass dimension."""
+        return self.get_property_state("mass")
+
+    @mass.setter
+    def mass(self, value: RealType):
+        self.set_property_state("mass", value)
+
+    @property
+    def temperature(self) -> RealType:
+        """Exponent of temperature dimension."""
+        return self.get_property_state("temperature")
+
+    @temperature.setter
+    def temperature(self, value: RealType):
+        self.set_property_state("temperature", value)
+
+    @property
+    def amount_of_substance(self) -> RealType:
+        """Exponent of amount of substance dimension."""
+        return self.get_property_state("amount_of_substance")
+
+    @amount_of_substance.setter
+    def amount_of_substance(self, value: RealType):
+        self.set_property_state("amount_of_substance", value)
+
+    @property
+    def current(self) -> RealType:
+        """Exponent of electric current dimension."""
+        return self.get_property_state("current")
+
+    @current.setter
+    def current(self, value: RealType):
+        self.set_property_state("current", value)
+
+    @property
+    def luminous_intensity(self) -> RealType:
+        """Exponent of luminous intensity dimension."""
+        return self.get_property_state("luminous_intensity")
+
+    @luminous_intensity.setter
+    def luminous_intensity(self, value: RealType):
+        self.set_property_state("luminous_intensity", value)
+
+    @property
+    def angle(self) -> RealType:
+        """Exponent of angle dimension."""
+        return self.get_property_state("angle")
+
+    @angle.setter
+    def angle(self, value: RealType):
+        self.set_property_state("angle", value)