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

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

@@ -0,0 +1,110 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+SHASH = "f7545cd9b5d857e7086be22fb7770696f0d1c5aea6299f3573c79899a6877d65"
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from ._solve import _solve
+from .abort import abort
+from .create_restart_point import create_restart_point
+from .get_machines import get_machines
+from .get_transformation import get_transformation
+from .initialize import initialize
+from .interrupt import interrupt
+from .open_results_in_en_sight import open_results_in_en_sight
+from .partition_participants import partition_participants
+from .shutdown import shutdown
+from .solve import solve
+from .start_participants import start_participants
+from .step import step
+from .write_csv_chart_files import write_csv_chart_files
+from .write_ensight import write_ensight
+
+
+class solution_root(Container):
+    """
+    'root' object
+    """
+
+    syc_name = "SolutionCommands"
+
+    command_names = [
+        "_solve",
+        "abort",
+        "create_restart_point",
+        "get_machines",
+        "get_transformation",
+        "initialize",
+        "interrupt",
+        "open_results_in_en_sight",
+        "partition_participants",
+        "shutdown",
+        "solve",
+        "start_participants",
+        "step",
+        "write_csv_chart_files",
+        "write_ensight",
+    ]
+
+    _solve: _solve = _solve
+    """
+    _solve command of solution_root.
+    """
+    abort: abort = abort
+    """
+    abort command of solution_root.
+    """
+    create_restart_point: create_restart_point = create_restart_point
+    """
+    create_restart_point command of solution_root.
+    """
+    get_machines: get_machines = get_machines
+    """
+    get_machines command of solution_root.
+    """
+    get_transformation: get_transformation = get_transformation
+    """
+    get_transformation command of solution_root.
+    """
+    initialize: initialize = initialize
+    """
+    initialize command of solution_root.
+    """
+    interrupt: interrupt = interrupt
+    """
+    interrupt command of solution_root.
+    """
+    open_results_in_en_sight: open_results_in_en_sight = open_results_in_en_sight
+    """
+    open_results_in_en_sight command of solution_root.
+    """
+    partition_participants: partition_participants = partition_participants
+    """
+    partition_participants command of solution_root.
+    """
+    shutdown: shutdown = shutdown
+    """
+    shutdown command of solution_root.
+    """
+    solve: solve = solve
+    """
+    solve command of solution_root.
+    """
+    start_participants: start_participants = start_participants
+    """
+    start_participants command of solution_root.
+    """
+    step: step = step
+    """
+    step command of solution_root.
+    """
+    write_csv_chart_files: write_csv_chart_files = write_csv_chart_files
+    """
+    write_csv_chart_files command of solution_root.
+    """
+    write_ensight: write_ensight = write_ensight
+    """
+    write_ensight command of solution_root.
+    """

ansys/systemcoupling/core/adaptor/api_24_1/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_24_1/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_24_1/start_participants.py

@@ -0,0 +1,47 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class start_participants(Command):
+    """
+    Important: This command is deprecated. Consider adopting workflows
+    where participants are started by another method, such as the ``initialize``,
+    ``step``, or ``solve`` commands.
+
+    Interactive command that reads the participants' System Coupling
+    Participant setup files (SCP) and starts participants on separate
+    sub-processes. By default, automatically starts all participants and blocks
+    solution progress until all participants are connected.
+
+    If omitted and the ``solve``, ``initialize``, or ``step`` command is issued, then
+    participants are started automatically during the execution of the 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.
+
+    Parameters
+    ----------
+    participant_names : typing.List[str], optional
+        This argument has been deprecated and will be removed in future releases.
+
+    """
+
+    syc_name = "StartParticipants"
+
+    argument_names = ["participant_names"]
+
+    class participant_names(StringList):
+        """
+        This argument has been deprecated and will be removed in future releases.
+        """
+
+        syc_name = "ParticipantNames"

ansys/systemcoupling/core/adaptor/api_24_1/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_24_1/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_24_1/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_24_1/type.py

@@ -0,0 +1,38 @@
+#
+# 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\" (beta only)"""
+        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_24_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)