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

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

@@ -0,0 +1,60 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class parameter_child(Container):
+    """
+    Configure a parameter for the coupling participant.
+    """
+
+    syc_name = "child_object_type"
+
+    property_names_types = [
+        ("participant_display_name", "ParticipantDisplayName", "str"),
+        ("display_name", "DisplayName", "str"),
+        ("data_type", "DataType", "str"),
+        ("tensor_type", "TensorType", "str"),
+    ]
+
+    @property
+    def participant_display_name(self) -> str:
+        """Parameter's display name as defined by the participant solver."""
+        return self.get_property_state("participant_display_name")
+
+    @participant_display_name.setter
+    def participant_display_name(self, value: str):
+        self.set_property_state("participant_display_name", value)
+
+    @property
+    def display_name(self) -> str:
+        """Parameter's display name as defined in System Coupling."""
+        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 data_type(self) -> str:
+        """Parameter's data type as reported by the participant.
+
+        Allowed values:
+
+        - Real"""
+        return self.get_property_state("data_type")
+
+    @data_type.setter
+    def data_type(self, value: str):
+        self.set_property_state("data_type", value)
+
+    @property
+    def tensor_type(self) -> str:
+        """Indicates the parameter tensor type (\"Scalar\" only)."""
+        return self.get_property_state("tensor_type")
+
+    @tensor_type.setter
+    def tensor_type(self, value: str):
+        self.set_property_state("tensor_type", value)

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

@@ -0,0 +1,148 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class partition_participants(Command):
+    """
+    Provide a utility for setting the parallel algorithm, parallel partitioning
+    fractions for each participant, and machine list information.
+
+    At least one participant must be defined for this command to be used. Use
+    of this command is not recommended if participants are already running.
+
+    Note:
+    Ansys recommends only using this command for the Custom partitioning algorithm.
+
+    When other algorithms are used (SharedAllocateMachines,
+    DistributedAllocateCores, etc.) the algorithm should be specified directly,
+    for example:
+
+    ``setup.analysis_control.partitioning_algorithm = "SharedAllocateMachines"``
+
+    The participant parallel fractions can also be specified directly, for example:
+
+    ``setup.coupling_participant["FLUENT-1"].execution_control.parallel_fraction = 0.5``
+
+    The machine list should be specified via System Coupling command line arguments,
+    for example:
+
+    ``<v252>/SystemCoupling/binsystemcoupling --cnf="hostA:4,hostB:4"``
+
+    Parameters
+    ----------
+    algorithm_name : str, optional
+        Name of the partitioning algorithm. Available algorithms are:
+        'SharedAllocateMachines'(default), 'SharedAllocateCores',
+        'DistributedAllocateMachines', 'DistributedAllocateCores',
+        and 'Custom' (please see ``partitioning_info`` section below for more details
+        for this algorithm)
+
+        The algorithms allow for both shared and distributed execution and for
+        the allocation of machines or cores. The default value is generally the
+        best choice, as it allows for each participant to take advantage of all
+        the allocated resources. The other partitioning methods are provided to
+        handle situations where not enough resources are available to run the
+        same machines.
+
+        See the System Coupling documentation for more details of the
+        partitioning algorithms.
+    names_and_fractions : List, optional
+        List of tuples specifying the fractions of core count applied for
+        each participant
+
+        Each tuple must have the ParticipantName as its first item and the
+        associated fraction as its second item. If this parameter is omitted,
+        then cores will be allocated for all participants set in the
+        data model.
+    machine_list : List, optional
+        List of dictionaries specifying machines available for distributed run.
+        Each dictionary must have a key 'machine-name' with machine name as its
+        value, and key 'core-count' with number of cores for that machine as
+        its value. Providing this argument will over-ride any machine-list
+        information detected from the scheduler environment and any information
+        provided by the --cnf command-line argument.
+    partitioning_info : Dict, optional
+        Dictionary specifying machines resources assigned to each participant by user.
+        Dictionary must have participant names as keys and machineLists containing
+        machine resources as values. The value of ``partitioning_info`` machineList is
+        a list of dictionaries specifying machines assigned to corresponding participants.
+        Each dictionary of machine mist must have a key 'machine-name' with machine name
+        as its value, and key 'core-count' with number of cores for that machine as its value.
+        Providing this argument will disallow other arguments except ``algorithm_name``,
+        which must set as 'Custom' if provided. Otherwise, ``algorithm_name`` will be set as
+        'Custom' internally if ``partitioning_info`` is provided.
+
+    """
+
+    syc_name = "PartitionParticipants"
+
+    argument_names = [
+        "algorithm_name",
+        "names_and_fractions",
+        "machine_list",
+        "partitioning_info",
+    ]
+
+    class algorithm_name(String):
+        """
+        Name of the partitioning algorithm. Available algorithms are:
+        'SharedAllocateMachines'(default), 'SharedAllocateCores',
+        'DistributedAllocateMachines', 'DistributedAllocateCores',
+        and 'Custom' (please see ``partitioning_info`` section below for more details
+        for this algorithm)
+
+        The algorithms allow for both shared and distributed execution and for
+        the allocation of machines or cores. The default value is generally the
+        best choice, as it allows for each participant to take advantage of all
+        the allocated resources. The other partitioning methods are provided to
+        handle situations where not enough resources are available to run the
+        same machines.
+
+        See the System Coupling documentation for more details of the
+        partitioning algorithms.
+        """
+
+        syc_name = "AlgorithmName"
+
+    class names_and_fractions(StrFloatPairList):
+        """
+        List of tuples specifying the fractions of core count applied for
+        each participant
+
+        Each tuple must have the ParticipantName as its first item and the
+        associated fraction as its second item. If this parameter is omitted,
+        then cores will be allocated for all participants set in the
+        data model.
+        """
+
+        syc_name = "NamesAndFractions"
+
+    class machine_list(StrOrIntDictList):
+        """
+        List of dictionaries specifying machines available for distributed run.
+        Each dictionary must have a key 'machine-name' with machine name as its
+        value, and key 'core-count' with number of cores for that machine as
+        its value. Providing this argument will over-ride any machine-list
+        information detected from the scheduler environment and any information
+        provided by the --cnf command-line argument.
+        """
+
+        syc_name = "MachineList"
+
+    class partitioning_info(StrOrIntDictListDict):
+        """
+        Dictionary specifying machines resources assigned to each participant by user.
+        Dictionary must have participant names as keys and machineLists containing
+        machine resources as values. The value of ``partitioning_info`` machineList is
+        a list of dictionaries specifying machines assigned to corresponding participants.
+        Each dictionary of machine mist must have a key 'machine-name' with machine name
+        as its value, and key 'core-count' with number of cores for that machine as its value.
+        Providing this argument will disallow other arguments except ``algorithm_name``,
+        which must set as 'Custom' if provided. Otherwise, ``algorithm_name`` will be set as
+        'Custom' internally if ``partitioning_info`` is provided.
+        """
+
+        syc_name = "PartitioningInfo"

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

@@ -0,0 +1,36 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class properties(Container):
+    """
+    UNDOCUMENTED
+    """
+
+    syc_name = "Properties"
+
+    property_names_types = [
+        ("accepts_new_inputs", "AcceptsNewInputs", "bool"),
+        ("time_integration", "TimeIntegration", "str"),
+    ]
+
+    @property
+    def accepts_new_inputs(self) -> bool:
+        """Controls whether participant accept new input variables or parameters."""
+        return self.get_property_state("accepts_new_inputs")
+
+    @accepts_new_inputs.setter
+    def accepts_new_inputs(self, value: bool):
+        self.set_property_state("accepts_new_inputs", value)
+
+    @property
+    def time_integration(self) -> str:
+        """Coupling participant time integration method (\"Implicit\" or \"Explicit\")"""
+        return self.get_property_state("time_integration")
+
+    @time_integration.setter
+    def time_integration(self, value: str):
+        self.set_property_state("time_integration", value)

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

@@ -0,0 +1,46 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class record_interactions(Container):
+    """
+    "Controls whether the System Coupling Participant library will record the setup and solution data files for testing and debugging.
+    """
+
+    syc_name = "RecordInteractions"
+
+    property_names_types = [
+        ("record_setup", "RecordSetup", "bool"),
+        ("record_solution", "RecordSolution", "bool"),
+        ("record_precision", "RecordPrecision", "int"),
+    ]
+
+    @property
+    def record_setup(self) -> bool:
+        """Flag indicating whether participant record scp file."""
+        return self.get_property_state("record_setup")
+
+    @record_setup.setter
+    def record_setup(self, value: bool):
+        self.set_property_state("record_setup", value)
+
+    @property
+    def record_solution(self) -> bool:
+        """Flag indicating whether participant record solution files."""
+        return self.get_property_state("record_solution")
+
+    @record_solution.setter
+    def record_solution(self, value: bool):
+        self.set_property_state("record_solution", value)
+
+    @property
+    def record_precision(self) -> int:
+        """Set the digital precision of solution variable,1 <= N <= 16.."""
+        return self.get_property_state("record_precision")
+
+    @record_precision.setter
+    def record_precision(self, value: int):
+        self.set_property_state("record_precision", value)

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

@@ -0,0 +1,20 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .reference_frame_child import reference_frame_child
+
+
+class reference_frame(NamedContainer[reference_frame_child]):
+    """
+    Provide a transformation relative to a ParentReferenceFrame.
+    """
+
+    syc_name = "ReferenceFrame"
+
+    child_object_type: reference_frame_child = reference_frame_child
+    """
+    child_object_type of reference_frame.
+    """

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

@@ -0,0 +1,71 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .transformation import transformation
+
+
+class reference_frame_child(Container):
+    """
+    Provide a transformation relative to a ParentReferenceFrame.
+    """
+
+    syc_name = "child_object_type"
+
+    child_names = ["transformation"]
+
+    transformation: transformation = transformation
+    """
+    transformation child of reference_frame_child.
+    """
+    property_names_types = [
+        ("option", "Option", "str"),
+        ("parent_reference_frame", "ParentReferenceFrame", "str"),
+        ("transformation_order", "TransformationOrder", "StringListType"),
+        ("transformation_matrix", "TransformationMatrix", "RealListType"),
+    ]
+
+    @property
+    def option(self) -> str:
+        """Method used to define the transformation from the parent reference frame.
+
+        - \"ByTransformation\" - Define the reference frame by one or more
+          transformation operations.
+        - \"Automatic\" - Align source and target automatically.
+        - \"ByMatrix\" - Only available if Alpha features are activated."""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def parent_reference_frame(self) -> str:
+        """Set the parent reference frame."""
+        return self.get_property_state("parent_reference_frame")
+
+    @parent_reference_frame.setter
+    def parent_reference_frame(self, value: str):
+        self.set_property_state("parent_reference_frame", value)
+
+    @property
+    def transformation_order(self) -> StringListType:
+        """List names of transformations in the order in which they apply.
+
+        Available for the ``ByTransformation`` option."""
+        return self.get_property_state("transformation_order")
+
+    @transformation_order.setter
+    def transformation_order(self, value: StringListType):
+        self.set_property_state("transformation_order", value)
+
+    @property
+    def transformation_matrix(self) -> RealListType:
+        """Define the transformation matrix when ``ByTransformation`` option is active."""
+        return self.get_property_state("transformation_matrix")
+
+    @transformation_matrix.setter
+    def transformation_matrix(self, value: RealListType):
+        self.set_property_state("transformation_matrix", value)

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

@@ -0,0 +1,20 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .region_child import region_child
+
+
+class region(NamedContainer[region_child]):
+    """
+    Configure a region for the coupling participant.
+    """
+
+    syc_name = "Region"
+
+    child_object_type: region_child = region_child
+    """
+    child_object_type of region.
+    """

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

@@ -0,0 +1,71 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class region_child(Container):
+    """
+    Configure a region for the coupling participant.
+    """
+
+    syc_name = "child_object_type"
+
+    property_names_types = [
+        ("topology", "Topology", "str"),
+        ("input_variables", "InputVariables", "StringListType"),
+        ("output_variables", "OutputVariables", "StringListType"),
+        ("display_name", "DisplayName", "str"),
+        ("region_discretization_type", "RegionDiscretizationType", "str"),
+    ]
+
+    @property
+    def topology(self) -> str:
+        """Region topology type.
+
+        Allowed values:
+
+        - \"Surface\"
+        - \"Volume\" (3D participants only)"""
+        return self.get_property_state("topology")
+
+    @topology.setter
+    def topology(self, value: str):
+        self.set_property_state("topology", value)
+
+    @property
+    def input_variables(self) -> StringListType:
+        """Input variables for the region or FMU."""
+        return self.get_property_state("input_variables")
+
+    @input_variables.setter
+    def input_variables(self, value: StringListType):
+        self.set_property_state("input_variables", value)
+
+    @property
+    def output_variables(self) -> StringListType:
+        """Output variables for the region or FMU."""
+        return self.get_property_state("output_variables")
+
+    @output_variables.setter
+    def output_variables(self, value: StringListType):
+        self.set_property_state("output_variables", value)
+
+    @property
+    def display_name(self) -> str:
+        """Display name of the region."""
+        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 region_discretization_type(self) -> str:
+        """Region discretization type (\"Mesh Region\" or \"Point Cloud Region\")."""
+        return self.get_property_state("region_discretization_type")
+
+    @region_discretization_type.setter
+    def region_discretization_type(self, value: str):
+        self.set_property_state("region_discretization_type", value)

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

@@ -0,0 +1,14 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class reload_expression_function_modules(Command):
+    """
+    This may be called to force a reload of expression function modules
+    if they have changed since they were last loaded.
+    """
+
+    syc_name = "ReloadExpressionFunctionModules"

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

@@ -0,0 +1,89 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .type import type
+
+
+class results(Container):
+    """
+    Configures output of postprocessing results data.
+    """
+
+    syc_name = "Results"
+
+    child_names = ["type"]
+
+    type: type = type
+    """
+    type child of results.
+    """
+    property_names_types = [
+        ("option", "Option", "str"),
+        ("include_instances", "IncludeInstances", "str"),
+        ("output_frequency", "OutputFrequency", "int"),
+    ]
+
+    @property
+    def option(self) -> str:
+        """Specifies whether and when results files are generated.
+
+        Allowed values:
+
+        - \"ProgramControlled\" - Generate postprocessing results at the same
+          frequency as restart points, as defined by the output control option
+          setting. If no restart frequency is defined, then results are
+          generated at the end of the last coupling step.
+
+        -  \"Off\" - Generation of postprocessing results is disabled.
+
+        Allowed values for step-based analyses:
+
+        - \"LastStep\" - Generate results only for the last coupling step completed.
+
+        - \"EveryStep\" - Generate results at the end of every coupling step.
+
+        - \"StepInterval\" - Generate results at the end of coupling steps at
+          the interval specified by the output frequency setting.
+
+        Allowed values for iteration-based analyses:
+
+        - \"LastIteration\" - Generate results only for the last coupling
+          iteration completed.
+
+        - \"EveryIteration\" - Generate results at the end of every coupling
+          iteration.
+
+        - \"IterationInterval\" - Generate results at the end of coupling
+          iterations at the interval specified by the output frequency setting."""
+        return self.get_property_state("option")
+
+    @option.setter
+    def option(self, value: str):
+        self.set_property_state("option", value)
+
+    @property
+    def include_instances(self) -> str:
+        """Control whether instances are output.
+
+        Allowed values:
+
+        - \"ProgramControlled\"
+        - \"ReferenceOnly\"
+        - \"All\" """
+        return self.get_property_state("include_instances")
+
+    @include_instances.setter
+    def include_instances(self, value: str):
+        self.set_property_state("include_instances", value)
+
+    @property
+    def output_frequency(self) -> int:
+        """Specify output frequency."""
+        return self.get_property_state("output_frequency")
+
+    @output_frequency.setter
+    def output_frequency(self, value: int):
+        self.set_property_state("output_frequency", value)

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

@@ -0,0 +1,53 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class save(Command):
+    """
+    Saves the state of the coupled analysis data model.
+
+    --  Analysis settings are written to a single Settings.h5 file which
+        can be used to reload analysis settings.
+
+    --  Restart files for all restart points in the current co-simulation will
+        be written when this command is called. Existing restart files from
+        previous System Coupling versions will be renamed to conform to the new
+        naming scheme.
+
+    --  Restart files are named according to the convention
+        Restart_step#.h5 or Restart_iter#.h5, where "#" is the index of
+        the corresponding coupling step or iteration.
+
+    Returns a Boolean value of 'True' if the files were saved successfully;
+    otherwise, returns a value of 'False'.
+
+    Note that this command will raise an exception if another instance of
+    System Coupling is solving in the current working directory.
+
+    If given optional arguments, then behaves as described below in "Optional
+    Keyword Arguments."
+
+    Parameters
+    ----------
+    file_path : str, optional
+        Writeable directory to which the SyC directory is added. (Settings and
+        Results.h5 files will be written to the SyC directory.). Ansys does
+        not recommend changing the default value of this argument.
+
+    """
+
+    syc_name = "Save"
+
+    argument_names = ["file_path"]
+
+    class file_path(String):
+        """
+        Writeable directory to which the SyC directory is added. (Settings and
+        Results.h5 files will be written to the SyC directory.). Ansys does
+        not recommend changing the default value of this argument.
+        """
+
+        syc_name = "FilePath"