Update generated code for DPF 261_test_mnale_solid_to_skin on main

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

@@ -7,6 +7,8 @@
 from .change_location import change_location
 from .change_shell_layers import change_shell_layers
 from .compute_time_scoping import compute_time_scoping
+from .concatenate_fields import concatenate_fields
+from .concatenate_fields_containers import concatenate_fields_containers
 from .customtypefield_get_attribute import customtypefield_get_attribute
 from .cyclic_support_get_attribute import cyclic_support_get_attribute
 from .default_value import default_value

src/ansys/dpf/core/operators/utility/concatenate_fields.py

@@ -0,0 +1,390 @@
+"""
+concatenate_fields
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+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
+
+if TYPE_CHECKING:
+    from ansys.dpf.core.field import Field
+
+
+class concatenate_fields(Operator):
+    r"""Concatenates fields into a unique one by incrementing the number of
+    components.
+
+    Example: - Field1 components: { UX, UY, UZ } - Field2 components: { RX,
+    RY, RZ } - Output field : { UX, UY, UZ, RX, RY, RZ }
+
+
+    Inputs
+    ------
+    rescoping_value: float, optional
+        Value used to fill the missing values when scopings are different. Default is 0.
+    reference_scoping_index: int, optional
+        Pin of the field of which to take the scoping for the output field.
+        If -1 all scopings will be merged, if -2 all scopings will be intersected. Default is -1
+    field_support: AbstractFieldSupport, optional
+        Support of the output field.
+    fields1:
+        A vector of fields to merge from pin 0 to ...
+    fields2:
+        A vector of fields to merge from pin 0 to ...
+
+    Outputs
+    -------
+    merged_fields: Field
+        Field which has as many components as the sum of all the input fields' numbers of components.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+
+    >>> # Instantiate operator
+    >>> op = dpf.operators.utility.concatenate_fields()
+
+    >>> # Make input connections
+    >>> my_rescoping_value = float()
+    >>> op.inputs.rescoping_value.connect(my_rescoping_value)
+    >>> my_reference_scoping_index = int()
+    >>> op.inputs.reference_scoping_index.connect(my_reference_scoping_index)
+    >>> my_field_support = dpf.AbstractFieldSupport()
+    >>> op.inputs.field_support.connect(my_field_support)
+    >>> my_fields1 = dpf.()
+    >>> op.inputs.fields1.connect(my_fields1)
+    >>> my_fields2 = dpf.()
+    >>> op.inputs.fields2.connect(my_fields2)
+
+    >>> # Instantiate operator and connect inputs in one line
+    >>> op = dpf.operators.utility.concatenate_fields(
+    ...     rescoping_value=my_rescoping_value,
+    ...     reference_scoping_index=my_reference_scoping_index,
+    ...     field_support=my_field_support,
+    ...     fields1=my_fields1,
+    ...     fields2=my_fields2,
+    ... )
+
+    >>> # Get output data
+    >>> result_merged_fields = op.outputs.merged_fields()
+    """
+
+    def __init__(
+        self,
+        rescoping_value=None,
+        reference_scoping_index=None,
+        field_support=None,
+        fields1=None,
+        fields2=None,
+        config=None,
+        server=None,
+    ):
+        super().__init__(
+            name="merge::concatenate_fields",
+            config=config,
+            server=server,
+            inputs_type=InputsConcatenateFields,
+            outputs_type=OutputsConcatenateFields,
+        )
+        if rescoping_value is not None:
+            self.inputs.rescoping_value.connect(rescoping_value)
+        if reference_scoping_index is not None:
+            self.inputs.reference_scoping_index.connect(reference_scoping_index)
+        if field_support is not None:
+            self.inputs.field_support.connect(field_support)
+        if fields1 is not None:
+            self.inputs.fields1.connect(fields1)
+        if fields2 is not None:
+            self.inputs.fields2.connect(fields2)
+
+    @staticmethod
+    def _spec() -> Specification:
+        description = r"""Concatenates fields into a unique one by incrementing the number of
+components.
+
+Example: - Field1 components: { UX, UY, UZ } - Field2 components: { RX,
+RY, RZ } - Output field : { UX, UY, UZ, RX, RY, RZ }
+"""
+        spec = Specification(
+            description=description,
+            map_input_pin_spec={
+                -3: PinSpecification(
+                    name="rescoping_value",
+                    type_names=["double"],
+                    optional=True,
+                    document=r"""Value used to fill the missing values when scopings are different. Default is 0.""",
+                ),
+                -2: PinSpecification(
+                    name="reference_scoping_index",
+                    type_names=["int32"],
+                    optional=True,
+                    document=r"""Pin of the field of which to take the scoping for the output field.
+If -1 all scopings will be merged, if -2 all scopings will be intersected. Default is -1""",
+                ),
+                -1: PinSpecification(
+                    name="field_support",
+                    type_names=["abstract_field_support"],
+                    optional=True,
+                    document=r"""Support of the output field.""",
+                ),
+                0: PinSpecification(
+                    name="fields",
+                    type_names=["any"],
+                    optional=False,
+                    document=r"""A vector of fields to merge from pin 0 to ...""",
+                ),
+                1: PinSpecification(
+                    name="fields",
+                    type_names=["any"],
+                    optional=False,
+                    document=r"""A vector of fields to merge from pin 0 to ...""",
+                ),
+            },
+            map_output_pin_spec={
+                0: PinSpecification(
+                    name="merged_fields",
+                    type_names=["field"],
+                    optional=False,
+                    document=r"""Field which has as many components as the sum of all the input fields' numbers of components.""",
+                ),
+            },
+        )
+        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="merge::concatenate_fields", server=server)
+
+    @property
+    def inputs(self) -> InputsConcatenateFields:
+        """Enables to connect inputs to the operator
+
+        Returns
+        --------
+        inputs:
+            An instance of InputsConcatenateFields.
+        """
+        return self._inputs
+
+    @property
+    def outputs(self) -> OutputsConcatenateFields:
+        """Enables to get outputs of the operator by evaluating it
+
+        Returns
+        --------
+        outputs:
+            An instance of OutputsConcatenateFields.
+        """
+        return self._outputs
+
+
+class InputsConcatenateFields(_Inputs):
+    """Intermediate class used to connect user inputs to
+    concatenate_fields operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.utility.concatenate_fields()
+    >>> my_rescoping_value = float()
+    >>> op.inputs.rescoping_value.connect(my_rescoping_value)
+    >>> my_reference_scoping_index = int()
+    >>> op.inputs.reference_scoping_index.connect(my_reference_scoping_index)
+    >>> my_field_support = dpf.AbstractFieldSupport()
+    >>> op.inputs.field_support.connect(my_field_support)
+    >>> my_fields1 = dpf.()
+    >>> op.inputs.fields1.connect(my_fields1)
+    >>> my_fields2 = dpf.()
+    >>> op.inputs.fields2.connect(my_fields2)
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(concatenate_fields._spec().inputs, op)
+        self._rescoping_value: Input[float] = Input(
+            concatenate_fields._spec().input_pin(-3), -3, op, -1
+        )
+        self._inputs.append(self._rescoping_value)
+        self._reference_scoping_index: Input[int] = Input(
+            concatenate_fields._spec().input_pin(-2), -2, op, -1
+        )
+        self._inputs.append(self._reference_scoping_index)
+        self._field_support: Input = Input(
+            concatenate_fields._spec().input_pin(-1), -1, op, -1
+        )
+        self._inputs.append(self._field_support)
+        self._fields1: Input = Input(concatenate_fields._spec().input_pin(0), 0, op, 0)
+        self._inputs.append(self._fields1)
+        self._fields2: Input = Input(concatenate_fields._spec().input_pin(1), 1, op, 1)
+        self._inputs.append(self._fields2)
+
+    @property
+    def rescoping_value(self) -> Input[float]:
+        r"""Allows to connect rescoping_value input to the operator.
+
+        Value used to fill the missing values when scopings are different. Default is 0.
+
+        Returns
+        -------
+        input:
+            An Input instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.utility.concatenate_fields()
+        >>> op.inputs.rescoping_value.connect(my_rescoping_value)
+        >>> # or
+        >>> op.inputs.rescoping_value(my_rescoping_value)
+        """
+        return self._rescoping_value
+
+    @property
+    def reference_scoping_index(self) -> Input[int]:
+        r"""Allows to connect reference_scoping_index input to the operator.
+
+        Pin of the field of which to take the scoping for the output field.
+        If -1 all scopings will be merged, if -2 all scopings will be intersected. Default is -1
+
+        Returns
+        -------
+        input:
+            An Input instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.utility.concatenate_fields()
+        >>> op.inputs.reference_scoping_index.connect(my_reference_scoping_index)
+        >>> # or
+        >>> op.inputs.reference_scoping_index(my_reference_scoping_index)
+        """
+        return self._reference_scoping_index
+
+    @property
+    def field_support(self) -> Input:
+        r"""Allows to connect field_support input to the operator.
+
+        Support of the output field.
+
+        Returns
+        -------
+        input:
+            An Input instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.utility.concatenate_fields()
+        >>> op.inputs.field_support.connect(my_field_support)
+        >>> # or
+        >>> op.inputs.field_support(my_field_support)
+        """
+        return self._field_support
+
+    @property
+    def fields1(self) -> Input:
+        r"""Allows to connect fields1 input to the operator.
+
+        A vector of fields to merge from pin 0 to ...
+
+        Returns
+        -------
+        input:
+            An Input instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.utility.concatenate_fields()
+        >>> op.inputs.fields1.connect(my_fields1)
+        >>> # or
+        >>> op.inputs.fields1(my_fields1)
+        """
+        return self._fields1
+
+    @property
+    def fields2(self) -> Input:
+        r"""Allows to connect fields2 input to the operator.
+
+        A vector of fields to merge from pin 0 to ...
+
+        Returns
+        -------
+        input:
+            An Input instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.utility.concatenate_fields()
+        >>> op.inputs.fields2.connect(my_fields2)
+        >>> # or
+        >>> op.inputs.fields2(my_fields2)
+        """
+        return self._fields2
+
+
+class OutputsConcatenateFields(_Outputs):
+    """Intermediate class used to get outputs from
+    concatenate_fields operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.utility.concatenate_fields()
+    >>> # Connect inputs : op.inputs. ...
+    >>> result_merged_fields = op.outputs.merged_fields()
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(concatenate_fields._spec().outputs, op)
+        self._merged_fields: Output[Field] = Output(
+            concatenate_fields._spec().output_pin(0), 0, op
+        )
+        self._outputs.append(self._merged_fields)
+
+    @property
+    def merged_fields(self) -> Output[Field]:
+        r"""Allows to get merged_fields output of the operator
+
+        Field which has as many components as the sum of all the input fields' numbers of components.
+
+        Returns
+        -------
+        output:
+            An Output instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.utility.concatenate_fields()
+        >>> # Get the output from op.outputs. ...
+        >>> result_merged_fields = op.outputs.merged_fields()
+        """
+        return self._merged_fields