ansys-systemcoupling-core 0.4.dev0__py3-none-any.whl → 0.5.0__py3-none-any.whl

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

@@ -0,0 +1,32 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_ordered_data_transfers(Command):
+    """
+    Adds data transfer for each ordered pair of variables in an FMU-FMU interface.
+
+    Returns the name of the Data Transfers created.
+
+    Parameters
+    ----------
+    interface : str
+        String indicating the name of the interface on which the data transfer
+        is to be created.
+
+    """
+
+    syc_name = "AddOrderedDataTransfers"
+
+    argument_names = ["interface"]
+
+    class interface(String):
+        """
+        String indicating the name of the interface on which the data transfer
+        is to be created.
+        """
+
+        syc_name = "Interface"

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

@@ -0,0 +1,162 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_participant(InjectedCommand):
+    """
+    This command operates in one of two modes, depending on how it is called.
+    *Either* a single argument, ``participant_session``, should be provided, *or* some
+    combination of the other optional arguments not including ``participant_session``
+    should be provided.
+
+    In the ``participant_session`` mode, the session object is queried to
+    extract the information needed to define a new ``coupling_participant``
+    object in the setup datamodel. A reference to the session is also retained,
+    and this will play a further role if ``solve`` is called later. In that case,
+    the participant solver will be driven from the Python environment in which the
+    participant and PySystemCoupling sessions are active and System Coupling will
+    regard the participant solver as "externally managed" (see the `execution_control`
+    settings in `coupling_participant` for details of this mode).
+
+    .. note::
+        The ``participant_session`` mode currently has limited support in the
+        broader Ansys Python ecosystem - at present, only PyFluent supports
+        the API required of the session object and product versions of Fluent and
+        System Coupling need to be at least 24.1. This capability should be
+        regarded as *Beta* as it may be subject to revision when extended to other
+        products.
+
+    The remainder of the documentation describes the more usual non-session mode.
+
+    Adds a coupling participant to the data model.
+
+    When executed, this command adds the new participant to the analysis
+    without removing any interfaces or data transfers created previously.
+
+    Cannot be called after participants have been started.
+
+    Returns the name of the participant.
+
+    There are several options that can be selected to add the
+    participant - via a file, via a participant executable, or via a
+    Python script. Some of these options may be combined. For example,
+    sometimes it is useful to use an input file while at the same time
+    providing a custom participant executable or Python script.
+
+    Option 1: Using an input file
+
+    Given an input file containing participant coupling information, reads the
+    specified file, pushes the participant's information to the data model.
+
+    Option 2: Using a participant executable
+
+    Given the path to the executable for this participant (and optionally,
+    additional arguments and/or working directory), start the participant
+    executable, connect to the participant using the socket connection,
+    and get the participant's information and add it to the data model.
+
+    Option 3: Using a Python script
+
+    This can be seen as a special case of Option 2 (using an executable),
+    but instead of an executable, a Python script is used. System Coupling
+    will invoke a specialized script to set up the environment so
+    that the Python script can more easily interact with System Coupling.
+
+    Parameters
+    ----------
+    participant_session : ParticipantProtocol, optional
+        Participant session object conforming to the ``ParticipantProtocol`` protocol class.
+    participant_type : str, optional
+        Participant type. To get a list of supported participant types, use
+        the get_supported_participant_types() query. If unspecified,
+        add_participant will attempt to deduce the type from input_file.
+    input_file : str, optional
+        Name of the input file for the participant to be added.
+        Currently supported formats are SCP files, Forte input (FTSIM)
+        files, mechanical server (*.rst) files, cfd server (*.csv) files,
+        FMU (.fmu) files, and System Coupling data server (*.scdt/axdt/csv) files.
+    executable : str, optional
+        Path to the executable file for the participant to be added.
+    additional_arguments : str, optional
+        Any additional arguments to be passed to the participant's executable.
+    working_directory : str, optional
+        Path to the working directory for this participant.
+    python_script : str, optional
+        Instead of the executable, use a Python script and wrap it with
+        System Coupling-provided .bat/.sh scripts to set up the environment
+        correctly before calling this Python script.
+
+    """
+
+    syc_name = "add_participant"
+
+    cmd_name = "add_participant"
+
+    argument_names = [
+        "participant_session",
+        "participant_type",
+        "input_file",
+        "executable",
+        "additional_arguments",
+        "working_directory",
+        "python_script",
+    ]
+
+    class participant_session(ParticipantSession):
+        """
+        Participant session object conforming to the ``ParticipantProtocol`` protocol class.
+        """
+
+        syc_name = "participant_session"
+
+    class participant_type(String):
+        """
+        Participant type. To get a list of supported participant types, use
+        the get_supported_participant_types() query. If unspecified,
+        add_participant will attempt to deduce the type from input_file.
+        """
+
+        syc_name = "ParticipantType"
+
+    class input_file(String):
+        """
+        Name of the input file for the participant to be added.
+        Currently supported formats are SCP files, Forte input (FTSIM)
+        files, mechanical server (*.rst) files, cfd server (*.csv) files,
+        FMU (.fmu) files, and System Coupling data server (*.scdt/axdt/csv) files.
+        """
+
+        syc_name = "InputFile"
+
+    class executable(String):
+        """
+        Path to the executable file for the participant to be added.
+        """
+
+        syc_name = "Executable"
+
+    class additional_arguments(String):
+        """
+        Any additional arguments to be passed to the participant's executable.
+        """
+
+        syc_name = "AdditionalArguments"
+
+    class working_directory(String):
+        """
+        Path to the working directory for this participant.
+        """
+
+        syc_name = "WorkingDirectory"
+
+    class python_script(String):
+        """
+        Instead of the executable, use a Python script and wrap it with
+        System Coupling-provided .bat/.sh scripts to set up the environment
+        correctly before calling this Python script.
+        """
+
+        syc_name = "PythonScript"

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

@@ -0,0 +1,40 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_reference_frame(Command):
+    """
+    Add a reference frame to the datamodel
+
+    The function will add a blank reference frame to the datamodel. Any
+    transformations must be added separately.
+
+    Reference frame name will be "Frame-#" where # is the first positive
+    integer which yields a unique frame name.
+
+    Returns the name of the reference frame.
+
+    Parameters
+    ----------
+    parent_reference_frame : str, optional
+        Name of a reference frame that the added frame should use as the
+        parent. If the argument is not provided, the default parent reference
+        frame "GlobalReferenceFrame" will be added.
+
+    """
+
+    syc_name = "AddReferenceFrame"
+
+    argument_names = ["parent_reference_frame"]
+
+    class parent_reference_frame(String):
+        """
+        Name of a reference frame that the added frame should use as the
+        parent. If the argument is not provided, the default parent reference
+        frame "GlobalReferenceFrame" will be added.
+        """
+
+        syc_name = "ParentReferenceFrame"

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

@@ -0,0 +1,43 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_thermal_data_transfers(Command):
+    """
+    Adds group of data transfers for thermal physics.
+
+    Returns the list of the data transfers created.
+
+    Parameters
+    ----------
+    interface : str
+        String indicating the name of the interface on which the data transfer
+        is to be created.
+    option : str, optional
+        Thermal data transfer option: 'Heat Rate' (default) or
+        'Heat Transfer Coefficient' (possible for surface-surface transfers).
+
+    """
+
+    syc_name = "AddThermalDataTransfers"
+
+    argument_names = ["interface", "option"]
+
+    class interface(String):
+        """
+        String indicating the name of the interface on which the data transfer
+        is to be created.
+        """
+
+        syc_name = "Interface"
+
+    class option(String):
+        """
+        Thermal data transfer option: 'Heat Rate' (default) or
+        'Heat Transfer Coefficient' (possible for surface-surface transfers).
+        """
+
+        syc_name = "Option"

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

@@ -0,0 +1,102 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_transformation(Command):
+    """
+    Add a transformation to a reference frame defined in the datamodel
+
+    Given the reference frame to add to the transform to, the type of transform
+    to be added, and any required information for the transformation, add the
+    transformation to the referenceFrame. Not all parameters are required for
+    every transformation.
+
+    The name of the transformation will be based on the type of transformation.
+    The name will be of the form ``<transformation_type>-#`` where ``#`` is the first
+    positive integer which yields a unique frame name.
+
+    The transformation will also be added to the end of the ``transformation_order``
+    list for the reference frame.
+
+    Returns the name of the transformation.
+
+    Parameters
+    ----------
+    reference_frame : str
+        Name of the reference frame to which the transformation will be added.
+    transformation_type : str
+        Type of transformation to be added. Available options are \"Rotation\" or
+        \"Translation\".
+
+        Required Parameters for Transformation Types:
+            Rotation: ``angle``, ``axis``, ``vector`` (if ``axis`` is \"UserDefined\")
+            Translation: ``vector``
+    angle : real, optional
+        Angle to rotate a reference frame. Used with \"Rotation\"
+        ``transformation_type``. Default unit is Radians.
+    axis : str, optional
+        Axis about which a rotation is applied. Used with
+        Rotation ``transformation_type``. Available options are: \"XAxis\", \"YAxis\",
+        \"ZAxis\", and \"UserDefined\".
+    vector : typing.Tuple[real, real, real], optional
+        A vector for use with \"Translation\" ``transformation_type`` or \"Rotation\"
+        ``transformation_type`` if the ``axis`` is \"UserDefined\".
+
+    """
+
+    syc_name = "AddTransformation"
+
+    argument_names = [
+        "reference_frame",
+        "transformation_type",
+        "angle",
+        "axis",
+        "vector",
+    ]
+
+    class reference_frame(String):
+        """
+        Name of the reference frame to which the transformation will be added.
+        """
+
+        syc_name = "ReferenceFrame"
+
+    class transformation_type(String):
+        """
+        Type of transformation to be added. Available options are \"Rotation\" or
+        \"Translation\".
+
+        Required Parameters for Transformation Types:
+            Rotation: ``angle``, ``axis``, ``vector`` (if ``axis`` is \"UserDefined\")
+            Translation: ``vector``
+        """
+
+        syc_name = "TransformationType"
+
+    class angle(Real):
+        """
+        Angle to rotate a reference frame. Used with \"Rotation\"
+        ``transformation_type``. Default unit is Radians.
+        """
+
+        syc_name = "Angle"
+
+    class axis(String):
+        """
+        Axis about which a rotation is applied. Used with
+        Rotation ``transformation_type``. Available options are: \"XAxis\", \"YAxis\",
+        \"ZAxis\", and \"UserDefined\".
+        """
+
+        syc_name = "Axis"
+
+    class vector(RealVector):
+        """
+        A vector for use with \"Translation\" ``transformation_type`` or \"Rotation\"
+        ``transformation_type`` if the ``axis`` is \"UserDefined\".
+        """
+
+        syc_name = "Vector"

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

@@ -0,0 +1,283 @@
+#
+# 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"),
+    ]
+
+    @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)