ansys-systemcoupling-core 0.9.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

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

@@ -0,0 +1,333 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .apip import apip
+from .automatic_alignment_options import automatic_alignment_options
+from .avoid_data_reconstruction import avoid_data_reconstruction
+from .global_stabilization import global_stabilization
+from .unmapped_value_options import unmapped_value_options
+
+
+class analysis_control(Container):
+    """
+    Configure coupling controls.
+    """
+
+    syc_name = "AnalysisControl"
+
+    child_names = [
+        "global_stabilization",
+        "apip",
+        "avoid_data_reconstruction",
+        "unmapped_value_options",
+        "automatic_alignment_options",
+    ]
+
+    global_stabilization: global_stabilization = global_stabilization
+    """
+    global_stabilization child of analysis_control.
+    """
+    apip: apip = apip
+    """
+    apip child of analysis_control.
+    """
+    avoid_data_reconstruction: avoid_data_reconstruction = avoid_data_reconstruction
+    """
+    avoid_data_reconstruction child of analysis_control.
+    """
+    unmapped_value_options: unmapped_value_options = unmapped_value_options
+    """
+    unmapped_value_options child of analysis_control.
+    """
+    automatic_alignment_options: automatic_alignment_options = (
+        automatic_alignment_options
+    )
+    """
+    automatic_alignment_options child of analysis_control.
+    """
+    property_names_types = [
+        ("analysis_type", "AnalysisType", "str"),
+        ("optimize_if_one_way", "OptimizeIfOneWay", "bool"),
+        ("warped_face_tolerance", "WarpedFaceTolerance", "RealType"),
+        ("allow_simultaneous_update", "AllowSimultaneousUpdate", "bool"),
+        ("simultaneous_participants", "SimultaneousParticipants", "str"),
+        (
+            "allow_simultaneous_initialization",
+            "AllowSimultaneousInitialization",
+            "bool",
+        ),
+        ("mpi_pause_timeout", "MpiPauseTimeout", "RealType"),
+        ("partitioning_algorithm", "PartitioningAlgorithm", "str"),
+        ("cleanup_inflated_fm_us", "CleanupInflatedFMUs", "bool"),
+        ("allow_iterations_only_mode", "AllowIterationsOnlyMode", "bool"),
+        ("target_initialization_option", "TargetInitializationOption", "str"),
+        ("fluent_region_update_at_step", "FluentRegionUpdateAtStep", "bool"),
+        ("mesh_import_on_initialization", "MeshImportOnInitialization", "bool"),
+        ("import_all_regions", "ImportAllRegions", "bool"),
+        ("bypass_fluent_adapter", "BypassFluentAdapter", "bool"),
+        ("variable_to_expression_transfer", "VariableToExpressionTransfer", "bool"),
+        ("update_mapping_weights", "UpdateMappingWeights", "str"),
+        (
+            "solve_incremental_displacement_first",
+            "SolveIncrementalDisplacementFirst",
+            "bool",
+        ),
+        ("write_scs_file", "WriteScsFile", "bool"),
+        ("check_for_input_files_changes", "CheckForInputFilesChanges", "str"),
+        ("is_user_friendly_mapping", "IsUserFriendlyMapping", "bool"),
+        ("reduce_informational_output", "ReduceInformationalOutput", "bool"),
+        ("participant_precision", "ParticipantPrecision", "str"),
+        ("avoid_rbf", "AvoidRBF", "str"),
+        ("interactive_initialization", "InteractiveInitialization", "bool"),
+    ]
+
+    @property
+    def analysis_type(self) -> str:
+        """Analysis type.
+
+        Allowed values:
+        - \"Steady\"
+        - \"Transient\" """
+        return self.get_property_state("analysis_type")
+
+    @analysis_type.setter
+    def analysis_type(self, value: str):
+        self.set_property_state("analysis_type", value)
+
+    @property
+    def optimize_if_one_way(self) -> bool:
+        """Optimizes various controls for a one-way workflow, if the
+        data transfers form a unidirectional graph."""
+        return self.get_property_state("optimize_if_one_way")
+
+    @optimize_if_one_way.setter
+    def optimize_if_one_way(self, value: bool):
+        self.set_property_state("optimize_if_one_way", value)
+
+    @property
+    def warped_face_tolerance(self) -> RealType:
+        """Set warped face detection tolerance (1e-6 is default value, 1.0 means disabled)."""
+        return self.get_property_state("warped_face_tolerance")
+
+    @warped_face_tolerance.setter
+    def warped_face_tolerance(self, value: RealType):
+        self.set_property_state("warped_face_tolerance", value)
+
+    @property
+    def allow_simultaneous_update(self) -> bool:
+        """Allow simultaneous update of independent participants."""
+        return self.get_property_state("allow_simultaneous_update")
+
+    @allow_simultaneous_update.setter
+    def allow_simultaneous_update(self, value: bool):
+        self.set_property_state("allow_simultaneous_update", value)
+
+    @property
+    def simultaneous_participants(self) -> str:
+        """Controls which participants are updated simultaneously."""
+        return self.get_property_state("simultaneous_participants")
+
+    @simultaneous_participants.setter
+    def simultaneous_participants(self, value: str):
+        self.set_property_state("simultaneous_participants", value)
+
+    @property
+    def allow_simultaneous_initialization(self) -> bool:
+        """Allow simultaneous initialization of participants."""
+        return self.get_property_state("allow_simultaneous_initialization")
+
+    @allow_simultaneous_initialization.setter
+    def allow_simultaneous_initialization(self, value: bool):
+        self.set_property_state("allow_simultaneous_initialization", value)
+
+    @property
+    def mpi_pause_timeout(self) -> RealType:
+        """Specify MPI pause time (in seconds) to wait for other participants to finish solving"""
+        return self.get_property_state("mpi_pause_timeout")
+
+    @mpi_pause_timeout.setter
+    def mpi_pause_timeout(self, value: RealType):
+        self.set_property_state("mpi_pause_timeout", value)
+
+    @property
+    def partitioning_algorithm(self) -> str:
+        """Partitioning algorithm used when participants are running in parallel.
+
+        Allowed values:
+
+        - \"SharedAllocateMachines\" - Participants share both machines and cores.
+
+        - \"SharedAllocateCores\" - Participants share machines but not cores.
+
+        - \"DistributedAllocateCores\" - Participants minimally share cores and machines. (Linux only)
+
+        - \"DistributedAllocateMachines\" - Participants never share cores or machines. (Linux only)
+
+        - \"Custom\" - Custom algorithm."""
+        return self.get_property_state("partitioning_algorithm")
+
+    @partitioning_algorithm.setter
+    def partitioning_algorithm(self, value: str):
+        self.set_property_state("partitioning_algorithm", value)
+
+    @property
+    def cleanup_inflated_fm_us(self) -> bool:
+        """Controls whether System Coupling will cleanup inflated FMUs at end of analysis."""
+        return self.get_property_state("cleanup_inflated_fm_us")
+
+    @cleanup_inflated_fm_us.setter
+    def cleanup_inflated_fm_us(self, value: bool):
+        self.set_property_state("cleanup_inflated_fm_us", value)
+
+    @property
+    def allow_iterations_only_mode(self) -> bool:
+        """Explicitly set whether iterations-only mode is allowed."""
+        return self.get_property_state("allow_iterations_only_mode")
+
+    @allow_iterations_only_mode.setter
+    def allow_iterations_only_mode(self, value: bool):
+        self.set_property_state("allow_iterations_only_mode", value)
+
+    @property
+    def target_initialization_option(self) -> str:
+        """Select option for target initialization."""
+        return self.get_property_state("target_initialization_option")
+
+    @target_initialization_option.setter
+    def target_initialization_option(self, value: str):
+        self.set_property_state("target_initialization_option", value)
+
+    @property
+    def fluent_region_update_at_step(self) -> bool:
+        """Allow update of Fluent regions at the beginning of a step."""
+        return self.get_property_state("fluent_region_update_at_step")
+
+    @fluent_region_update_at_step.setter
+    def fluent_region_update_at_step(self, value: bool):
+        self.set_property_state("fluent_region_update_at_step", value)
+
+    @property
+    def mesh_import_on_initialization(self) -> bool:
+        """Select whether to import the mesh during the analysis initialization."""
+        return self.get_property_state("mesh_import_on_initialization")
+
+    @mesh_import_on_initialization.setter
+    def mesh_import_on_initialization(self, value: bool):
+        self.set_property_state("mesh_import_on_initialization", value)
+
+    @property
+    def import_all_regions(self) -> bool:
+        """Select whether to import mesh for all defined regions."""
+        return self.get_property_state("import_all_regions")
+
+    @import_all_regions.setter
+    def import_all_regions(self, value: bool):
+        self.set_property_state("import_all_regions", value)
+
+    @property
+    def bypass_fluent_adapter(self) -> bool:
+        """Switch to bypass Fluent adapter."""
+        return self.get_property_state("bypass_fluent_adapter")
+
+    @bypass_fluent_adapter.setter
+    def bypass_fluent_adapter(self, value: bool):
+        self.set_property_state("bypass_fluent_adapter", value)
+
+    @property
+    def variable_to_expression_transfer(self) -> bool:
+        """Convert variable-based data transfers to expression transfers."""
+        return self.get_property_state("variable_to_expression_transfer")
+
+    @variable_to_expression_transfer.setter
+    def variable_to_expression_transfer(self, value: bool):
+        self.set_property_state("variable_to_expression_transfer", value)
+
+    @property
+    def update_mapping_weights(self) -> str:
+        """Weight factor when multiple transfers are stabilized.
+
+        Allowed values:
+
+        - \"Off\" (default)
+        - \"EveryStep\"
+        - \"EveryIteration\" """
+        return self.get_property_state("update_mapping_weights")
+
+    @update_mapping_weights.setter
+    def update_mapping_weights(self, value: str):
+        self.set_property_state("update_mapping_weights", value)
+
+    @property
+    def solve_incremental_displacement_first(self) -> bool:
+        """Force participants serving incremental displacement to solve first."""
+        return self.get_property_state("solve_incremental_displacement_first")
+
+    @solve_incremental_displacement_first.setter
+    def solve_incremental_displacement_first(self, value: bool):
+        self.set_property_state("solve_incremental_displacement_first", value)
+
+    @property
+    def write_scs_file(self) -> bool:
+        """Force writing of scs file even if participants are auto-started."""
+        return self.get_property_state("write_scs_file")
+
+    @write_scs_file.setter
+    def write_scs_file(self, value: bool):
+        self.set_property_state("write_scs_file", value)
+
+    @property
+    def check_for_input_files_changes(self) -> str:
+        """Controls whether System Coupling will check for changes in participant input files."""
+        return self.get_property_state("check_for_input_files_changes")
+
+    @check_for_input_files_changes.setter
+    def check_for_input_files_changes(self, value: str):
+        self.set_property_state("check_for_input_files_changes", value)
+
+    @property
+    def is_user_friendly_mapping(self) -> bool:
+        """Controls whether is System Coupling user friendly mapping workflow."""
+        return self.get_property_state("is_user_friendly_mapping")
+
+    @is_user_friendly_mapping.setter
+    def is_user_friendly_mapping(self, value: bool):
+        self.set_property_state("is_user_friendly_mapping", value)
+
+    @property
+    def reduce_informational_output(self) -> bool:
+        """Reduce the information written to the transcript and stdout"""
+        return self.get_property_state("reduce_informational_output")
+
+    @reduce_informational_output.setter
+    def reduce_informational_output(self, value: bool):
+        self.set_property_state("reduce_informational_output", value)
+
+    @property
+    def participant_precision(self) -> str:
+        """Set global option for participant precision"""
+        return self.get_property_state("participant_precision")
+
+    @participant_precision.setter
+    def participant_precision(self, value: str):
+        self.set_property_state("participant_precision", value)
+
+    @property
+    def avoid_rbf(self) -> str:
+        """UNDOCUMENTED"""
+        return self.get_property_state("avoid_rbf")
+
+    @avoid_rbf.setter
+    def avoid_rbf(self, value: str):
+        self.set_property_state("avoid_rbf", value)
+
+    @property
+    def interactive_initialization(self) -> bool:
+        """Controls whether using interactive initialization for cosim"""
+        return self.get_property_state("interactive_initialization")
+
+    @interactive_initialization.setter
+    def interactive_initialization(self, value: bool):
+        self.set_property_state("interactive_initialization", value)

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

@@ -0,0 +1,33 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class apip(Container):
+    """
+    Apip-related expert settings.
+    """
+
+    syc_name = "Apip"
+
+    property_names_types = [("debug", "Debug", "bool"), ("disable", "Disable", "bool")]
+
+    @property
+    def debug(self) -> bool:
+        """Debug apip data (sends to debug server, saves data locally)."""
+        return self.get_property_state("debug")
+
+    @debug.setter
+    def debug(self, value: bool):
+        self.set_property_state("debug", value)
+
+    @property
+    def disable(self) -> bool:
+        """Disable apip collection (regardless of user settings)."""
+        return self.get_property_state("disable")
+
+    @disable.setter
+    def disable(self, value: bool):
+        self.set_property_state("disable", value)

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

@@ -0,0 +1,44 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class ascii_output(Container):
+    """
+    Output interface data as ASCII.
+    """
+
+    syc_name = "AsciiOutput"
+
+    property_names_types = [("option", "Option", "str"), ("format", "Format", "str")]
+
+    @property
+    def option(self) -> str:
+        """Control ASCII interface data output.
+
+        Allowed values:
+
+        - \"Off\"
+        - \"EveryStep\" (for step-based analyses)
+        - \"EveryIteration\" (for iteration-based analyses)"""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def format(self) -> str:
+        """ASCII output format type.
+
+        Allowed values:
+
+        - \"Axdt\"
+        - \"Csv\" """
+        return self.get_property_state("format")
+
+    @format.setter
+    def format(self, value: str):
+        self.set_property_state("format", value)

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

@@ -0,0 +1,20 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .attribute_child import attribute_child
+
+
+class attribute(NamedContainer[attribute_child]):
+    """
+    Configure an attribute.
+    """
+
+    syc_name = "Attribute"
+
+    child_object_type: attribute_child = attribute_child
+    """
+    child_object_type of attribute.
+    """

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

@@ -0,0 +1,74 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .dimensionality import dimensionality
+
+
+class attribute_child(Container):
+    """
+    Configure an attribute.
+    """
+
+    syc_name = "child_object_type"
+
+    child_names = ["dimensionality"]
+
+    dimensionality: dimensionality = dimensionality
+    """
+    dimensionality child of attribute_child.
+    """
+    property_names_types = [
+        ("attribute_type", "AttributeType", "str"),
+        ("modifiable", "Modifiable", "bool"),
+        ("real_value", "RealValue", "RealType"),
+        ("integer_value", "IntegerValue", "int"),
+        ("string_value", "StringValue", "str"),
+    ]
+
+    @property
+    def attribute_type(self) -> str:
+        """The type of the attribute (\"Real\", \"Integer\", or \"String\")."""
+        return self.get_property_state("attribute_type")
+
+    @attribute_type.setter
+    def attribute_type(self, value: str):
+        self.set_property_state("attribute_type", value)
+
+    @property
+    def modifiable(self) -> bool:
+        """Controls whether the attribute is Modifiable"""
+        return self.get_property_state("modifiable")
+
+    @modifiable.setter
+    def modifiable(self, value: bool):
+        self.set_property_state("modifiable", value)
+
+    @property
+    def real_value(self) -> RealType:
+        """Real attribute value."""
+        return self.get_property_state("real_value")
+
+    @real_value.setter
+    def real_value(self, value: RealType):
+        self.set_property_state("real_value", value)
+
+    @property
+    def integer_value(self) -> int:
+        """Integer attribute value."""
+        return self.get_property_state("integer_value")
+
+    @integer_value.setter
+    def integer_value(self, value: int):
+        self.set_property_state("integer_value", value)
+
+    @property
+    def string_value(self) -> str:
+        """String attribute value."""
+        return self.get_property_state("string_value")
+
+    @string_value.setter
+    def string_value(self, value: str):
+        self.set_property_state("string_value", value)

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

@@ -0,0 +1,46 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class automatic_alignment_options(Container):
+    """
+    Automatic alignment settings.
+    """
+
+    syc_name = "AutomaticAlignmentOptions"
+
+    property_names_types = [
+        ("alignment_type", "AlignmentType", "str"),
+        ("singular_value_tolerance", "SingularValueTolerance", "RealType"),
+        ("verbosity", "Verbosity", "int"),
+    ]
+
+    @property
+    def alignment_type(self) -> str:
+        """Alignment type (\"Covariance\" or \"Moment Covariance\" or \"Inertial Axes\")."""
+        return self.get_property_state("alignment_type")
+
+    @alignment_type.setter
+    def alignment_type(self, value: str):
+        self.set_property_state("alignment_type", value)
+
+    @property
+    def singular_value_tolerance(self) -> RealType:
+        """Tolerance used to compare singular values"""
+        return self.get_property_state("singular_value_tolerance")
+
+    @singular_value_tolerance.setter
+    def singular_value_tolerance(self, value: RealType):
+        self.set_property_state("singular_value_tolerance", value)
+
+    @property
+    def verbosity(self) -> int:
+        """Set to 1 to print additional information about the alignment"""
+        return self.get_property_state("verbosity")
+
+    @verbosity.setter
+    def verbosity(self, value: int):
+        self.set_property_state("verbosity", value)

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

@@ -0,0 +1,40 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class available_ports(Container):
+    """
+    Specify ports available for co-simulation.
+    """
+
+    syc_name = "AvailablePorts"
+
+    property_names_types = [("option", "Option", "str"), ("range", "Range", "str")]
+
+    @property
+    def option(self) -> str:
+        """Specify how available ports are determined.
+
+        - \"ProgramControlled\" - System Coupling will find an
+          available port.
+        - \"UserDefined\" - An available port will be chosen,
+          if possible, from a specified range."""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def range(self) -> str:
+        """Port range expressed as a comma-separated list of integers and/or
+        integer ranges. An integer range is a pair of integers separated
+        with a "-" character, specify an inclusive range of port numbers."""
+        return self.get_property_state("range")
+
+    @range.setter
+    def range(self, value: str):
+        self.set_property_state("range", value)

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

@@ -0,0 +1,56 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class avoid_data_reconstruction(Container):
+    """
+    Control whether data reconstruction should be done for elemental intensive data.
+    """
+
+    syc_name = "AvoidDataReconstruction"
+
+    property_names_types = [
+        ("volume_mapping", "VolumeMapping", "bool"),
+        ("surface_mapping", "SurfaceMapping", "bool"),
+        ("surface_volume_mapping", "SurfaceVolumeMapping", "bool"),
+        ("nep", "NEP", "str"),
+    ]
+
+    @property
+    def volume_mapping(self) -> bool:
+        """UNDOCUMENTED"""
+        return self.get_property_state("volume_mapping")
+
+    @volume_mapping.setter
+    def volume_mapping(self, value: bool):
+        self.set_property_state("volume_mapping", value)
+
+    @property
+    def surface_mapping(self) -> bool:
+        """UNDOCUMENTED"""
+        return self.get_property_state("surface_mapping")
+
+    @surface_mapping.setter
+    def surface_mapping(self, value: bool):
+        self.set_property_state("surface_mapping", value)
+
+    @property
+    def surface_volume_mapping(self) -> bool:
+        """UNDOCUMENTED"""
+        return self.get_property_state("surface_volume_mapping")
+
+    @surface_volume_mapping.setter
+    def surface_volume_mapping(self, value: bool):
+        self.set_property_state("surface_volume_mapping", value)
+
+    @property
+    def nep(self) -> str:
+        """UNDOCUMENTED"""
+        return self.get_property_state("nep")
+
+    @nep.setter
+    def nep(self, value: str):
+        self.set_property_state("nep", value)