Merged PR 328554: Add Example for distributed averaging

![image.png](https://tfs.ansys.com:8443/tfs/ANSYS_Development/b301e85b-3c3f-4e72-a514-819567f03273/_apis/git/repositories/fd1f4a58-0e9c-400f-9239-5de269689350/pullRequests/328554/attachments/image.png)

Related work items: #672579

Author: cbellot000

ansys/dpf/core/operators/__init__.py

@@ -3,11 +3,11 @@
 from . import utility
 from . import min_max
 from . import scoping
-from . import metadata
 from . import logic
+from . import metadata
+from . import serialization
 from . import mesh
 from . import filter
-from . import serialization
 from . import geo
 from . import averaging
 from . import invariant

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

@@ -13,6 +13,7 @@
 from .elemental_fraction_fc import elemental_fraction_fc 
 from .to_nodal import to_nodal 
 from .to_nodal_fc import to_nodal_fc 
+from .nodal_extend_to_mid_nodes import nodal_extend_to_mid_nodes 
 from .elemental_nodal_to_nodal_elemental import elemental_nodal_to_nodal_elemental 
 from .extend_to_mid_nodes import extend_to_mid_nodes 
 from .extend_to_mid_nodes_fc import extend_to_mid_nodes_fc 

ansys/dpf/core/operators/averaging/elemental_nodal_to_nodal.py

@@ -25,6 +25,9 @@ class elemental_nodal_to_nodal(Operator):
         Each nodal value is divided by the number of
         elements linked to this node (default
         is true for discrete quantities)
+    extend_to_mid_nodes : bool, optional
+        Compute mid nodes (when available) by
+        averaging neighbour primary nodes
     mesh : MeshedRegion, optional
 
 
@@ -42,6 +45,8 @@ class elemental_nodal_to_nodal(Operator):
     >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
     >>> my_should_average = bool()
     >>> op.inputs.should_average.connect(my_should_average)
+    >>> my_extend_to_mid_nodes = bool()
+    >>> op.inputs.extend_to_mid_nodes.connect(my_extend_to_mid_nodes)
     >>> my_mesh = dpf.MeshedRegion()
     >>> op.inputs.mesh.connect(my_mesh)
 
@@ -50,18 +55,21 @@ class elemental_nodal_to_nodal(Operator):
     ...     field=my_field,
     ...     mesh_scoping=my_mesh_scoping,
     ...     should_average=my_should_average,
+    ...     extend_to_mid_nodes=my_extend_to_mid_nodes,
     ...     mesh=my_mesh,
     ... )
 
     >>> # Get output data
     >>> result_field = op.outputs.field()
+    >>> result_weight = op.outputs.weight()
     """
 
     def __init__(
         self,
         field=None,
         mesh_scoping=None,
         should_average=None,
+        extend_to_mid_nodes=None,
         mesh=None,
         config=None,
         server=None,
@@ -75,6 +83,8 @@ def __init__(
             self.inputs.mesh_scoping.connect(mesh_scoping)
         if should_average is not None:
             self.inputs.should_average.connect(should_average)
+        if extend_to_mid_nodes is not None:
+            self.inputs.extend_to_mid_nodes.connect(extend_to_mid_nodes)
         if mesh is not None:
             self.inputs.mesh.connect(mesh)
 
@@ -105,6 +115,13 @@ def _spec():
                     document="""Each nodal value is divided by the number of
         elements linked to this node (default
         is true for discrete quantities)""",
+                ),
+                4: PinSpecification(
+                    name="extend_to_mid_nodes",
+                    type_names=["bool"],
+                    optional=True,
+                    document="""Compute mid nodes (when available) by
+        averaging neighbour primary nodes""",
                 ),
                 7: PinSpecification(
                     name="mesh",
@@ -120,6 +137,14 @@ def _spec():
                     optional=False,
                     document="""""",
                 ),
+                1: PinSpecification(
+                    name="weight",
+                    type_names=["property_field"],
+                    optional=False,
+                    document="""Gives for each node, the number of times it
+        was found in the elemental nodal
+        field. can be used to average later.""",
+                ),
             },
         )
         return spec
@@ -175,6 +200,8 @@ class InputsElementalNodalToNodal(_Inputs):
     >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
     >>> my_should_average = bool()
     >>> op.inputs.should_average.connect(my_should_average)
+    >>> my_extend_to_mid_nodes = bool()
+    >>> op.inputs.extend_to_mid_nodes.connect(my_extend_to_mid_nodes)
     >>> my_mesh = dpf.MeshedRegion()
     >>> op.inputs.mesh.connect(my_mesh)
     """
@@ -191,6 +218,10 @@ def __init__(self, op: Operator):
             elemental_nodal_to_nodal._spec().input_pin(2), 2, op, -1
         )
         self._inputs.append(self._should_average)
+        self._extend_to_mid_nodes = Input(
+            elemental_nodal_to_nodal._spec().input_pin(4), 4, op, -1
+        )
+        self._inputs.append(self._extend_to_mid_nodes)
         self._mesh = Input(elemental_nodal_to_nodal._spec().input_pin(7), 7, op, -1)
         self._inputs.append(self._mesh)
 
@@ -257,6 +288,27 @@ def should_average(self):
         """
         return self._should_average
 
+    @property
+    def extend_to_mid_nodes(self):
+        """Allows to connect extend_to_mid_nodes input to the operator.
+
+        Compute mid nodes (when available) by
+        averaging neighbour primary nodes
+
+        Parameters
+        ----------
+        my_extend_to_mid_nodes : bool
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.averaging.elemental_nodal_to_nodal()
+        >>> op.inputs.extend_to_mid_nodes.connect(my_extend_to_mid_nodes)
+        >>> # or
+        >>> op.inputs.extend_to_mid_nodes(my_extend_to_mid_nodes)
+        """
+        return self._extend_to_mid_nodes
+
     @property
     def mesh(self):
         """Allows to connect mesh input to the operator.
@@ -286,12 +338,15 @@ class OutputsElementalNodalToNodal(_Outputs):
     >>> op = dpf.operators.averaging.elemental_nodal_to_nodal()
     >>> # Connect inputs : op.inputs. ...
     >>> result_field = op.outputs.field()
+    >>> result_weight = op.outputs.weight()
     """
 
     def __init__(self, op: Operator):
         super().__init__(elemental_nodal_to_nodal._spec().outputs, op)
         self._field = Output(elemental_nodal_to_nodal._spec().output_pin(0), 0, op)
         self._outputs.append(self._field)
+        self._weight = Output(elemental_nodal_to_nodal._spec().output_pin(1), 1, op)
+        self._outputs.append(self._weight)
 
     @property
     def field(self):
@@ -309,3 +364,20 @@ def field(self):
         >>> result_field = op.outputs.field()
         """  # noqa: E501
         return self._field
+
+    @property
+    def weight(self):
+        """Allows to get weight output of the operator
+
+        Returns
+        ----------
+        my_weight : PropertyField
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.averaging.elemental_nodal_to_nodal()
+        >>> # Connect inputs : op.inputs. ...
+        >>> result_weight = op.outputs.weight()
+        """  # noqa: E501
+        return self._weight

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

@@ -31,6 +31,9 @@ class elemental_nodal_to_nodal_fc(Operator):
         Average only on these nodes, if it is scoping
         container, the label must correspond
         to the one of the fields container
+    extend_to_mid_nodes : bool, optional
+        Compute mid nodes (when available) by
+        averaging neighbour primary nodes
 
 
     Examples
@@ -49,17 +52,21 @@ class elemental_nodal_to_nodal_fc(Operator):
     >>> op.inputs.should_average.connect(my_should_average)
     >>> my_scoping = dpf.Scoping()
     >>> op.inputs.scoping.connect(my_scoping)
+    >>> my_extend_to_mid_nodes = bool()
+    >>> op.inputs.extend_to_mid_nodes.connect(my_extend_to_mid_nodes)
 
     >>> # Instantiate operator and connect inputs in one line
     >>> op = dpf.operators.averaging.elemental_nodal_to_nodal_fc(
     ...     fields_container=my_fields_container,
     ...     mesh=my_mesh,
     ...     should_average=my_should_average,
     ...     scoping=my_scoping,
+    ...     extend_to_mid_nodes=my_extend_to_mid_nodes,
     ... )
 
     >>> # Get output data
     >>> result_fields_container = op.outputs.fields_container()
+    >>> result_weights = op.outputs.weights()
     """
 
     def __init__(
@@ -68,6 +75,7 @@ def __init__(
         mesh=None,
         should_average=None,
         scoping=None,
+        extend_to_mid_nodes=None,
         config=None,
         server=None,
     ):
@@ -84,6 +92,8 @@ def __init__(
             self.inputs.should_average.connect(should_average)
         if scoping is not None:
             self.inputs.scoping.connect(scoping)
+        if extend_to_mid_nodes is not None:
+            self.inputs.extend_to_mid_nodes.connect(extend_to_mid_nodes)
 
     @staticmethod
     def _spec():
@@ -125,6 +135,13 @@ def _spec():
         container, the label must correspond
         to the one of the fields container""",
                 ),
+                4: PinSpecification(
+                    name="extend_to_mid_nodes",
+                    type_names=["bool"],
+                    optional=True,
+                    document="""Compute mid nodes (when available) by
+        averaging neighbour primary nodes""",
+                ),
             },
             map_output_pin_spec={
                 0: PinSpecification(
@@ -133,6 +150,16 @@ def _spec():
                     optional=False,
                     document="""""",
                 ),
+                1: PinSpecification(
+                    name="weights",
+                    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
+        field. can be used to average later.""",
+                ),
             },
         )
         return spec
@@ -192,6 +219,8 @@ class InputsElementalNodalToNodalFc(_Inputs):
     >>> op.inputs.should_average.connect(my_should_average)
     >>> my_scoping = dpf.Scoping()
     >>> op.inputs.scoping.connect(my_scoping)
+    >>> my_extend_to_mid_nodes = bool()
+    >>> op.inputs.extend_to_mid_nodes.connect(my_extend_to_mid_nodes)
     """
 
     def __init__(self, op: Operator):
@@ -210,6 +239,10 @@ def __init__(self, op: Operator):
             elemental_nodal_to_nodal_fc._spec().input_pin(3), 3, op, -1
         )
         self._inputs.append(self._scoping)
+        self._extend_to_mid_nodes = Input(
+            elemental_nodal_to_nodal_fc._spec().input_pin(4), 4, op, -1
+        )
+        self._inputs.append(self._extend_to_mid_nodes)
 
     @property
     def fields_container(self):
@@ -295,6 +328,27 @@ def scoping(self):
         """
         return self._scoping
 
+    @property
+    def extend_to_mid_nodes(self):
+        """Allows to connect extend_to_mid_nodes input to the operator.
+
+        Compute mid nodes (when available) by
+        averaging neighbour primary nodes
+
+        Parameters
+        ----------
+        my_extend_to_mid_nodes : bool
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.averaging.elemental_nodal_to_nodal_fc()
+        >>> op.inputs.extend_to_mid_nodes.connect(my_extend_to_mid_nodes)
+        >>> # or
+        >>> op.inputs.extend_to_mid_nodes(my_extend_to_mid_nodes)
+        """
+        return self._extend_to_mid_nodes
+
 
 class OutputsElementalNodalToNodalFc(_Outputs):
     """Intermediate class used to get outputs from
@@ -306,6 +360,7 @@ class OutputsElementalNodalToNodalFc(_Outputs):
     >>> op = dpf.operators.averaging.elemental_nodal_to_nodal_fc()
     >>> # Connect inputs : op.inputs. ...
     >>> result_fields_container = op.outputs.fields_container()
+    >>> result_weights = op.outputs.weights()
     """
 
     def __init__(self, op: Operator):
@@ -314,6 +369,8 @@ def __init__(self, op: Operator):
             elemental_nodal_to_nodal_fc._spec().output_pin(0), 0, op
         )
         self._outputs.append(self._fields_container)
+        self._weights = Output(elemental_nodal_to_nodal_fc._spec().output_pin(1), 1, op)
+        self._outputs.append(self._weights)
 
     @property
     def fields_container(self):
@@ -331,3 +388,21 @@ def fields_container(self):
         >>> result_fields_container = op.outputs.fields_container()
         """  # noqa: E501
         return self._fields_container
+
+    @property
+    def weights(self):
+        """Allows to get weights output of the operator
+
+        Returns
+        ----------
+        my_weights : Class Dataprocessing::Dpftypecollection&lt;Class
+        Dataprocessing::Cpropertyfield&gt;
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.averaging.elemental_nodal_to_nodal_fc()
+        >>> # Connect inputs : op.inputs. ...
+        >>> result_weights = op.outputs.weights()
+        """  # noqa: E501
+        return self._weights

ansys/dpf/core/operators/averaging/extend_to_mid_nodes.py

@@ -11,8 +11,8 @@
 
 
 class extend_to_mid_nodes(Operator):
-    """Extends ElementalNodal field defined on corner nodes to a
-    ElementalNodal field defined also on the mid nodes.
+    """Extends an ElementalNodal or Nodal field defined on corner nodes to a
+    field defined also on the mid nodes.
 
     Parameters
     ----------
@@ -56,8 +56,8 @@ def __init__(self, field=None, mesh=None, config=None, server=None):
 
     @staticmethod
     def _spec():
-        description = """Extends ElementalNodal field defined on corner nodes to a
-            ElementalNodal field defined also on the mid nodes."""
+        description = """Extends an ElementalNodal or Nodal field defined on corner nodes to a
+            field defined also on the mid nodes."""
         spec = Specification(
             description=description,
             map_input_pin_spec={

ansys/dpf/core/operators/averaging/extend_to_mid_nodes_fc.py

@@ -11,7 +11,7 @@
 
 
 class extend_to_mid_nodes_fc(Operator):
-    """Extends ElementalNodal fields defined on corner nodes to
+    """Extends ElementalNodal or Nodal fields defined on corner nodes to
     ElementalNodal fields defined also on the mid nodes.
 
     Parameters
@@ -57,7 +57,7 @@ def __init__(self, fields_container=None, mesh=None, config=None, server=None):
 
     @staticmethod
     def _spec():
-        description = """Extends ElementalNodal fields defined on corner nodes to
+        description = """Extends ElementalNodal or Nodal fields defined on corner nodes to
             ElementalNodal fields defined also on the mid nodes."""
         spec = Specification(
             description=description,