Update generated code for DPF 261_daily on main

src/ansys/dpf/core/operators/compression/__init__.py

@@ -1,4 +1,6 @@
 from .apply_svd import apply_svd
 from .apply_zfp import apply_zfp
 from .kmeans_clustering import kmeans_clustering
+from .quantization import quantization
+from .quantization_fc import quantization_fc
 from .zfp_decompress import zfp_decompress

src/ansys/dpf/core/operators/compression/quantization.py

@@ -0,0 +1,242 @@
+"""
+quantization
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+
+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
+from ansys.dpf.core.config import Config
+from ansys.dpf.core.server_types import AnyServerType
+
+
+class quantization(Operator):
+    r"""Applies scaling to precision to all the values from field input, then
+    rounding to the unit.
+
+
+    Parameters
+    ----------
+    input_field: Field
+        Input field
+    threshold: float
+        Threshold (precision) desired.
+
+    Returns
+    -------
+    output_field: Field
+        Scaled and rounded field
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+
+    >>> # Instantiate operator
+    >>> op = dpf.operators.compression.quantization()
+
+    >>> # Make input connections
+    >>> my_input_field = dpf.Field()
+    >>> op.inputs.input_field.connect(my_input_field)
+    >>> my_threshold = float()
+    >>> op.inputs.threshold.connect(my_threshold)
+
+    >>> # Instantiate operator and connect inputs in one line
+    >>> op = dpf.operators.compression.quantization(
+    ...     input_field=my_input_field,
+    ...     threshold=my_threshold,
+    ... )
+
+    >>> # Get output data
+    >>> result_output_field = op.outputs.output_field()
+    """
+
+    def __init__(self, input_field=None, threshold=None, config=None, server=None):
+        super().__init__(name="quantization", config=config, server=server)
+        self._inputs = InputsQuantization(self)
+        self._outputs = OutputsQuantization(self)
+        if input_field is not None:
+            self.inputs.input_field.connect(input_field)
+        if threshold is not None:
+            self.inputs.threshold.connect(threshold)
+
+    @staticmethod
+    def _spec() -> Specification:
+        description = r"""Applies scaling to precision to all the values from field input, then
+rounding to the unit.
+"""
+        spec = Specification(
+            description=description,
+            map_input_pin_spec={
+                0: PinSpecification(
+                    name="input_field",
+                    type_names=["field"],
+                    optional=False,
+                    document=r"""Input field""",
+                ),
+                1: PinSpecification(
+                    name="threshold",
+                    type_names=["double"],
+                    optional=False,
+                    document=r"""Threshold (precision) desired.""",
+                ),
+            },
+            map_output_pin_spec={
+                0: PinSpecification(
+                    name="output_field",
+                    type_names=["field"],
+                    optional=False,
+                    document=r"""Scaled and rounded field""",
+                ),
+            },
+        )
+        return spec
+
+    @staticmethod
+    def default_config(server: AnyServerType = None) -> Config:
+        """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 with channel connected to the remote or local instance. When
+            ``None``, attempts to use the global server.
+
+        Returns
+        -------
+        config:
+            A new Config instance equivalent to the default config for this operator.
+        """
+        return Operator.default_config(name="quantization", server=server)
+
+    @property
+    def inputs(self) -> InputsQuantization:
+        """Enables to connect inputs to the operator
+
+        Returns
+        --------
+        inputs:
+            An instance of InputsQuantization.
+        """
+        return super().inputs
+
+    @property
+    def outputs(self) -> OutputsQuantization:
+        """Enables to get outputs of the operator by evaluating it
+
+        Returns
+        --------
+        outputs:
+            An instance of OutputsQuantization.
+        """
+        return super().outputs
+
+
+class InputsQuantization(_Inputs):
+    """Intermediate class used to connect user inputs to
+    quantization operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.compression.quantization()
+    >>> my_input_field = dpf.Field()
+    >>> op.inputs.input_field.connect(my_input_field)
+    >>> my_threshold = float()
+    >>> op.inputs.threshold.connect(my_threshold)
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(quantization._spec().inputs, op)
+        self._input_field = Input(quantization._spec().input_pin(0), 0, op, -1)
+        self._inputs.append(self._input_field)
+        self._threshold = Input(quantization._spec().input_pin(1), 1, op, -1)
+        self._inputs.append(self._threshold)
+
+    @property
+    def input_field(self) -> Input:
+        r"""Allows to connect input_field input to the operator.
+
+        Input field
+
+        Returns
+        -------
+        input:
+            An Input instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.quantization()
+        >>> op.inputs.input_field.connect(my_input_field)
+        >>> # or
+        >>> op.inputs.input_field(my_input_field)
+        """
+        return self._input_field
+
+    @property
+    def threshold(self) -> Input:
+        r"""Allows to connect threshold input to the operator.
+
+        Threshold (precision) desired.
+
+        Returns
+        -------
+        input:
+            An Input instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.quantization()
+        >>> op.inputs.threshold.connect(my_threshold)
+        >>> # or
+        >>> op.inputs.threshold(my_threshold)
+        """
+        return self._threshold
+
+
+class OutputsQuantization(_Outputs):
+    """Intermediate class used to get outputs from
+    quantization operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.compression.quantization()
+    >>> # Connect inputs : op.inputs. ...
+    >>> result_output_field = op.outputs.output_field()
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(quantization._spec().outputs, op)
+        self._output_field = Output(quantization._spec().output_pin(0), 0, op)
+        self._outputs.append(self._output_field)
+
+    @property
+    def output_field(self) -> Output:
+        r"""Allows to get output_field output of the operator
+
+        Scaled and rounded field
+
+        Returns
+        -------
+        output:
+            An Output instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.compression.quantization()
+        >>> # Get the output from op.outputs. ...
+        >>> result_output_field = op.outputs.output_field()
+        """
+        return self._output_field