ansys-systemcoupling-core 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

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

@@ -0,0 +1,138 @@
+#
+# 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.
+
+    Parameters
+    ----------
+    algorithm_name : str, optional
+        Name of the partitioning algorithm. Available algorithms are:
+
+        - \"SharedAllocateMachines\" (default)
+        - \"SharedAllocateCores\"
+        - \"DistributedAllocateMachines\"
+        - \"DistributedAllocateCores\"
+        - \"Custom\" (see ``partitioning_info`` for more details)
+
+        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 participant name 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 override 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 machine lists containing
+        machine resources as values. The value of a ``partitioning_info`` machine list is
+        a list of dictionaries specifying machines assigned to corresponding participants.
+        Each dictionary of the machine list must have a key \"machine-name\" with the
+        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\"
+        - \"Custom\" (see ``partitioning_info`` for more details)
+
+        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 participant name 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 override 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 machine lists containing
+        machine resources as values. The value of a ``partitioning_info`` machine list is
+        a list of dictionaries specifying machines assigned to corresponding participants.
+        Each dictionary of the machine list must have a key \"machine-name\" with the
+        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,51 @@
+#
+# 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.
+
+    By default, writes to the ``SyC`` sub-directory of the current working
+    directory. This behavior may be modified by providing ``file_path``.
+
+    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.)
+
+    """
+
+    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.)
+        """
+
+        syc_name = "FilePath"

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

@@ -0,0 +1,54 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class save_snapshot(Command):
+    """
+    Saves a snapshot of the current state of the simulation. Snapshot will
+    contain all files and directories within the working directory that are
+    tracked by System Coupling: the SyC directory and the working directories
+    of all loaded participants. Before saving the snapshot, the current
+    datamodel will be saved.
+
+    Note: Snapshot cannot be saved if participants have been started.
+
+    Note: If files required for cosimulation are not stored within the working
+    directory, then they will not be included in the snapshot.
+
+    Parameters
+    ----------
+    snapshot_name : str
+        Name of the snapshot to be saved.
+    overwrite_existing : bool, optional
+        Boolean argument controlling whether an existing snapshot should be
+        overwritten. If ``True``, then an existing snapshot named ``snapshot_name`` will
+        be overwritten if it exists. If ``False`` (default), then if ``snapshot_name`` is
+        shared with an existing snapshot, a warning will be written and the
+        command will return without saving the snapshot.
+
+    """
+
+    syc_name = "SaveSnapshot"
+
+    argument_names = ["snapshot_name", "overwrite_existing"]
+
+    class snapshot_name(String):
+        """
+        Name of the snapshot to be saved.
+        """
+
+        syc_name = "SnapshotName"
+
+    class overwrite_existing(Boolean):
+        """
+        Boolean argument controlling whether an existing snapshot should be
+        overwritten. If ``True``, then an existing snapshot named ``snapshot_name`` will
+        be overwritten if it exists. If ``False`` (default), then if ``snapshot_name`` is
+        shared with an existing snapshot, a warning will be written and the
+        command will return without saving the snapshot.
+        """
+
+        syc_name = "OverwriteExisting"