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

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

@@ -0,0 +1,191 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_data_transfer_by_display_names(Command):
+    """
+    Important: This command is deprecated. To add an interface, use the
+    ``add_data_transfer`` command instead.
+
+    Adds data transfer based on arguments that specify the interface, target
+    side, and variables to be associated with each side of the interface.
+    The command requires that you specify variables using their display names
+    (see parameter descriptions for details). Either a variable-based
+    or expression-based data transfer may be created with this command based on
+    the arguments provided. If a variable-based data transfer argument
+    is given, then no expression-based data transfer arguments can be used. If
+    an expression-based data transfer argument is given, then no variable-based
+    data transfer arguments can be used.
+
+    Cannot be run after participants have been started.
+
+    Returns the name of the Data Transfer created.
+
+    Parameters
+    ----------
+    interface : str
+        String indicating the display name of the interface on which the
+        data transfer is to be created.
+    target_side : str
+        String indicating the side of the interface to receive the data
+        transfer variable. Possible values are \"One\" or \"Two\".
+    source_variable : str, optional
+        String specifying the display name of the variable on the source side of
+        the data transfer. Used when creating a variable-based data transfer.
+        Must be combined with ``target_variable``.
+    target_variable : str, optional
+        String specifying the display name of the variable on the target side of
+        the data transfer. Must be combined with either ``source_variable`` (when
+        creating a variable-based data transfer) or with ``value_{x|y|z}``
+        (when creating an expression-based data transfer).
+    value : str, optional
+        String specifying the expression to use on the source side of the data
+        transfer. Used when creating an expression-based data transfer if the
+        ``target_variable`` is a scalar. (If the ``target_variable`` is a vector,
+        ``value_x``, ``value_y``, ``value_z`` must be used instead.)
+    value_x : str, optional
+        String specifying the X component of the expression to use on the
+        source side of the data transfer. Used when crating an expression-based
+        data transfer if the ``target_variable`` is a vector. (If the ``target_variable``
+        is scalar, ``value`` must be used instead.) ``value_y`` and ``value_z`` are also
+        required if ``value_x`` is used.
+    value_y : str, optional
+        String specifying the Y component of the expression to use on the
+        source side of the data transfer. Used when crating an expression-based
+        data transfer if the ``target_variable`` is a vector. (If the ``target_variable``
+        is scalar, ``value`` must be used instead.) ``value_x`` and ``value_z`` are also
+        required if ``value_y`` is used.
+    value_z : str, optional
+        String specifying the Z component of the expression to use on the
+        source side of the data transfer. Used when crating an expression-based
+        data transfer if the ``target_variable`` is a vector. (If the ``target_variable``
+        is scalar, ``value`` must be used instead.) ``value_x`` and ``value_y`` are also
+        required if ``value_z`` is used.
+    side_one_variable : str, optional
+        String specifying the display name of the variable associated with side one
+        of the interface. Must be combined with ``side_two_variable``. Used only
+        when creating variable-based data transfers. Consider using
+        ``source_variable``/``target_variable`` parameters instead.
+    side_two_variable : str, optional
+        String specifying the display name of the variable associated with side two
+        of the interface. Must be combined with ``side_two_variable``. Used only
+        when creating variable-based data transfers. Consider using
+        ``source_variable``/``target_variable`` parameters instead.
+
+    """
+
+    syc_name = "AddDataTransferByDisplayNames"
+
+    argument_names = [
+        "interface",
+        "target_side",
+        "source_variable",
+        "target_variable",
+        "value",
+        "value_x",
+        "value_y",
+        "value_z",
+        "side_one_variable",
+        "side_two_variable",
+    ]
+
+    class interface(String):
+        """
+        String indicating the display name of the interface on which the
+        data transfer is to be created.
+        """
+
+        syc_name = "Interface"
+
+    class target_side(String):
+        """
+        String indicating the side of the interface to receive the data
+        transfer variable. Possible values are \"One\" or \"Two\".
+        """
+
+        syc_name = "TargetSide"
+
+    class source_variable(String):
+        """
+        String specifying the display name of the variable on the source side of
+        the data transfer. Used when creating a variable-based data transfer.
+        Must be combined with ``target_variable``.
+        """
+
+        syc_name = "SourceVariable"
+
+    class target_variable(String):
+        """
+        String specifying the display name of the variable on the target side of
+        the data transfer. Must be combined with either ``source_variable`` (when
+        creating a variable-based data transfer) or with ``value_{x|y|z}``
+        (when creating an expression-based data transfer).
+        """
+
+        syc_name = "TargetVariable"
+
+    class value(String):
+        """
+        String specifying the expression to use on the source side of the data
+        transfer. Used when creating an expression-based data transfer if the
+        ``target_variable`` is a scalar. (If the ``target_variable`` is a vector,
+        ``value_x``, ``value_y``, ``value_z`` must be used instead.)
+        """
+
+        syc_name = "Value"
+
+    class value_x(String):
+        """
+        String specifying the X component of the expression to use on the
+        source side of the data transfer. Used when crating an expression-based
+        data transfer if the ``target_variable`` is a vector. (If the ``target_variable``
+        is scalar, ``value`` must be used instead.) ``value_y`` and ``value_z`` are also
+        required if ``value_x`` is used.
+        """
+
+        syc_name = "ValueX"
+
+    class value_y(String):
+        """
+        String specifying the Y component of the expression to use on the
+        source side of the data transfer. Used when crating an expression-based
+        data transfer if the ``target_variable`` is a vector. (If the ``target_variable``
+        is scalar, ``value`` must be used instead.) ``value_x`` and ``value_z`` are also
+        required if ``value_y`` is used.
+        """
+
+        syc_name = "ValueY"
+
+    class value_z(String):
+        """
+        String specifying the Z component of the expression to use on the
+        source side of the data transfer. Used when crating an expression-based
+        data transfer if the ``target_variable`` is a vector. (If the ``target_variable``
+        is scalar, ``value`` must be used instead.) ``value_x`` and ``value_y`` are also
+        required if ``value_z`` is used.
+        """
+
+        syc_name = "ValueZ"
+
+    class side_one_variable(String):
+        """
+        String specifying the display name of the variable associated with side one
+        of the interface. Must be combined with ``side_two_variable``. Used only
+        when creating variable-based data transfers. Consider using
+        ``source_variable``/``target_variable`` parameters instead.
+        """
+
+        syc_name = "SideOneVariable"
+
+    class side_two_variable(String):
+        """
+        String specifying the display name of the variable associated with side two
+        of the interface. Must be combined with ``side_two_variable``. Used only
+        when creating variable-based data transfers. Consider using
+        ``source_variable``/``target_variable`` parameters instead.
+        """
+
+        syc_name = "SideTwoVariable"

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

@@ -0,0 +1,61 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_expression_function(Command):
+    """
+    Creates an expression function object in the data model that makes
+    available an external Python function for use in expressions.
+
+    The parameters specified should correspond to a module and function
+    that exists and can successfully be loaded when the application
+    starts. Otherwise, the data model object will be created but there
+    will be validation errors and the function will not be available for
+    use.
+
+    Parameters
+    ----------
+    module : str
+        The name of the Python module (in the 'Modules' sub-directory of
+        the working directory) from which the function is to be obtained.
+    function : str
+        The name of the function in the module. If no ``function_name`` is
+        specified, this will also be the name by which the function should
+        be referenced when used in an expression.
+    function_name : str, optional
+        Optionally specify a different name from ``function`` which should be
+        the name used to reference the function in an expression.
+
+    """
+
+    syc_name = "AddExpressionFunction"
+
+    argument_names = ["module", "function", "function_name"]
+
+    class module(String):
+        """
+        The name of the Python module (in the 'Modules' sub-directory of
+        the working directory) from which the function is to be obtained.
+        """
+
+        syc_name = "Module"
+
+    class function(String):
+        """
+        The name of the function in the module. If no ``function_name`` is
+        specified, this will also be the name by which the function should
+        be referenced when used in an expression.
+        """
+
+        syc_name = "Function"
+
+    class function_name(String):
+        """
+        Optionally specify a different name from ``function`` which should be
+        the name used to reference the function in an expression.
+        """
+
+        syc_name = "FunctionName"

ansys/systemcoupling/core/adaptor/api_24_2/add_fsi_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_fsi_data_transfers(Command):
+    """
+    Adds group of data transfers for FSI 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.
+    use_force_density : bool, optional
+        Boolean indicating whether to prefer force density variable over force.
+        Default value is False.
+
+    """
+
+    syc_name = "AddFSIDataTransfers"
+
+    argument_names = ["interface", "use_force_density"]
+
+    class interface(String):
+        """
+        String indicating the name of the interface on which the data transfer
+        is to be created.
+        """
+
+        syc_name = "Interface"
+
+    class use_force_density(Boolean):
+        """
+        Boolean indicating whether to prefer force density variable over force.
+        Default value is False.
+        """
+
+        syc_name = "UseForceDensity"

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

@@ -0,0 +1,77 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_interface(Command):
+    """
+    Adds an interface based on the participant and region names specified
+    as arguments for each side of the interface. This command requires that
+    you specify participants using their names as described below in
+    Essential Keyword Arguments. Non-FMU participants must provide a list
+    of regions as described below in Optional Keyword Arguments. For FMU
+    interfaces, specifying the regions are not allowed.
+
+    Cannot be run after participants have been started.
+
+    Returns the name of the Interface created.
+
+    Parameters
+    ----------
+    side_one_participant : str
+        String indicating the name of the participant to be associated with
+        side \"One\" of the interface.
+    side_two_participant : str
+        String indicating the name of the participant to be associated with
+        side \"Two"\ of the interface.
+    side_one_regions : typing.List[str], optional
+        List specifying the name(s) of region(s) to be added to side One of
+        the interface. Must be provided if ``side_one_participant`` is not an FMU.
+    side_two_regions : typing.List[str], optional
+        List specifying the name(s) of region(s) to be added to side Two of
+        the interface. Must be provided if ``side_one_participant`` is not an FMU.
+
+    """
+
+    syc_name = "AddInterface"
+
+    argument_names = [
+        "side_one_participant",
+        "side_two_participant",
+        "side_one_regions",
+        "side_two_regions",
+    ]
+
+    class side_one_participant(String):
+        """
+        String indicating the name of the participant to be associated with
+        side \"One\" of the interface.
+        """
+
+        syc_name = "SideOneParticipant"
+
+    class side_two_participant(String):
+        """
+        String indicating the name of the participant to be associated with
+        side \"Two"\ of the interface.
+        """
+
+        syc_name = "SideTwoParticipant"
+
+    class side_one_regions(StringList):
+        """
+        List specifying the name(s) of region(s) to be added to side One of
+        the interface. Must be provided if ``side_one_participant`` is not an FMU.
+        """
+
+        syc_name = "SideOneRegions"
+
+    class side_two_regions(StringList):
+        """
+        List specifying the name(s) of region(s) to be added to side Two of
+        the interface. Must be provided if ``side_one_participant`` is not an FMU.
+        """
+
+        syc_name = "SideTwoRegions"

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

@@ -0,0 +1,78 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_interface_by_display_names(Command):
+    """
+    Important: This command is deprecated. To add an interface, use the
+    ``add_interface`` command instead.
+
+    Adds an interface based on the participant and region display names specified
+    as arguments for each side of the interface. This command requires that you
+    specify participants and regions using their *display* names (see parameter
+    descriptions for details).
+
+    Cannot be run after participants have been started.
+
+    Returns the name of the Interface created.
+
+    Parameters
+    ----------
+    side_one_participant : str
+        String indicating the name of the participant to be associated with
+        side \"One\" of the interface.
+    side_one_regions : typing.List[str]
+        List specifying the name(s) of region(s) to be added to side \"One\" of
+        the interface.
+    side_two_participant : str
+        String indicating the name of the participant to be associated with
+        side \"Two\" of the interface.
+    side_two_regions : typing.List[str]
+        List specifying the name(s) of region(s) to be added to side \"Two\"
+        of the interface.
+
+    """
+
+    syc_name = "AddInterfaceByDisplayNames"
+
+    argument_names = [
+        "side_one_participant",
+        "side_one_regions",
+        "side_two_participant",
+        "side_two_regions",
+    ]
+
+    class side_one_participant(String):
+        """
+        String indicating the name of the participant to be associated with
+        side \"One\" of the interface.
+        """
+
+        syc_name = "SideOneParticipant"
+
+    class side_one_regions(StringList):
+        """
+        List specifying the name(s) of region(s) to be added to side \"One\" of
+        the interface.
+        """
+
+        syc_name = "SideOneRegions"
+
+    class side_two_participant(String):
+        """
+        String indicating the name of the participant to be associated with
+        side \"Two\" of the interface.
+        """
+
+        syc_name = "SideTwoParticipant"
+
+    class side_two_regions(StringList):
+        """
+        List specifying the name(s) of region(s) to be added to side \"Two\"
+        of the interface.
+        """
+
+        syc_name = "SideTwoRegions"

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

@@ -0,0 +1,42 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class add_named_expression(Command):
+    """
+    Creates a named expression object in the data model.
+    If there is already an object in the data model whose ``expression_name``
+    matches the provided ``expression_name``, its ``expression_string`` will be
+    overwritten with the provided ``expression_string``
+
+    Parameters
+    ----------
+    expression_name : str
+        The name by which this expression should be referenced when used in
+        another expression.
+    expression_string : str
+        String containing the definition of the expression.
+
+    """
+
+    syc_name = "AddNamedExpression"
+
+    argument_names = ["expression_name", "expression_string"]
+
+    class expression_name(String):
+        """
+        The name by which this expression should be referenced when used in
+        another expression.
+        """
+
+        syc_name = "ExpressionName"
+
+    class expression_string(String):
+        """
+        String containing the definition of the expression.
+        """
+
+        syc_name = "ExpressionString"

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"