ansys-systemcoupling-core 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

ansys/systemcoupling/core/adaptor/api_25_1/unmapped_value_options.py

@@ -0,0 +1,158 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class unmapped_value_options(Container):
+    """
+    Unmapped value settings.
+    """
+
+    syc_name = "UnmappedValueOptions"
+
+    property_names_types = [
+        ("matrix_verbosity", "MatrixVerbosity", "int"),
+        ("solver_verbosity", "SolverVerbosity", "int"),
+        ("solver", "Solver", "str"),
+        ("solver_relative_tolerance", "SolverRelativeTolerance", "RealType"),
+        ("solver_max_iterations", "SolverMaxIterations", "int"),
+        ("solver_max_search_directions", "SolverMaxSearchDirections", "int"),
+        ("preconditioner", "Preconditioner", "str"),
+        ("ilut_tau", "IlutTau", "RealType"),
+        ("ilut_max_fill", "IlutMaxFill", "int"),
+        ("ilut_pivot_tol", "IlutPivotTol", "RealType"),
+        ("face_filter_tolerance", "FaceFilterTolerance", "RealType"),
+        ("rbf_shape_parameter", "RbfShapeParameter", "RealType"),
+        ("rbf_linear_correction", "RbfLinearCorrection", "bool"),
+        ("rbf_colinearity_tolerance", "RbfColinearityTolerance", "RealType"),
+    ]
+
+    @property
+    def matrix_verbosity(self) -> int:
+        """Matrix verbosity."""
+        return self.get_property_state("matrix_verbosity")
+
+    @matrix_verbosity.setter
+    def matrix_verbosity(self, value: int):
+        self.set_property_state("matrix_verbosity", value)
+
+    @property
+    def solver_verbosity(self) -> int:
+        """Solver verbosity."""
+        return self.get_property_state("solver_verbosity")
+
+    @solver_verbosity.setter
+    def solver_verbosity(self, value: int):
+        self.set_property_state("solver_verbosity", value)
+
+    @property
+    def solver(self) -> str:
+        """Solver (\"GMRES\" or \"FGMRES\")."""
+        return self.get_property_state("solver")
+
+    @solver.setter
+    def solver(self, value: str):
+        self.set_property_state("solver", value)
+
+    @property
+    def solver_relative_tolerance(self) -> RealType:
+        """Solver relative tolerance"""
+        return self.get_property_state("solver_relative_tolerance")
+
+    @solver_relative_tolerance.setter
+    def solver_relative_tolerance(self, value: RealType):
+        self.set_property_state("solver_relative_tolerance", value)
+
+    @property
+    def solver_max_iterations(self) -> int:
+        """Solver maximum iterations."""
+        return self.get_property_state("solver_max_iterations")
+
+    @solver_max_iterations.setter
+    def solver_max_iterations(self, value: int):
+        self.set_property_state("solver_max_iterations", value)
+
+    @property
+    def solver_max_search_directions(self) -> int:
+        """Solver maximum search directions."""
+        return self.get_property_state("solver_max_search_directions")
+
+    @solver_max_search_directions.setter
+    def solver_max_search_directions(self, value: int):
+        self.set_property_state("solver_max_search_directions", value)
+
+    @property
+    def preconditioner(self) -> str:
+        """Preconditioner type (\"None\" or \"ILUT\")."""
+        return self.get_property_state("preconditioner")
+
+    @preconditioner.setter
+    def preconditioner(self, value: str):
+        self.set_property_state("preconditioner", value)
+
+    @property
+    def ilut_tau(self) -> RealType:
+        """Tolerance for ILUT."""
+        return self.get_property_state("ilut_tau")
+
+    @ilut_tau.setter
+    def ilut_tau(self, value: RealType):
+        self.set_property_state("ilut_tau", value)
+
+    @property
+    def ilut_max_fill(self) -> int:
+        """Maximum fill level for ILUT."""
+        return self.get_property_state("ilut_max_fill")
+
+    @ilut_max_fill.setter
+    def ilut_max_fill(self, value: int):
+        self.set_property_state("ilut_max_fill", value)
+
+    @property
+    def ilut_pivot_tol(self) -> RealType:
+        """Pivot tolerance for ILUT."""
+        return self.get_property_state("ilut_pivot_tol")
+
+    @ilut_pivot_tol.setter
+    def ilut_pivot_tol(self, value: RealType):
+        self.set_property_state("ilut_pivot_tol", value)
+
+    @property
+    def face_filter_tolerance(self) -> RealType:
+        """Tolerance (angle, in degrees) for which to consider nearby faces to be sufficiently
+        aligned to be included in the algorithm."""
+        return self.get_property_state("face_filter_tolerance")
+
+    @face_filter_tolerance.setter
+    def face_filter_tolerance(self, value: RealType):
+        self.set_property_state("face_filter_tolerance", value)
+
+    @property
+    def rbf_shape_parameter(self) -> RealType:
+        """Radial basis function shape parameter for Gaussian shape function."""
+        return self.get_property_state("rbf_shape_parameter")
+
+    @rbf_shape_parameter.setter
+    def rbf_shape_parameter(self, value: RealType):
+        self.set_property_state("rbf_shape_parameter", value)
+
+    @property
+    def rbf_linear_correction(self) -> bool:
+        """Control whether the radial basis function linear correction is active."""
+        return self.get_property_state("rbf_linear_correction")
+
+    @rbf_linear_correction.setter
+    def rbf_linear_correction(self, value: bool):
+        self.set_property_state("rbf_linear_correction", value)
+
+    @property
+    def rbf_colinearity_tolerance(self) -> RealType:
+        """Tolerance to use for checking colinearity of nearby data when using the radial
+        basis functions for non-overlap extrapolation."""
+        return self.get_property_state("rbf_colinearity_tolerance")
+
+    @rbf_colinearity_tolerance.setter
+    def rbf_colinearity_tolerance(self, value: RealType):
+        self.set_property_state("rbf_colinearity_tolerance", value)

ansys/systemcoupling/core/adaptor/api_25_1/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_25_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_25_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_25_1/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_25_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_25_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"