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

ansys/systemcoupling/core/adaptor/api_23_1/mapping_control.py

@@ -0,0 +1,229 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class mapping_control(Container):
+    """
+    Configure controls for mapping.
+    """
+
+    syc_name = "MappingControl"
+
+    property_names_types = [
+        ("stop_if_poor_intersection", "StopIfPoorIntersection", "bool"),
+        ("poor_intersection_threshold", "PoorIntersectionThreshold", "RealType"),
+        ("face_alignment", "FaceAlignment", "str"),
+        ("absolute_gap_tolerance", "AbsoluteGapTolerance", "RealType"),
+        ("relative_gap_tolerance", "RelativeGapTolerance", "RealType"),
+        ("small_weight_tolerance", "SmallWeightTolerance", "RealType"),
+        ("corner_tolerance", "CornerTolerance", "RealType"),
+        ("halo_tolerance", "HaloTolerance", "RealType"),
+        (
+            "conservative_reciprocity_factor",
+            "ConservativeReciprocityFactor",
+            "RealType",
+        ),
+        (
+            "profile_preserving_reciprocity_factor",
+            "ProfilePreservingReciprocityFactor",
+            "RealType",
+        ),
+        ("conservative_intensive", "ConservativeIntensive", "str"),
+        ("preserve_normal", "PreserveNormal", "str"),
+        (
+            "conservation_fix_tolerance_volume",
+            "ConservationFixToleranceVolume",
+            "RealType",
+        ),
+        ("rbf_option", "RBFOption", "str"),
+        ("rbf_shape_parameter", "RBFShapeParameter", "RealType"),
+        ("rbf_linear_correction", "RBFLinearCorrection", "bool"),
+        ("rbf_clipping_scale", "RBFClippingScale", "RealType"),
+    ]
+
+    @property
+    def stop_if_poor_intersection(self) -> bool:
+        """Controls whether to stop if the intersection is poor"""
+        return self.get_property_state("stop_if_poor_intersection")
+
+    @stop_if_poor_intersection.setter
+    def stop_if_poor_intersection(self, value: bool):
+        self.set_property_state("stop_if_poor_intersection", value)
+
+    @property
+    def poor_intersection_threshold(self) -> RealType:
+        """System Coupling terminates with an error if the intersected fractions are below this threshold (in both directions)"""
+        return self.get_property_state("poor_intersection_threshold")
+
+    @poor_intersection_threshold.setter
+    def poor_intersection_threshold(self, value: RealType):
+        self.set_property_state("poor_intersection_threshold", value)
+
+    @property
+    def face_alignment(self) -> str:
+        """Controls how face alignment is used during mapping.
+
+        Allowed values:
+
+        - \"ProgramControlled\" (default)
+        - \"OppositeOrientation\"
+        - \"SameOrientation\"
+        - \"AnyOrientation\" """
+        return self.get_property_state("face_alignment")
+
+    @face_alignment.setter
+    def face_alignment(self, value: str):
+        self.set_property_state("face_alignment", value)
+
+    @property
+    def absolute_gap_tolerance(self) -> RealType:
+        """Absolute gap tolerance value."""
+        return self.get_property_state("absolute_gap_tolerance")
+
+    @absolute_gap_tolerance.setter
+    def absolute_gap_tolerance(self, value: RealType):
+        self.set_property_state("absolute_gap_tolerance", value)
+
+    @property
+    def relative_gap_tolerance(self) -> RealType:
+        """Maximum gap size relative to face size."""
+        return self.get_property_state("relative_gap_tolerance")
+
+    @relative_gap_tolerance.setter
+    def relative_gap_tolerance(self, value: RealType):
+        self.set_property_state("relative_gap_tolerance", value)
+
+    @property
+    def small_weight_tolerance(self) -> RealType:
+        """Relative tolerance used to control when weights are dropped."""
+        return self.get_property_state("small_weight_tolerance")
+
+    @small_weight_tolerance.setter
+    def small_weight_tolerance(self, value: RealType):
+        self.set_property_state("small_weight_tolerance", value)
+
+    @property
+    def corner_tolerance(self) -> RealType:
+        """Angle [degrees] between adjacent source mesh faces above which the
+        mapping algorithm will stop searching for mapping candidates."""
+        return self.get_property_state("corner_tolerance")
+
+    @corner_tolerance.setter
+    def corner_tolerance(self, value: RealType):
+        self.set_property_state("corner_tolerance", value)
+
+    @property
+    def halo_tolerance(self) -> RealType:
+        """If a face intersects but a target node lies outside of the source face, then
+        map the node if the projected distance to the face / sqrt(srcArea) is less
+        than this tolerance, otherwise leave as unmapped."""
+        return self.get_property_state("halo_tolerance")
+
+    @halo_tolerance.setter
+    def halo_tolerance(self, value: RealType):
+        self.set_property_state("halo_tolerance", value)
+
+    @property
+    def conservative_reciprocity_factor(self) -> RealType:
+        """Reciprocity blend factor for conservative mapping."""
+        return self.get_property_state("conservative_reciprocity_factor")
+
+    @conservative_reciprocity_factor.setter
+    def conservative_reciprocity_factor(self, value: RealType):
+        self.set_property_state("conservative_reciprocity_factor", value)
+
+    @property
+    def profile_preserving_reciprocity_factor(self) -> RealType:
+        """Reciprocity blend factor for profile-preserving mapping."""
+        return self.get_property_state("profile_preserving_reciprocity_factor")
+
+    @profile_preserving_reciprocity_factor.setter
+    def profile_preserving_reciprocity_factor(self, value: RealType):
+        self.set_property_state("profile_preserving_reciprocity_factor", value)
+
+    @property
+    def conservative_intensive(self) -> str:
+        """Determines when the Intensive option is used for conservative mapping.
+
+        Allowed values:
+
+        - \"ProgramControlled\" (default)
+        - \"Off\"
+        - \"On\" """
+        return self.get_property_state("conservative_intensive")
+
+    @conservative_intensive.setter
+    def conservative_intensive(self, value: str):
+        self.set_property_state("conservative_intensive", value)
+
+    @property
+    def preserve_normal(self) -> str:
+        """Determines if the normal component of a vector is preserved.
+
+        Allowed values:
+
+        - \"ProgramControlled\" (default)
+        - \"Off\"
+        - \"On\" """
+        return self.get_property_state("preserve_normal")
+
+    @preserve_normal.setter
+    def preserve_normal(self, value: str):
+        self.set_property_state("preserve_normal", value)
+
+    @property
+    def conservation_fix_tolerance_volume(self) -> RealType:
+        """Source element overlap fraction to trigger volume mapping conservation fix.
+
+        0.0 is default. 1.0 effectively disables it."""
+        return self.get_property_state("conservation_fix_tolerance_volume")
+
+    @conservation_fix_tolerance_volume.setter
+    def conservation_fix_tolerance_volume(self, value: RealType):
+        self.set_property_state("conservation_fix_tolerance_volume", value)
+
+    @property
+    def rbf_option(self) -> str:
+        """Controls radial basis function formulation.
+
+        Allowed values:
+
+        - \"Gaussian\" (default)
+        - \"ThinPlateSpline\" """
+        return self.get_property_state("rbf_option")
+
+    @rbf_option.setter
+    def rbf_option(self, value: str):
+        self.set_property_state("rbf_option", value)
+
+    @property
+    def rbf_shape_parameter(self) -> RealType:
+        """Sets the shape parameter beta when using Gaussian radial basis functions."""
+        return self.get_property_state("rbf_shape_parameter")
+
+    @rbf_shape_parameter.setter
+    def rbf_shape_parameter(self, value: RealType):
+        self.set_property_state("rbf_shape_parameter", value)
+
+    @property
+    def rbf_linear_correction(self) -> bool:
+        """Controls whether linear polynomial augmentation is added to the RBF stencil for
+        low order regular element types (tet, hex, pyramid, wedge)."""
+        return self.get_property_state("rbf_linear_correction")
+
+    @rbf_linear_correction.setter
+    def rbf_linear_correction(self, value: bool):
+        self.set_property_state("rbf_linear_correction", value)
+
+    @property
+    def rbf_clipping_scale(self) -> RealType:
+        """Length scale factor used to determine if source nodes are removed from RBF
+        stencil when too close."""
+        return self.get_property_state("rbf_clipping_scale")
+
+    @rbf_clipping_scale.setter
+    def rbf_clipping_scale(self, value: RealType):
+        self.set_property_state("rbf_clipping_scale", value)

ansys/systemcoupling/core/adaptor/api_23_1/open.py

@@ -0,0 +1,102 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class open(Command):
+    """
+    Reads the state of a coupled analysis. The state consists of settings to
+    populate the datamodel and results to restart the analysis at the end of
+    a specified coupling step.
+
+    Settings are stored in a file named Settings.h5. Results files may
+    correspond either to coupling iterations or coupling steps, depending on
+    the analysis type and the types of participants involved.
+
+    By default (no arguments provided), this command looks for the ``SyC``
+    directory in the current  working directory. By default, if multiple
+    results files exist, the most recent one is opened.
+
+    If given optional arguments, behavior is modified as described below.
+
+    Cannot be run after the participants have been started.
+
+    Parameters
+    ----------
+    file_path : str, optional
+        Working directory containing the ``SyC`` subdirectory (and its .h5
+        file(s)) to be read.
+    coupling_step : int, optional
+        Integer specifying the coupling step at which the coupled analysis is
+        restarted. When used, System Coupling reads the corresponding
+        ``Results_step<#>.h5`` file in the specified directory and restarts the
+        analysis at the end of the specified coupling step. When this argument
+        is used, System Coupling automatically removes the output files related
+        to all later coupling steps. If the files cannot be removed, then
+        System Coupling generates an exception message instructing you to free
+        up the files and reissue the ``open`` command with the ``coupling_step``
+        argument. If the simulation's results files are associated with
+        coupling iterations, then System Coupling prints an error message
+        indicating this.
+    coupling_iteration : int, optional
+        Integer specifying the coupling iteration at which the coupled analysis
+        is restarted. When used, System Coupling reads the corresponding
+        ``Results_iter<#>.h5`` file in the specified directory and restarts the
+        analysis at the end of the specified coupling iteration. When this
+        argument is used, System Coupling automatically removes the output
+        files related to all later coupling iterations. If the files cannot be
+        removed, then System Coupling generates an exception message
+        instructing you to free up the files and reissue the ``open`` command with
+        the ``coupling_iteration`` argument. If the simulation's results files are
+        associated with coupling steps, then System Coupling prints an error
+        message indicating this.
+
+    """
+
+    syc_name = "Open"
+
+    argument_names = ["file_path", "coupling_step", "coupling_iteration"]
+
+    class file_path(String):
+        """
+        Working directory containing the ``SyC`` subdirectory (and its .h5
+        file(s)) to be read.
+        """
+
+        syc_name = "FilePath"
+
+    class coupling_step(Integer):
+        """
+        Integer specifying the coupling step at which the coupled analysis is
+        restarted. When used, System Coupling reads the corresponding
+        ``Results_step<#>.h5`` file in the specified directory and restarts the
+        analysis at the end of the specified coupling step. When this argument
+        is used, System Coupling automatically removes the output files related
+        to all later coupling steps. If the files cannot be removed, then
+        System Coupling generates an exception message instructing you to free
+        up the files and reissue the ``open`` command with the ``coupling_step``
+        argument. If the simulation's results files are associated with
+        coupling iterations, then System Coupling prints an error message
+        indicating this.
+        """
+
+        syc_name = "CouplingStep"
+
+    class coupling_iteration(Integer):
+        """
+        Integer specifying the coupling iteration at which the coupled analysis
+        is restarted. When used, System Coupling reads the corresponding
+        ``Results_iter<#>.h5`` file in the specified directory and restarts the
+        analysis at the end of the specified coupling iteration. When this
+        argument is used, System Coupling automatically removes the output
+        files related to all later coupling iterations. If the files cannot be
+        removed, then System Coupling generates an exception message
+        instructing you to free up the files and reissue the ``open`` command with
+        the ``coupling_iteration`` argument. If the simulation's results files are
+        associated with coupling steps, then System Coupling prints an error
+        message indicating this.
+        """
+
+        syc_name = "CouplingIteration"

ansys/systemcoupling/core/adaptor/{api_24_1/open_results_in_en_sight.py → api_23_1/open_results_in_ensight.py}

@@ -5,7 +5,7 @@
 from ansys.systemcoupling.core.adaptor.impl.types import *
 
 
-class open_results_in_en_sight(Command):
+class open_results_in_ensight(Command):
     """
     Allows for System Coupling results to be postprocessed in EnSight.
 
@@ -23,34 +23,6 @@ class open_results_in_en_sight(Command):
     instance of the EnSight application is opened. Any existing instances of
     EnSight remain open, both when additional instances are created and when
     System Coupling exits.
-
-    Parameters
-    ----------
-    file_name : str, optional
-        The basename of the EnSight case file if using a non-standard file
-        name. Overrides the default file name ``results.enc``.
-    file_path : str, optional
-        The path to the EnSight case if using a non-standard location.
-        Overrides the default path of ``SyC/results``.
-
     """
 
     syc_name = "OpenResultsInEnSight"
-
-    argument_names = ["file_name", "file_path"]
-
-    class file_name(String):
-        """
-        The basename of the EnSight case file if using a non-standard file
-        name. Overrides the default file name ``results.enc``.
-        """
-
-        syc_name = "FileName"
-
-    class file_path(String):
-        """
-        The path to the EnSight case if using a non-standard location.
-        Overrides the default path of ``SyC/results``.
-        """
-
-        syc_name = "FilePath"

ansys/systemcoupling/core/adaptor/api_23_1/open_snapshot.py

@@ -0,0 +1,37 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+
+class open_snapshot(Command):
+    """
+    Opens a snapshot containing a previously saved state of the simulation.
+    All state (files and directories) stored in the snapshot will be restored.
+    If other state exists in the working directory, then it will not be
+    modified by this command.
+
+    Note: Snapshot cannot be opened if participants have been started.
+
+    Parameters
+    ----------
+    snapshot_name : str, optional
+        The name of the snapshot to be opened. This is optional if and only if
+        there is only one snapshot available to be loaded. If multiple
+        snapshots exist, then the snapshot name must be specified.
+
+    """
+
+    syc_name = "OpenSnapshot"
+
+    argument_names = ["snapshot_name"]
+
+    class snapshot_name(String):
+        """
+        The name of the snapshot to be opened. This is optional if and only if
+        there is only one snapshot available to be loaded. If multiple
+        snapshots exist, then the snapshot name must be specified.
+        """
+
+        syc_name = "SnapshotName"

ansys/systemcoupling/core/adaptor/api_23_1/output_control.py

@@ -0,0 +1,129 @@
+#
+# This is an auto-generated file.  DO NOT EDIT!
+#
+
+from ansys.systemcoupling.core.adaptor.impl.types import *
+
+from .ascii_output import ascii_output
+from .results import results
+
+
+class output_control(Container):
+    """
+    Configure output controls.
+    """
+
+    syc_name = "OutputControl"
+
+    child_names = ["results", "ascii_output"]
+
+    results: results = results
+    """
+    results child of output_control.
+    """
+    ascii_output: ascii_output = ascii_output
+    """
+    ascii_output child of output_control.
+    """
+    property_names_types = [
+        ("option", "Option", "str"),
+        ("generate_csv_chart_output", "GenerateCSVChartOutput", "bool"),
+        ("write_initial_snapshot", "WriteInitialSnapshot", "bool"),
+        ("transcript_precision", "TranscriptPrecision", "int"),
+        ("write_diagnostics", "WriteDiagnostics", "bool"),
+        ("write_weights_matrix", "WriteWeightsMatrix", "bool"),
+        ("write_residuals", "WriteResiduals", "bool"),
+        ("output_frequency", "OutputFrequency", "int"),
+    ]
+
+    @property
+    def option(self) -> str:
+        """Specifies when restart points are generated.
+
+        Allowed values (step-based analyses only):
+
+        - \"LastStep\" - Generates a restart point only for the last
+          coupling step completed.
+        - \"EveryStep\" -
+          Generate a restart point at the end of every coupling step.
+        - \"StepInterval\" - Generates a restart point at the end of
+          coupling steps at the interval specified by the output
+          frequency setting.
+
+        Allowed values (iteration-based analyses only):
+
+        - \"LastIteration\" - Generates a restart point only for the
+          last coupling iteration completed.
+        - \"EveryIteration\" - Generate a restart point at the end
+          of every coupling iteration.
+        - \"IterationInterval\" - Generates a restart point 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 generate_csv_chart_output(self) -> bool:
+        """Write chart data in CSV format during solve."""
+        return self.get_property_state("generate_csv_chart_output")
+
+    @generate_csv_chart_output.setter
+    def generate_csv_chart_output(self, value: bool):
+        self.set_property_state("generate_csv_chart_output", value)
+
+    @property
+    def write_initial_snapshot(self) -> bool:
+        """Write initial snapshot."""
+        return self.get_property_state("write_initial_snapshot")
+
+    @write_initial_snapshot.setter
+    def write_initial_snapshot(self, value: bool):
+        self.set_property_state("write_initial_snapshot", value)
+
+    @property
+    def transcript_precision(self) -> int:
+        """Number of digits after decimal point in transcript."""
+        return self.get_property_state("transcript_precision")
+
+    @transcript_precision.setter
+    def transcript_precision(self, value: int):
+        self.set_property_state("transcript_precision", value)
+
+    @property
+    def write_diagnostics(self) -> bool:
+        """Write transfer diagnostics dictionary to file."""
+        return self.get_property_state("write_diagnostics")
+
+    @write_diagnostics.setter
+    def write_diagnostics(self, value: bool):
+        self.set_property_state("write_diagnostics", value)
+
+    @property
+    def write_weights_matrix(self) -> bool:
+        """Write mapping weights to file after calculation."""
+        return self.get_property_state("write_weights_matrix")
+
+    @write_weights_matrix.setter
+    def write_weights_matrix(self, value: bool):
+        self.set_property_state("write_weights_matrix", value)
+
+    @property
+    def write_residuals(self) -> bool:
+        """Write residuals to results files."""
+        return self.get_property_state("write_residuals")
+
+    @write_residuals.setter
+    def write_residuals(self, value: bool):
+        self.set_property_state("write_residuals", 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_23_1/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 : typing.List[typing.Tuple[str, float]], 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 : typing.List[typing.Dict[str, typing.Union[str, int]]], 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 : typing.Dict[str, typing.List[typing.Dict[str, typing.Union[str, int]]]], 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"