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

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

@@ -0,0 +1,30 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class solve(InjectedCommand):
+    """
+    Starts the participants (if necessary) and solves the coupled analysis. By
+    default, the solution runs straight through without pause unless stopped by
+    an scStop file.
+
+    Disabled when a solution is already in progress.
+
+    For restarts, the ``open`` command must be run before the ``solve`` command.
+
+    Note that if the ``execution_control`` option for a participant is set to
+    \"ExternallyManaged\", then System Coupling will not start the participant
+    using either this command or any of the other commands that automatically
+    start participants. The user is expected to manually start the participant.
+    This function will not return until all participants have been connected.
+
+    Note that this command will raise an exception if another instance of
+    System Coupling is solving in the current working directory.
+    """
+
+    syc_name = "solve"
+
+    cmd_name = "solve"

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

@@ -0,0 +1,157 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class stabilization(Container):
+    """
+    Stabilization and Acceleration method.
+    """
+
+    syc_name = "Stabilization"
+
+    property_names_types = [
+        ("option", "Option", "str"),
+        ("couple_with_global_stabilization", "CoupleWithGlobalStabilization", "bool"),
+        ("initial_iterations", "InitialIterations", "int"),
+        ("initial_relaxation_factor", "InitialRelaxationFactor", "RealType"),
+        ("maximum_retained_time_steps", "MaximumRetainedTimeSteps", "int"),
+        ("maximum_retained_iterations", "MaximumRetainedIterations", "int"),
+        ("weight_factor", "WeightFactor", "RealType"),
+        ("diagnostics_level", "DiagnosticsLevel", "int"),
+        ("weight_option", "WeightOption", "str"),
+        ("qr_tol_this_step", "QRTolThisStep", "RealType"),
+        ("qr_tol_old_steps", "QRTolOldSteps", "RealType"),
+        ("time_step_initialization_option", "TimeStepInitializationOption", "str"),
+    ]
+
+    @property
+    def option(self) -> str:
+        """Allowed values:
+
+        - \"ProgramControlled\"
+        - \"None\"
+        - \"Quasi-Newton\"
+        - \"Aitken\" (Alpha only)"""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def couple_with_global_stabilization(self) -> bool:
+        """Controls whether the stabilization for this data transfer is coupled with the global stabilization."""
+        return self.get_property_state("couple_with_global_stabilization")
+
+    @couple_with_global_stabilization.setter
+    def couple_with_global_stabilization(self, value: bool):
+        self.set_property_state("couple_with_global_stabilization", value)
+
+    @property
+    def initial_iterations(self) -> int:
+        """Number of pre-stabilization iterations to perform."""
+        return self.get_property_state("initial_iterations")
+
+    @initial_iterations.setter
+    def initial_iterations(self, value: int):
+        self.set_property_state("initial_iterations", value)
+
+    @property
+    def initial_relaxation_factor(self) -> RealType:
+        """Relaxation factor applied for pre-stabilization iterations."""
+        return self.get_property_state("initial_relaxation_factor")
+
+    @initial_relaxation_factor.setter
+    def initial_relaxation_factor(self, value: RealType):
+        self.set_property_state("initial_relaxation_factor", value)
+
+    @property
+    def maximum_retained_time_steps(self) -> int:
+        """Controls the maximum number of timesteps to retain."""
+        return self.get_property_state("maximum_retained_time_steps")
+
+    @maximum_retained_time_steps.setter
+    def maximum_retained_time_steps(self, value: int):
+        self.set_property_state("maximum_retained_time_steps", value)
+
+    @property
+    def maximum_retained_iterations(self) -> int:
+        """Controls the maximum number of iterations to retain."""
+        return self.get_property_state("maximum_retained_iterations")
+
+    @maximum_retained_iterations.setter
+    def maximum_retained_iterations(self, value: int):
+        self.set_property_state("maximum_retained_iterations", value)
+
+    @property
+    def weight_factor(self) -> RealType:
+        """Weighting factor to use for this data transfer in IQN-ILS."""
+        return self.get_property_state("weight_factor")
+
+    @weight_factor.setter
+    def weight_factor(self, value: RealType):
+        self.set_property_state("weight_factor", value)
+
+    @property
+    def diagnostics_level(self) -> int:
+        """Controls the maximum number of timesteps to retain.
+
+        Values are interpreted as:
+
+        - 0 : none
+        - 1 : basic
+        - 2 : advanced
+        - 3 : write matrix files"""
+        return self.get_property_state("diagnostics_level")
+
+    @diagnostics_level.setter
+    def diagnostics_level(self, value: int):
+        self.set_property_state("diagnostics_level", value)
+
+    @property
+    def weight_option(self) -> str:
+        """Weight factor when multiple transfers are stabilized.
+
+        Allowed values:
+
+        - \"Constant\"
+        - \"Value\"
+        - \"Residual\"
+        - \"ResidualSum\"
+        - \"InverseResidual\"
+        - \"InverseResidualSum\" """
+        return self.get_property_state("weight_option")
+
+    @weight_option.setter
+    def weight_option(self, value: str):
+        self.set_property_state("weight_option", value)
+
+    @property
+    def qr_tol_this_step(self) -> RealType:
+        """QR filter tolerance for current step."""
+        return self.get_property_state("qr_tol_this_step")
+
+    @qr_tol_this_step.setter
+    def qr_tol_this_step(self, value: RealType):
+        self.set_property_state("qr_tol_this_step", value)
+
+    @property
+    def qr_tol_old_steps(self) -> RealType:
+        """QR filter tolerance for old steps."""
+        return self.get_property_state("qr_tol_old_steps")
+
+    @qr_tol_old_steps.setter
+    def qr_tol_old_steps(self, value: RealType):
+        self.set_property_state("qr_tol_old_steps", value)
+
+    @property
+    def time_step_initialization_option(self) -> str:
+        """Controls how Aitken relaxation factor is initialized at start of new timestep."""
+        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/step.py

@@ -0,0 +1,57 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class step(Command):
+    """
+    Interactive command that initializes the analysis (if necessary) and
+    runs the specified number of coupling steps before pausing the coupled
+    analysis.
+
+    Disabled when a solution is already in progress.
+
+    Disabled for iterations-only steady analyses.
+
+    By default, runs a single step. If given the optional ``count`` argument,
+    then runs the specified number of steps.
+
+    For restarts, the ``open`` command must be run before the ``step`` command.
+
+    When you run this command, System Coupling initializes the analysis if
+    needed and then begins the solution. When the specified number of coupling
+    steps has been run, the solution is paused, providing you with an
+    opportunity to interact with the analysis.
+
+    Note that if the ``execution_control`` option for a participant is set to
+    ExternallyManaged, then System Coupling will not start the participant
+    using either this command or any of the other commands that automatically
+    start participants. The user is expected to manually start the participant.
+    This function will not return until all participants have been connected.
+
+    When the solution is resumed, either by reissuing this command or by
+    running the ``solve`` command, System Coupling restarts the analysis at the
+    point it left off and continues the solution with the next step.
+
+    Note that this command will raise an exception if another instance of
+    System Coupling is solving in the current working directory.
+
+    Parameters
+    ----------
+    count : int, optional
+        Integer specifying the number of steps to be run. Defaults to 1.
+
+    """
+
+    syc_name = "Step"
+
+    argument_names = ["count"]
+
+    class count(Integer):
+        """
+        Integer specifying the number of steps to be run. Defaults to 1.
+        """
+
+        syc_name = "Count"

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

@@ -0,0 +1,21 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .transformation_child import transformation_child
+
+
+class transformation(NamedContainer[transformation_child]):
+    """
+    Use to apply transformations to coupling interface sides to control
+    positioning of the geometry.
+    """
+
+    syc_name = "Transformation"
+
+    child_object_type: transformation_child = transformation_child
+    """
+    child_object_type of transformation.
+    """

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

@@ -0,0 +1,62 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class transformation_child(Container):
+    """
+    Use to apply transformations to coupling interface sides to control
+    positioning of the geometry.
+    """
+
+    syc_name = "child_object_type"
+
+    property_names_types = [
+        ("option", "Option", "str"),
+        ("angle", "Angle", "RealType"),
+        ("axis", "Axis", "str"),
+        ("vector", "Vector", "RealVectorType"),
+    ]
+
+    @property
+    def option(self) -> str:
+        """Specifies the type of transformation, ``Rotation`` or ``Translation``."""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def angle(self) -> RealType:
+        """The angle of rotation for a rotation transformation."""
+        return self.get_property_state("angle")
+
+    @angle.setter
+    def angle(self, value: RealType):
+        self.set_property_state("angle", value)
+
+    @property
+    def axis(self) -> str:
+        """The axis of rotation to be used for a rotation transformation.
+
+        - \"XAxis\" - Rotation is about the x-axis.
+        - \"YAxis\" - Rotation is about the y-axis.
+        - \"ZAxis\" - Rotation is about the z-axis.
+        - \"UserDefined\" - Rotation is about a user defined vector."""
+        return self.get_property_state("axis")
+
+    @axis.setter
+    def axis(self, value: str):
+        self.set_property_state("axis", value)
+
+    @property
+    def vector(self) -> RealVectorType:
+        """Define an axis of rotation vector in the ``UserDefined`` case."""
+        return self.get_property_state("vector")
+
+    @vector.setter
+    def vector(self, value: RealVectorType):
+        self.set_property_state("vector", value)

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

@@ -0,0 +1,39 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class type(Container):
+    """
+    File type for result output.
+    """
+
+    syc_name = "Type"
+
+    property_names_types = [
+        ("option", "Option", "str"),
+        ("binary_format", "BinaryFormat", "bool"),
+    ]
+
+    @property
+    def option(self) -> str:
+        """Allowed values:
+
+        - \"EnsightGold\"
+        - \"DVS\" """
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def binary_format(self) -> bool:
+        """Output in Binary or ASCII format."""
+        return self.get_property_state("binary_format")
+
+    @binary_format.setter
+    def binary_format(self, value: bool):
+        self.set_property_state("binary_format", value)

ansys/systemcoupling/core/adaptor/api_25_2/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_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_25_2/update_interfaces.py

@@ -0,0 +1,19 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class update_interfaces(Command):
+    """
+    Command to apply transformation and instance defined in the interfaces.
+    And display mapping mesh with the transformation and instance applied in the
+    System Coupling viewer.
+
+    The purpose of this command is to visually confirm the correctness of coupling
+    interfaces definition, alignment and instancing settings, and to allow modifying
+    those settings to fix any issues ("nudge" the alignment, etc.)
+    """
+
+    syc_name = "UpdateInterfaces"

ansys/systemcoupling/core/adaptor/api_25_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 participant, updates the state of the participant.
+
+    Available for DEFAULT-SRV, CFD-SRV, MECH-SRV, and SCDT-SRV and
+    AEDT participants.
+
+    As part of the update, System Coupling updates all regions, variables,
+    and parameters defined in the participant, including all variable
+    attributes. Regions, variables, and parameters 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.
+
+    Note: AEDT participants must be updated using an scp file.
+
+    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.
+    input_file : str, optional
+        Name of the input file for the participant to be added.
+        Currently supported formats are SCP files, mechanical server
+        (*.rst) files, cfd server (*.csv) files, 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.
+        """
+
+        syc_name = "ParticipantName"
+
+    class input_file(String):
+        """
+        Name of the input file for the participant to be added.
+        Currently supported formats are SCP files, mechanical server
+        (*.rst) files, cfd server (*.csv) files, and system coupling
+        data server (*.scdt/axdt/csv) files.
+        """
+
+        syc_name = "InputFile"

ansys/systemcoupling/core/adaptor/api_25_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.
+    """