update generated code

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

@@ -10,6 +10,7 @@
 from .elemental_to_elemental_nodal import elemental_to_elemental_nodal
 from .elemental_to_elemental_nodal_fc import elemental_to_elemental_nodal_fc
 from .elemental_to_nodal import elemental_to_nodal
+from .elemental_to_nodal_fc import elemental_to_nodal_fc
 from .extend_to_mid_nodes import extend_to_mid_nodes
 from .extend_to_mid_nodes_fc import extend_to_mid_nodes_fc
 from .force_summation import force_summation
@@ -20,5 +21,6 @@
 from .nodal_to_elemental import nodal_to_elemental
 from .nodal_to_elemental_fc import nodal_to_elemental_fc
 from .to_elemental_fc import to_elemental_fc
+from .to_elemental_nodal_fc import to_elemental_nodal_fc
 from .to_nodal import to_nodal
 from .to_nodal_fc import to_nodal_fc

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

@@ -0,0 +1,377 @@
+"""
+elemental_to_nodal_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 elemental_to_nodal_fc(Operator):
+    """Transforms Elemental Nodal fields to Nodal fields. The result is
+    computed on a given node's scoping.1. For a finite element mesh,
+    the value on a node is the average of the values of the neighbour
+    elements.  2. For a finite volume mesh, the agorithm is :    - For
+    each node, compute interpolation weights for the cells connected
+    to it based   on the Frink's Laplacian method.         - If the
+    determinant of the I matrix is zero, switch to an inverse distance
+    weighted average.         - If not, compute the Frink weights and
+    apply the Holmes' weight clip.         - If the clipping produces
+    a large overshoot, inverse volume weighted average is used.. 3.
+    For a face finite volume mesh inverse distance weighted average is
+    used.
+
+    Parameters
+    ----------
+    fields_container : FieldsContainer
+    mesh : MeshedRegion or MeshesContainer, optional
+    force_averaging : int, optional
+        Averaging on nodes is used if this pin is set
+        to 1 (default is 1 for integrated
+        results and 0 for discrete ones).
+    mesh_scoping : Scoping or ScopingsContainer, optional
+    algorithm : int, optional
+        Forces the usage of algorithm 1, 2 or 3
+        (default is chosen based on the type
+        of mesh).
+
+    Returns
+    -------
+    fields_container : FieldsContainer
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+
+    >>> # Instantiate operator
+    >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
+
+    >>> # Make input connections
+    >>> my_fields_container = dpf.FieldsContainer()
+    >>> op.inputs.fields_container.connect(my_fields_container)
+    >>> my_mesh = dpf.MeshedRegion()
+    >>> op.inputs.mesh.connect(my_mesh)
+    >>> my_force_averaging = int()
+    >>> op.inputs.force_averaging.connect(my_force_averaging)
+    >>> my_mesh_scoping = dpf.Scoping()
+    >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+    >>> my_algorithm = int()
+    >>> op.inputs.algorithm.connect(my_algorithm)
+
+    >>> # Instantiate operator and connect inputs in one line
+    >>> op = dpf.operators.averaging.elemental_to_nodal_fc(
+    ...     fields_container=my_fields_container,
+    ...     mesh=my_mesh,
+    ...     force_averaging=my_force_averaging,
+    ...     mesh_scoping=my_mesh_scoping,
+    ...     algorithm=my_algorithm,
+    ... )
+
+    >>> # Get output data
+    >>> result_fields_container = op.outputs.fields_container()
+    """
+
+    def __init__(
+        self,
+        fields_container=None,
+        mesh=None,
+        force_averaging=None,
+        mesh_scoping=None,
+        algorithm=None,
+        config=None,
+        server=None,
+    ):
+        super().__init__(name="elemental_to_nodal_fc", config=config, server=server)
+        self._inputs = InputsElementalToNodalFc(self)
+        self._outputs = OutputsElementalToNodalFc(self)
+        if fields_container is not None:
+            self.inputs.fields_container.connect(fields_container)
+        if mesh is not None:
+            self.inputs.mesh.connect(mesh)
+        if force_averaging is not None:
+            self.inputs.force_averaging.connect(force_averaging)
+        if mesh_scoping is not None:
+            self.inputs.mesh_scoping.connect(mesh_scoping)
+        if algorithm is not None:
+            self.inputs.algorithm.connect(algorithm)
+
+    @staticmethod
+    def _spec():
+        description = """Transforms Elemental Nodal fields to Nodal fields. The result is
+            computed on a given node's scoping.1. For a finite element
+            mesh, the value on a node is the average of the values of
+            the neighbour elements.  2. For a finite volume mesh, the
+            agorithm is :    - For each node, compute interpolation
+            weights for the cells connected to it based   on the
+            Frink's Laplacian method.         - If the determinant of
+            the I matrix is zero, switch to an inverse distance
+            weighted average.         - If not, compute the Frink
+            weights and apply the Holmes' weight clip.         - If
+            the clipping produces a large overshoot, inverse volume
+            weighted average is used.. 3. For a face finite volume
+            mesh inverse distance weighted average is used."""
+        spec = Specification(
+            description=description,
+            map_input_pin_spec={
+                0: PinSpecification(
+                    name="fields_container",
+                    type_names=["fields_container"],
+                    optional=False,
+                    document="""""",
+                ),
+                1: PinSpecification(
+                    name="mesh",
+                    type_names=["abstract_meshed_region", "meshes_container"],
+                    optional=True,
+                    document="""""",
+                ),
+                2: PinSpecification(
+                    name="force_averaging",
+                    type_names=["int32"],
+                    optional=True,
+                    document="""Averaging on nodes is used if this pin is set
+        to 1 (default is 1 for integrated
+        results and 0 for discrete ones).""",
+                ),
+                3: PinSpecification(
+                    name="mesh_scoping",
+                    type_names=["scoping", "scopings_container"],
+                    optional=True,
+                    document="""""",
+                ),
+                200: PinSpecification(
+                    name="algorithm",
+                    type_names=["int32"],
+                    optional=True,
+                    document="""Forces the usage of algorithm 1, 2 or 3
+        (default is chosen based on the type
+        of mesh).""",
+                ),
+            },
+            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="elemental_to_nodal_fc", server=server)
+
+    @property
+    def inputs(self):
+        """Enables to connect inputs to the operator
+
+        Returns
+        --------
+        inputs : InputsElementalToNodalFc
+        """
+        return super().inputs
+
+    @property
+    def outputs(self):
+        """Enables to get outputs of the operator by evaluating it
+
+        Returns
+        --------
+        outputs : OutputsElementalToNodalFc
+        """
+        return super().outputs
+
+
+class InputsElementalToNodalFc(_Inputs):
+    """Intermediate class used to connect user inputs to
+    elemental_to_nodal_fc operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
+    >>> my_fields_container = dpf.FieldsContainer()
+    >>> op.inputs.fields_container.connect(my_fields_container)
+    >>> my_mesh = dpf.MeshedRegion()
+    >>> op.inputs.mesh.connect(my_mesh)
+    >>> my_force_averaging = int()
+    >>> op.inputs.force_averaging.connect(my_force_averaging)
+    >>> my_mesh_scoping = dpf.Scoping()
+    >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+    >>> my_algorithm = int()
+    >>> op.inputs.algorithm.connect(my_algorithm)
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(elemental_to_nodal_fc._spec().inputs, op)
+        self._fields_container = Input(
+            elemental_to_nodal_fc._spec().input_pin(0), 0, op, -1
+        )
+        self._inputs.append(self._fields_container)
+        self._mesh = Input(elemental_to_nodal_fc._spec().input_pin(1), 1, op, -1)
+        self._inputs.append(self._mesh)
+        self._force_averaging = Input(
+            elemental_to_nodal_fc._spec().input_pin(2), 2, op, -1
+        )
+        self._inputs.append(self._force_averaging)
+        self._mesh_scoping = Input(
+            elemental_to_nodal_fc._spec().input_pin(3), 3, op, -1
+        )
+        self._inputs.append(self._mesh_scoping)
+        self._algorithm = Input(
+            elemental_to_nodal_fc._spec().input_pin(200), 200, op, -1
+        )
+        self._inputs.append(self._algorithm)
+
+    @property
+    def fields_container(self):
+        """Allows to connect fields_container input to the operator.
+
+        Parameters
+        ----------
+        my_fields_container : FieldsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
+        >>> op.inputs.fields_container.connect(my_fields_container)
+        >>> # or
+        >>> op.inputs.fields_container(my_fields_container)
+        """
+        return self._fields_container
+
+    @property
+    def mesh(self):
+        """Allows to connect mesh input to the operator.
+
+        Parameters
+        ----------
+        my_mesh : MeshedRegion or MeshesContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
+        >>> op.inputs.mesh.connect(my_mesh)
+        >>> # or
+        >>> op.inputs.mesh(my_mesh)
+        """
+        return self._mesh
+
+    @property
+    def force_averaging(self):
+        """Allows to connect force_averaging input to the operator.
+
+        Averaging on nodes is used if this pin is set
+        to 1 (default is 1 for integrated
+        results and 0 for discrete ones).
+
+        Parameters
+        ----------
+        my_force_averaging : int
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
+        >>> op.inputs.force_averaging.connect(my_force_averaging)
+        >>> # or
+        >>> op.inputs.force_averaging(my_force_averaging)
+        """
+        return self._force_averaging
+
+    @property
+    def mesh_scoping(self):
+        """Allows to connect mesh_scoping input to the operator.
+
+        Parameters
+        ----------
+        my_mesh_scoping : Scoping or ScopingsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
+        >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+        >>> # or
+        >>> op.inputs.mesh_scoping(my_mesh_scoping)
+        """
+        return self._mesh_scoping
+
+    @property
+    def algorithm(self):
+        """Allows to connect algorithm input to the operator.
+
+        Forces the usage of algorithm 1, 2 or 3
+        (default is chosen based on the type
+        of mesh).
+
+        Parameters
+        ----------
+        my_algorithm : int
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
+        >>> op.inputs.algorithm.connect(my_algorithm)
+        >>> # or
+        >>> op.inputs.algorithm(my_algorithm)
+        """
+        return self._algorithm
+
+
+class OutputsElementalToNodalFc(_Outputs):
+    """Intermediate class used to get outputs from
+    elemental_to_nodal_fc operator.
+
+    Examples
+    --------
+    >>> from ansys.dpf import core as dpf
+    >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
+    >>> # Connect inputs : op.inputs. ...
+    >>> result_fields_container = op.outputs.fields_container()
+    """
+
+    def __init__(self, op: Operator):
+        super().__init__(elemental_to_nodal_fc._spec().outputs, op)
+        self._fields_container = Output(
+            elemental_to_nodal_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.averaging.elemental_to_nodal_fc()
+        >>> # Connect inputs : op.inputs. ...
+        >>> result_fields_container = op.outputs.fields_container()
+        """  # noqa: E501
+        return self._fields_container