update operators (#916)

Co-authored-by: PProfizi <[email protected]>

Author: github-actions[bot]

docs/source/_static/dpf_operators.html

@@ -173,7 +173,9 @@ def _spec():
                 ),
                 1: PinSpecification(
                     name="weights",
-                    type_names=["class dataProcessing::CPropertyFieldsContainer"],
+                    type_names=[
+                        "class dataProcessing::DpfTypeCollection<class dataProcessing::CPropertyField>"
+                    ],
                     optional=False,
                     document="""Gives for each node, the number of times it
         was found in the elemental nodal

src/ansys/dpf/core/operators/averaging/elemental_nodal_to_nodal_fc.py

@@ -4,12 +4,12 @@
 from .component_selector import component_selector 
 from .identical_property_fields import identical_property_fields 
 from .component_transformer_fc import component_transformer_fc 
+from .enrich_materials import enrich_materials 
 from .solid_shell_fields import solid_shell_fields 
 from .identical_meshes import identical_meshes 
 from .identical_fields import identical_fields 
 from .included_fields import included_fields 
 from .identical_fc import identical_fc 
-from .enrich_materials import enrich_materials 
 from .descending_sort import descending_sort 
 from .ascending_sort_fc import ascending_sort_fc 
 from .descending_sort_fc import descending_sort_fc 

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

@@ -3,4 +3,5 @@
 from .find_reduced_coordinates import find_reduced_coordinates 
 from .on_reduced_coordinates import on_reduced_coordinates 
 from .on_coordinates import on_coordinates 
+from .solid_to_skin_fc import solid_to_skin_fc 
 from .prepare_mapping_workflow import prepare_mapping_workflow 

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

@@ -0,0 +1,224 @@
+"""
+solid_to_skin_fc
+================
+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 solid_to_skin_fc(Operator):
+    """Maps a field defined on solid elements to a field defined on skin
+    elements.
+
+    Parameters
+    ----------
+    fields_container : FieldsContainer
+        Field or fields container with only one field
+        is expected
+    mesh_scoping : MeshedRegion, optional
+        Skin mesh region expected
+
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+
+    >>> # Instantiate operator
+    >>> op = dpf.operators.mapping.solid_to_skin_fc()
+
+    >>> # Make input connections
+    >>> my_fields_container = dpf.FieldsContainer()
+    >>> op.inputs.fields_container.connect(my_fields_container)
+    >>> my_mesh_scoping = dpf.MeshedRegion()
+    >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+
+    >>> # Instantiate operator and connect inputs in one line
+    >>> op = dpf.operators.mapping.solid_to_skin_fc(
+    ...     fields_container=my_fields_container,
+    ...     mesh_scoping=my_mesh_scoping,
+    ... )
+
+    >>> # Get output data
+    >>> result_fields_container = op.outputs.fields_container()
+    """
+
+    def __init__(
+        self, fields_container=None, mesh_scoping=None, config=None, server=None
+    ):
+        super().__init__(name="solid_to_skin_fc", config=config, server=server)
+        self._inputs = InputsSolidToSkinFc(self)
+        self._outputs = OutputsSolidToSkinFc(self)
+        if fields_container is not None:
+            self.inputs.fields_container.connect(fields_container)
+        if mesh_scoping is not None:
+            self.inputs.mesh_scoping.connect(mesh_scoping)
+
+    @staticmethod
+    def _spec():
+        description = """Maps a field defined on solid elements to a field defined on skin
+            elements."""
+        spec = Specification(
+            description=description,
+            map_input_pin_spec={
+                0: PinSpecification(
+                    name="fields_container",
+                    type_names=["fields_container"],
+                    optional=False,
+                    document="""Field or fields container with only one field
+        is expected""",
+                ),
+                1: PinSpecification(
+                    name="mesh_scoping",
+                    type_names=["abstract_meshed_region"],
+                    optional=True,
+                    document="""Skin mesh region expected""",
+                ),
+            },
+            map_output_pin_spec={
+                0: PinSpecification(
+                    name="fields_container",
+                    type_names=["fields_container"],
+                    optional=False,
+                    document="""""",
+                ),
+            },
+        )
+        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="solid_to_skin_fc", server=server)
+
+    @property
+    def inputs(self):
+        """Enables to connect inputs to the operator
+
+        Returns
+        --------
+        inputs : InputsSolidToSkinFc
+        """
+        return super().inputs
+
+    @property
+    def outputs(self):
+        """Enables to get outputs of the operator by evaluationg it
+
+        Returns
+        --------
+        outputs : OutputsSolidToSkinFc
+        """
+        return super().outputs
+
+
+class InputsSolidToSkinFc(_Inputs):
+    """Intermediate class used to connect user inputs to
+    solid_to_skin_fc operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.mapping.solid_to_skin_fc()
+    >>> my_fields_container = dpf.FieldsContainer()
+    >>> op.inputs.fields_container.connect(my_fields_container)
+    >>> my_mesh_scoping = dpf.MeshedRegion()
+    >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(solid_to_skin_fc._spec().inputs, op)
+        self._fields_container = Input(solid_to_skin_fc._spec().input_pin(0), 0, op, -1)
+        self._inputs.append(self._fields_container)
+        self._mesh_scoping = Input(solid_to_skin_fc._spec().input_pin(1), 1, op, -1)
+        self._inputs.append(self._mesh_scoping)
+
+    @property
+    def fields_container(self):
+        """Allows to connect fields_container input to the operator.
+
+        Field or fields container with only one field
+        is expected
+
+        Parameters
+        ----------
+        my_fields_container : FieldsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.mapping.solid_to_skin_fc()
+        >>> op.inputs.fields_container.connect(my_fields_container)
+        >>> # or
+        >>> op.inputs.fields_container(my_fields_container)
+        """
+        return self._fields_container
+
+    @property
+    def mesh_scoping(self):
+        """Allows to connect mesh_scoping input to the operator.
+
+        Skin mesh region expected
+
+        Parameters
+        ----------
+        my_mesh_scoping : MeshedRegion
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.mapping.solid_to_skin_fc()
+        >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+        >>> # or
+        >>> op.inputs.mesh_scoping(my_mesh_scoping)
+        """
+        return self._mesh_scoping
+
+
+class OutputsSolidToSkinFc(_Outputs):
+    """Intermediate class used to get outputs from
+    solid_to_skin_fc operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.mapping.solid_to_skin_fc()
+    >>> # Connect inputs : op.inputs. ...
+    >>> result_fields_container = op.outputs.fields_container()
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(solid_to_skin_fc._spec().outputs, op)
+        self._fields_container = Output(solid_to_skin_fc._spec().output_pin(0), 0, op)
+        self._outputs.append(self._fields_container)
+
+    @property
+    def fields_container(self):
+        """Allows to get fields_container output of the operator
+
+        Returns
+        ----------
+        my_fields_container : FieldsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.mapping.solid_to_skin_fc()
+        >>> # Connect inputs : op.inputs. ...
+        >>> result_fields_container = op.outputs.fields_container()
+        """  # noqa: E501
+        return self._fields_container

src/ansys/dpf/core/operators/mapping/solid_to_skin_fc.py

@@ -11,8 +11,8 @@
 
 
 class svd(Operator):
-    """Computes the complex matrix singular value decomposition (SVD) for
-    each field in the given fields container.
+    """Computes the matrix singular value decomposition (SVD) for each field
+    in the given fields container.
 
     Parameters
     ----------
@@ -37,7 +37,9 @@ class svd(Operator):
     ... )
 
     >>> # Get output data
-    >>> result_fields_container = op.outputs.fields_container()
+    >>> result_s_svd = op.outputs.s_svd()
+    >>> result_u_svd = op.outputs.u_svd()
+    >>> result_vt_svd = op.outputs.vt_svd()
     """
 
     def __init__(self, fields_container=None, config=None, server=None):
@@ -49,8 +51,8 @@ def __init__(self, fields_container=None, config=None, server=None):
 
     @staticmethod
     def _spec():
-        description = """Computes the complex matrix singular value decomposition (SVD) for
-            each field in the given fields container."""
+        description = """Computes the matrix singular value decomposition (SVD) for each field
+            in the given fields container."""
         spec = Specification(
             description=description,
             map_input_pin_spec={
@@ -63,10 +65,23 @@ def _spec():
             },
             map_output_pin_spec={
                 0: PinSpecification(
-                    name="fields_container",
+                    name="s_svd",
                     type_names=["fields_container"],
                     optional=False,
-                    document="""""",
+                    document="""Singular values of the input data, where
+        a=u.s.vt""",
+                ),
+                1: PinSpecification(
+                    name="u_svd",
+                    type_names=["fields_container"],
+                    optional=False,
+                    document="""U of the input data, where a=u.s.vt""",
+                ),
+                2: PinSpecification(
+                    name="vt_svd",
+                    type_names=["fields_container"],
+                    optional=False,
+                    document="""Vt of the input data, where a=u.s.vt""",
                 ),
             },
         )
@@ -156,27 +171,67 @@ class OutputsSvd(_Outputs):
     >>> from ansys.dpf import core as dpf
     >>> op = dpf.operators.math.svd()
     >>> # Connect inputs : op.inputs. ...
-    >>> result_fields_container = op.outputs.fields_container()
+    >>> result_s_svd = op.outputs.s_svd()
+    >>> result_u_svd = op.outputs.u_svd()
+    >>> result_vt_svd = op.outputs.vt_svd()
     """
 
     def __init__(self, op: Operator):
         super().__init__(svd._spec().outputs, op)
-        self._fields_container = Output(svd._spec().output_pin(0), 0, op)
-        self._outputs.append(self._fields_container)
+        self._s_svd = Output(svd._spec().output_pin(0), 0, op)
+        self._outputs.append(self._s_svd)
+        self._u_svd = Output(svd._spec().output_pin(1), 1, op)
+        self._outputs.append(self._u_svd)
+        self._vt_svd = Output(svd._spec().output_pin(2), 2, op)
+        self._outputs.append(self._vt_svd)
 
     @property
-    def fields_container(self):
-        """Allows to get fields_container output of the operator
+    def s_svd(self):
+        """Allows to get s_svd output of the operator
 
         Returns
         ----------
-        my_fields_container : FieldsContainer
+        my_s_svd : FieldsContainer
 
         Examples
         --------
         >>> from ansys.dpf import core as dpf
         >>> op = dpf.operators.math.svd()
         >>> # Connect inputs : op.inputs. ...
-        >>> result_fields_container = op.outputs.fields_container()
+        >>> result_s_svd = op.outputs.s_svd()
         """  # noqa: E501
-        return self._fields_container
+        return self._s_svd
+
+    @property
+    def u_svd(self):
+        """Allows to get u_svd output of the operator
+
+        Returns
+        ----------
+        my_u_svd : FieldsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.math.svd()
+        >>> # Connect inputs : op.inputs. ...
+        >>> result_u_svd = op.outputs.u_svd()
+        """  # noqa: E501
+        return self._u_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.math.svd()
+        >>> # Connect inputs : op.inputs. ...
+        >>> result_vt_svd = op.outputs.vt_svd()
+        """  # noqa: E501
+        return self._vt_svd