update generated code (#1452)

Author: pyansys-ci-bot

doc/source/_static/dpf_operators.html

@@ -0,0 +1,383 @@
+"""
+apply_svd
+=========
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class apply_svd(Operator):
+    """Computes the coefficients (=U*Sigma) and VT components from SVD.
+
+    Parameters
+    ----------
+    field_contaner_to_compress : FieldsContainer
+        Fields container to be compressed
+    scalar_int : int
+        Number of vectors (r) to keep for the future
+        reconstraction of the matrix a, ex.
+        a[m,n]=coef[m,r]*vt[r,n], where
+        coef=u*sigma
+    scalar_double : float
+        Threshold (precision) as a double, default
+        value is 1e-7
+    boolean : bool
+        Apply svd on the initial input data (true) or
+        transposed (square matrix), default
+        value is false
+
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+
+    >>> # Instantiate operator
+    >>> op = dpf.operators.compression.apply_svd()
+
+    >>> # Make input connections
+    >>> my_field_contaner_to_compress = dpf.FieldsContainer()
+    >>> op.inputs.field_contaner_to_compress.connect(my_field_contaner_to_compress)
+    >>> my_scalar_int = int()
+    >>> op.inputs.scalar_int.connect(my_scalar_int)
+    >>> my_scalar_double = float()
+    >>> op.inputs.scalar_double.connect(my_scalar_double)
+    >>> my_boolean = bool()
+    >>> op.inputs.boolean.connect(my_boolean)
+
+    >>> # Instantiate operator and connect inputs in one line
+    >>> op = dpf.operators.compression.apply_svd(
+    ...     field_contaner_to_compress=my_field_contaner_to_compress,
+    ...     scalar_int=my_scalar_int,
+    ...     scalar_double=my_scalar_double,
+    ...     boolean=my_boolean,
+    ... )
+
+    >>> # Get output data
+    >>> result_us_svd = op.outputs.us_svd()
+    >>> result_vt_svd = op.outputs.vt_svd()
+    >>> result_sigma = op.outputs.sigma()
+    """
+
+    def __init__(
+        self,
+        field_contaner_to_compress=None,
+        scalar_int=None,
+        scalar_double=None,
+        boolean=None,
+        config=None,
+        server=None,
+    ):
+        super().__init__(name="svd_operator", config=config, server=server)
+        self._inputs = InputsApplySvd(self)
+        self._outputs = OutputsApplySvd(self)
+        if field_contaner_to_compress is not None:
+            self.inputs.field_contaner_to_compress.connect(field_contaner_to_compress)
+        if scalar_int is not None:
+            self.inputs.scalar_int.connect(scalar_int)
+        if scalar_double is not None:
+            self.inputs.scalar_double.connect(scalar_double)
+        if boolean is not None:
+            self.inputs.boolean.connect(boolean)
+
+    @staticmethod
+    def _spec():
+        description = (
+            """Computes the coefficients (=U*Sigma) and VT components from SVD."""
+        )
+        spec = Specification(
+            description=description,
+            map_input_pin_spec={
+                0: PinSpecification(
+                    name="field_contaner_to_compress",
+                    type_names=["fields_container"],
+                    optional=False,
+                    document="""Fields container to be compressed""",
+                ),
+                1: PinSpecification(
+                    name="scalar_int",
+                    type_names=["int32"],
+                    optional=False,
+                    document="""Number of vectors (r) to keep for the future
+        reconstraction of the matrix a, ex.
+        a[m,n]=coef[m,r]*vt[r,n], where
+        coef=u*sigma""",
+                ),
+                2: PinSpecification(
+                    name="scalar_double",
+                    type_names=["double"],
+                    optional=False,
+                    document="""Threshold (precision) as a double, default
+        value is 1e-7""",
+                ),
+                3: PinSpecification(
+                    name="boolean",
+                    type_names=["bool"],
+                    optional=False,
+                    document="""Apply svd on the initial input data (true) or
+        transposed (square matrix), default
+        value is false""",
+                ),
+            },
+            map_output_pin_spec={
+                0: PinSpecification(
+                    name="us_svd",
+                    type_names=["fields_container"],
+                    optional=False,
+                    document="""The output entity is a field container (time
+        dependant); it contains the
+        multiplication of two matrices, u and
+        s, where a=u.s.vt""",
+                ),
+                1: PinSpecification(
+                    name="vt_svd",
+                    type_names=["fields_container"],
+                    optional=False,
+                    document="""The output entity is a field container (space
+        dependant), containing the vt, where
+        a=u.s.vt""",
+                ),
+                2: PinSpecification(
+                    name="sigma",
+                    type_names=["field"],
+                    optional=False,
+                    document="""The output entity is a field, containing
+        singular (s) values of the input
+        data, where a=u.s.vt""",
+                ),
+            },
+        )
+        return spec
+
+    @staticmethod
+    def default_config(server=None):
+        """Returns the default config of the operator.
+
+        This config can then be changed to the user needs and be used to
+        instantiate the operator. The Configuration allows to customize
+        how the operation will be processed by the operator.
+
+        Parameters
+        ----------
+        server : server.DPFServer, optional
+            Server with channel connected to the remote or local instance. When
+            ``None``, attempts to use the global server.
+        """
+        return Operator.default_config(name="svd_operator", server=server)
+
+    @property
+    def inputs(self):
+        """Enables to connect inputs to the operator
+
+        Returns
+        --------
+        inputs : InputsApplySvd
+        """
+        return super().inputs
+
+    @property
+    def outputs(self):
+        """Enables to get outputs of the operator by evaluating it
+
+        Returns
+        --------
+        outputs : OutputsApplySvd
+        """
+        return super().outputs
+
+
+class InputsApplySvd(_Inputs):
+    """Intermediate class used to connect user inputs to
+    apply_svd operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.compression.apply_svd()
+    >>> my_field_contaner_to_compress = dpf.FieldsContainer()
+    >>> op.inputs.field_contaner_to_compress.connect(my_field_contaner_to_compress)
+    >>> my_scalar_int = int()
+    >>> op.inputs.scalar_int.connect(my_scalar_int)
+    >>> my_scalar_double = float()
+    >>> op.inputs.scalar_double.connect(my_scalar_double)
+    >>> my_boolean = bool()
+    >>> op.inputs.boolean.connect(my_boolean)
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(apply_svd._spec().inputs, op)
+        self._field_contaner_to_compress = Input(
+            apply_svd._spec().input_pin(0), 0, op, -1
+        )
+        self._inputs.append(self._field_contaner_to_compress)
+        self._scalar_int = Input(apply_svd._spec().input_pin(1), 1, op, -1)
+        self._inputs.append(self._scalar_int)
+        self._scalar_double = Input(apply_svd._spec().input_pin(2), 2, op, -1)
+        self._inputs.append(self._scalar_double)
+        self._boolean = Input(apply_svd._spec().input_pin(3), 3, op, -1)
+        self._inputs.append(self._boolean)
+
+    @property
+    def field_contaner_to_compress(self):
+        """Allows to connect field_contaner_to_compress input to the operator.
+
+        Fields container to be compressed
+
+        Parameters
+        ----------
+        my_field_contaner_to_compress : FieldsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.apply_svd()
+        >>> op.inputs.field_contaner_to_compress.connect(my_field_contaner_to_compress)
+        >>> # or
+        >>> op.inputs.field_contaner_to_compress(my_field_contaner_to_compress)
+        """
+        return self._field_contaner_to_compress
+
+    @property
+    def scalar_int(self):
+        """Allows to connect scalar_int input to the operator.
+
+        Number of vectors (r) to keep for the future
+        reconstraction of the matrix a, ex.
+        a[m,n]=coef[m,r]*vt[r,n], where
+        coef=u*sigma
+
+        Parameters
+        ----------
+        my_scalar_int : int
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.apply_svd()
+        >>> op.inputs.scalar_int.connect(my_scalar_int)
+        >>> # or
+        >>> op.inputs.scalar_int(my_scalar_int)
+        """
+        return self._scalar_int
+
+    @property
+    def scalar_double(self):
+        """Allows to connect scalar_double input to the operator.
+
+        Threshold (precision) as a double, default
+        value is 1e-7
+
+        Parameters
+        ----------
+        my_scalar_double : float
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.apply_svd()
+        >>> op.inputs.scalar_double.connect(my_scalar_double)
+        >>> # or
+        >>> op.inputs.scalar_double(my_scalar_double)
+        """
+        return self._scalar_double
+
+    @property
+    def boolean(self):
+        """Allows to connect boolean input to the operator.
+
+        Apply svd on the initial input data (true) or
+        transposed (square matrix), default
+        value is false
+
+        Parameters
+        ----------
+        my_boolean : bool
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.apply_svd()
+        >>> op.inputs.boolean.connect(my_boolean)
+        >>> # or
+        >>> op.inputs.boolean(my_boolean)
+        """
+        return self._boolean
+
+
+class OutputsApplySvd(_Outputs):
+    """Intermediate class used to get outputs from
+    apply_svd operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.compression.apply_svd()
+    >>> # Connect inputs : op.inputs. ...
+    >>> result_us_svd = op.outputs.us_svd()
+    >>> result_vt_svd = op.outputs.vt_svd()
+    >>> result_sigma = op.outputs.sigma()
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(apply_svd._spec().outputs, op)
+        self._us_svd = Output(apply_svd._spec().output_pin(0), 0, op)
+        self._outputs.append(self._us_svd)
+        self._vt_svd = Output(apply_svd._spec().output_pin(1), 1, op)
+        self._outputs.append(self._vt_svd)
+        self._sigma = Output(apply_svd._spec().output_pin(2), 2, op)
+        self._outputs.append(self._sigma)
+
+    @property
+    def us_svd(self):
+        """Allows to get us_svd output of the operator
+
+        Returns
+        ----------
+        my_us_svd : FieldsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.apply_svd()
+        >>> # Connect inputs : op.inputs. ...
+        >>> result_us_svd = op.outputs.us_svd()
+        """  # noqa: E501
+        return self._us_svd
+
+    @property
+    def vt_svd(self):
+        """Allows to get vt_svd output of the operator
+
+        Returns
+        ----------
+        my_vt_svd : FieldsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.apply_svd()
+        >>> # Connect inputs : op.inputs. ...
+        >>> result_vt_svd = op.outputs.vt_svd()
+        """  # noqa: E501
+        return self._vt_svd
+
+    @property
+    def sigma(self):
+        """Allows to get sigma output of the operator
+
+        Returns
+        ----------
+        my_sigma : Field
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.apply_svd()
+        >>> # Connect inputs : op.inputs. ...
+        >>> result_sigma = op.outputs.sigma()
+        """  # noqa: E501
+        return self._sigma