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

ansys/systemcoupling/core/adaptor/api_24_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_24_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_24_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_24_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)

ansys/systemcoupling/core/adaptor/api_24_2/execution_control.py

@@ -0,0 +1,246 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .fluent_input import fluent_input
+
+
+class execution_control(Container):
+    """
+    Configure execution control for a coupling participant.
+    """
+
+    syc_name = "ExecutionControl"
+
+    child_names = ["fluent_input"]
+
+    fluent_input: fluent_input = fluent_input
+    """
+    fluent_input child of execution_control.
+    """
+    property_names_types = [
+        ("option", "Option", "str"),
+        ("working_directory", "WorkingDirectory", "str"),
+        ("use_wrapper_script", "UseWrapperScript", "bool"),
+        ("python_script", "PythonScript", "str"),
+        ("executable", "Executable", "str"),
+        ("auto_distribution_settings", "AutoDistributionSettings", "bool"),
+        ("use_ls_dyna_custom_executable", "UseLsDynaCustomExecutable", "bool"),
+        ("ls_dyna_custom_executable", "LsDynaCustomExecutable", "str"),
+        ("ls_dyna_parallel_option", "LsDynaParallelOption", "str"),
+        (
+            "include_hpc_distribution_types",
+            "IncludeHPCDistributionTypes",
+            "StringListType",
+        ),
+        ("number_of_cores_per_task", "NumberOfCoresPerTask", "int"),
+        ("batch_options", "BatchOptions", "str"),
+        ("additional_arguments", "AdditionalArguments", "str"),
+        ("parallel_fraction", "ParallelFraction", "RealType"),
+        ("initial_input", "InitialInput", "str"),
+        ("additional_restart_input_file", "AdditionalRestartInputFile", "str"),
+        ("gui_mode", "GuiMode", "bool"),
+        ("base_output_file_name", "BaseOutputFileName", "str"),
+        ("overwrite_existing_files", "OverwriteExistingFiles", "bool"),
+        ("mass_normalized", "MassNormalized", "bool"),
+        ("write_output", "WriteOutput", "bool"),
+    ]
+
+    @property
+    def option(self) -> str:
+        """Method used to find the solver executable file to be used to start
+        the participant.
+
+        - \"ProgramControlled\" - (Default) Find the executable based on the
+          participant type. Available whenever the participant type is not
+          set to \"DEFAULT\" or \"EXTERNALDATA\".
+        - \"UserDefined\" - User supplied settings are used to find the executable.
+        - \"ExternallyManaged\" - Typically used for workflows managed by
+          `WorkBench`."""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def working_directory(self) -> str:
+        """Participant working directory."""
+        return self.get_property_state("working_directory")
+
+    @working_directory.setter
+    def working_directory(self, value: str):
+        self.set_property_state("working_directory", value)
+
+    @property
+    def use_wrapper_script(self) -> bool:
+        """Specify whether to use System Coupling-provided wrapper script to set up the environment."""
+        return self.get_property_state("use_wrapper_script")
+
+    @use_wrapper_script.setter
+    def use_wrapper_script(self, value: bool):
+        self.set_property_state("use_wrapper_script", value)
+
+    @property
+    def python_script(self) -> str:
+        """Path to the Python script."""
+        return self.get_property_state("python_script")
+
+    @python_script.setter
+    def python_script(self, value: str):
+        self.set_property_state("python_script", value)
+
+    @property
+    def executable(self) -> str:
+        """Path to participant executable."""
+        return self.get_property_state("executable")
+
+    @executable.setter
+    def executable(self, value: str):
+        self.set_property_state("executable", value)
+
+    @property
+    def auto_distribution_settings(self) -> bool:
+        """Specify whether to use automatic distribution settings."""
+        return self.get_property_state("auto_distribution_settings")
+
+    @auto_distribution_settings.setter
+    def auto_distribution_settings(self, value: bool):
+        self.set_property_state("auto_distribution_settings", value)
+
+    @property
+    def use_ls_dyna_custom_executable(self) -> bool:
+        """Specify whether to use custom executable for LS-DYNA."""
+        return self.get_property_state("use_ls_dyna_custom_executable")
+
+    @use_ls_dyna_custom_executable.setter
+    def use_ls_dyna_custom_executable(self, value: bool):
+        self.set_property_state("use_ls_dyna_custom_executable", value)
+
+    @property
+    def ls_dyna_custom_executable(self) -> str:
+        """Path to LS-DYNA executable."""
+        return self.get_property_state("ls_dyna_custom_executable")
+
+    @ls_dyna_custom_executable.setter
+    def ls_dyna_custom_executable(self, value: str):
+        self.set_property_state("ls_dyna_custom_executable", value)
+
+    @property
+    def ls_dyna_parallel_option(self) -> str:
+        """LS-DYNA Parallel Option."""
+        return self.get_property_state("ls_dyna_parallel_option")
+
+    @ls_dyna_parallel_option.setter
+    def ls_dyna_parallel_option(self, value: str):
+        self.set_property_state("ls_dyna_parallel_option", value)
+
+    @property
+    def include_hpc_distribution_types(self) -> StringListType:
+        """Include HPC distribution types for the distributed AEDT runs."""
+        return self.get_property_state("include_hpc_distribution_types")
+
+    @include_hpc_distribution_types.setter
+    def include_hpc_distribution_types(self, value: StringListType):
+        self.set_property_state("include_hpc_distribution_types", value)
+
+    @property
+    def number_of_cores_per_task(self) -> int:
+        """Specify number of parallel cores per task for parallel AEDT analysis."""
+        return self.get_property_state("number_of_cores_per_task")
+
+    @number_of_cores_per_task.setter
+    def number_of_cores_per_task(self, value: int):
+        self.set_property_state("number_of_cores_per_task", value)
+
+    @property
+    def batch_options(self) -> str:
+        """Specify batch options for AEDT participant."""
+        return self.get_property_state("batch_options")
+
+    @batch_options.setter
+    def batch_options(self, value: str):
+        self.set_property_state("batch_options", value)
+
+    @property
+    def additional_arguments(self) -> str:
+        """Additional command line arguments."""
+        return self.get_property_state("additional_arguments")
+
+    @additional_arguments.setter
+    def additional_arguments(self, value: str):
+        self.set_property_state("additional_arguments", value)
+
+    @property
+    def parallel_fraction(self) -> RealType:
+        """Fraction of available cores to use for this participant"""
+        return self.get_property_state("parallel_fraction")
+
+    @parallel_fraction.setter
+    def parallel_fraction(self, value: RealType):
+        self.set_property_state("parallel_fraction", value)
+
+    @property
+    def initial_input(self) -> str:
+        """Initial input."""
+        return self.get_property_state("initial_input")
+
+    @initial_input.setter
+    def initial_input(self, value: str):
+        self.set_property_state("initial_input", value)
+
+    @property
+    def additional_restart_input_file(self) -> str:
+        """File containing MAPDL command snippets to modify the restarted run."""
+        return self.get_property_state("additional_restart_input_file")
+
+    @additional_restart_input_file.setter
+    def additional_restart_input_file(self, value: str):
+        self.set_property_state("additional_restart_input_file", value)
+
+    @property
+    def gui_mode(self) -> bool:
+        """Run participant in graphical mode."""
+        return self.get_property_state("gui_mode")
+
+    @gui_mode.setter
+    def gui_mode(self, value: bool):
+        self.set_property_state("gui_mode", value)
+
+    @property
+    def base_output_file_name(self) -> str:
+        """Base output file name for the CFD Server or SCDT Server."""
+        return self.get_property_state("base_output_file_name")
+
+    @base_output_file_name.setter
+    def base_output_file_name(self, value: str):
+        self.set_property_state("base_output_file_name", value)
+
+    @property
+    def overwrite_existing_files(self) -> bool:
+        """Flag indicating whether CFD Server should overwrite existing files."""
+        return self.get_property_state("overwrite_existing_files")
+
+    @overwrite_existing_files.setter
+    def overwrite_existing_files(self, value: bool):
+        self.set_property_state("overwrite_existing_files", value)
+
+    @property
+    def mass_normalized(self) -> bool:
+        """Controls whether mode shapes are mass normalized"""
+        return self.get_property_state("mass_normalized")
+
+    @mass_normalized.setter
+    def mass_normalized(self, value: bool):
+        self.set_property_state("mass_normalized", value)
+
+    @property
+    def write_output(self) -> bool:
+        """Controls whether export scdt files for the SCDT Server"""
+        return self.get_property_state("write_output")
+
+    @write_output.setter
+    def write_output(self, value: bool):
+        self.set_property_state("write_output", value)

ansys/systemcoupling/core/adaptor/api_24_2/execution_control_1.py

@@ -0,0 +1,24 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class execution_control(Container):
+    """
+    Configure execution control for a live visualization.
+    """
+
+    syc_name = "ExecutionControl"
+
+    property_names_types = [("option", "Option", "str")]
+
+    @property
+    def option(self) -> str:
+        """Set behavior of this object."""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)

ansys/systemcoupling/core/adaptor/api_24_2/expression.py

@@ -0,0 +1,20 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .expression_child import expression_child
+
+
+class expression(NamedContainer[expression_child]):
+    """
+    Define a named expression that can be referenced in other expressions.
+    """
+
+    syc_name = "Expression"
+
+    child_object_type: expression_child = expression_child
+    """
+    child_object_type of expression.
+    """

ansys/systemcoupling/core/adaptor/api_24_2/expression_child.py

@@ -0,0 +1,36 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class expression_child(Container):
+    """
+    Define a named expression that can be referenced in other expressions.
+    """
+
+    syc_name = "child_object_type"
+
+    property_names_types = [
+        ("expression_name", "ExpressionName", "str"),
+        ("expression_string", "ExpressionString", "str"),
+    ]
+
+    @property
+    def expression_name(self) -> str:
+        """Name used to reference this expression from another expression"""
+        return self.get_property_state("expression_name")
+
+    @expression_name.setter
+    def expression_name(self, value: str):
+        self.set_property_state("expression_name", value)
+
+    @property
+    def expression_string(self) -> str:
+        """String defining the expression."""
+        return self.get_property_state("expression_string")
+
+    @expression_string.setter
+    def expression_string(self, value: str):
+        self.set_property_state("expression_string", value)