Fix scoping if force_elemental_nodal is true. (#739)

When manual averaging is needed we request the data as ElementalNodal and perform the nodal averaging manually (force_elemental_nodal=True). If the mesh_scoping for a source operator (such as S) is nodal, and the requested location is ElementalNodal it returns the inclusive data (all elements that have at least one node in the scoping). This leads to one extra layer of data if

the initial scope is nodal (see Nodal named selection with force_elemental_nodal yield too large selection #731)
The initial scope is elemental but the requested data is nodal. This happens because _build_selection converts the elemental scoping into a nodal scoping when the requested result is nodal.
In build selection, there was already a call to _requires_manual_averaging, based on which the location was modified. However, _requires_manual_averaging was always called with selection = None, which basically meant it always returns false and the location is not adapted.

This PR adresses the problem by making the has_skin, and has_external_layer inputs explicit in the call to _requires_manual_averaging and passing the correct values in _build_selection. It also moves the call to _requires_manual_averaging outside of all the if statements so is called in the same way as in _get_results.

The selection is now inclusive for nodes (from a nodal named selections or a node id array), to support the case of nodal selections that don't select all the nodes of an element. Depending on the selection this results in an additional "layer" of nodes in the result. This is solved by returning the original selection from _build_selection and applying it in the end of the results workflow. Please have another look.

Notes:

This problem was not often visible because manual averaging is mostly needed in the skin case, where the final result is rescoped to the skin. It is more apparent with the new average per solid feature
I removed the requires_manual_averaging method from selection and spatial selection, because it is incomplete. Some decisions depend on the result type (is it a strain result?). If these methods are needed for backward compatibility I can add calls to the new generic method with dummy arguments for the result types.
Also #fixes #731

Author: janvonrickenbach

src/ansys/dpf/post/fluid_simulation.py

@@ -20,7 +20,7 @@
     _create_components,
 )
 from ansys.dpf.post.result_workflows._connect_workflow_inputs import (
-    _connect_initial_results_inputs,
+    _connect_workflow_inputs,
 )
 from ansys.dpf.post.result_workflows._sub_workflows import _create_norm_workflow
 from ansys.dpf.post.result_workflows._utils import AveragingConfig, _append_workflows
@@ -252,9 +252,10 @@ def _get_result_workflow(
             "mesh_scoping", initial_result_op.inputs.mesh_scoping
         )
 
-        _connect_initial_results_inputs(
+        _connect_workflow_inputs(
             initial_result_workflow=initial_result_workflow,
             split_by_body_workflow=None,
+            rescoping_workflow=None,
             force_elemental_nodal=False,
             location=location,
             selection=selection,

src/ansys/dpf/post/harmonic_mechanical_simulation.py

@@ -4,7 +4,7 @@
 ----------------------------
 
 """
-from typing import List, Tuple, Union
+from typing import List, Optional, Tuple, Union
 import warnings
 
 from ansys.dpf import core as dpf
@@ -28,9 +28,13 @@
 )
 from ansys.dpf.post.result_workflows._connect_workflow_inputs import (
     _connect_averaging_eqv_and_principal_workflows,
-    _connect_initial_results_inputs,
+    _connect_workflow_inputs,
+)
+from ansys.dpf.post.result_workflows._utils import (
+    AveragingConfig,
+    _append_workflows,
+    _Rescoping,
 )
-from ansys.dpf.post.result_workflows._utils import AveragingConfig, _append_workflows
 from ansys.dpf.post.selection import Selection, _WfNames
 from ansys.dpf.post.simulation import MechanicalSimulation
 
@@ -51,6 +55,7 @@ def _get_result_workflow(
         expand_cyclic: Union[bool, List[Union[int, List[int]]]] = True,
         phase_angle_cyclic: Union[float, None] = None,
         averaging_config: AveragingConfig = AveragingConfig(),
+        rescoping: Optional[_Rescoping] = None,
     ) -> (dpf.Workflow, Union[str, list[str], None], str):
         """Generate (without evaluating) the Workflow to extract results."""
         result_workflow_inputs = _create_result_workflow_inputs(
@@ -64,15 +69,17 @@ def _get_result_workflow(
             amplitude=amplitude,
             sweeping_phase=sweeping_phase,
             averaging_config=averaging_config,
+            rescoping=rescoping,
         )
         result_workflows = _create_result_workflows(
             server=self._model._server,
             create_operator_callable=self._model.operator,
             create_workflow_inputs=result_workflow_inputs,
         )
-        _connect_initial_results_inputs(
+        _connect_workflow_inputs(
             initial_result_workflow=result_workflows.initial_result_workflow,
             split_by_body_workflow=result_workflows.split_by_bodies_workflow,
+            rescoping_workflow=result_workflows.rescoping_workflow,
             selection=selection,
             data_sources=self._model.metadata.data_sources,
             streams_provider=self._model.metadata.streams_provider,
@@ -91,6 +98,7 @@ def _get_result_workflow(
                 result_workflows.component_extraction_workflow,
                 result_workflows.sweeping_phase_workflow,
                 result_workflows.norm_workflow,
+                result_workflows.rescoping_workflow,
             ],
             output_wf,
         )
@@ -235,7 +243,7 @@ def _get_result(
                 "and node_ids are mutually exclusive"
             )
 
-        selection = self._build_selection(
+        selection, rescoping = self._build_selection(
             base_name=base_name,
             category=category,
             selection=selection,
@@ -249,6 +257,7 @@ def _get_result(
             location=location,
             external_layer=external_layer,
             skin=skin,
+            average_per_body=averaging_config.average_per_body,
         )
 
         wf, comp, base_name = self._get_result_workflow(
@@ -263,6 +272,7 @@ def _get_result(
             expand_cyclic=expand_cyclic,
             phase_angle_cyclic=phase_angle_cyclic,
             averaging_config=averaging_config,
+            rescoping=rescoping,
         )
 
         # Evaluate  the workflow

src/ansys/dpf/post/modal_mechanical_simulation.py

@@ -4,7 +4,7 @@
 -------------------------
 
 """
-from typing import List, Union
+from typing import List, Optional, Union
 
 from ansys.dpf import core as dpf
 from ansys.dpf.post import locations
@@ -19,9 +19,13 @@
 )
 from ansys.dpf.post.result_workflows._connect_workflow_inputs import (
     _connect_averaging_eqv_and_principal_workflows,
-    _connect_initial_results_inputs,
+    _connect_workflow_inputs,
+)
+from ansys.dpf.post.result_workflows._utils import (
+    AveragingConfig,
+    _append_workflows,
+    _Rescoping,
 )
-from ansys.dpf.post.result_workflows._utils import AveragingConfig, _append_workflows
 from ansys.dpf.post.selection import Selection, _WfNames
 from ansys.dpf.post.simulation import MechanicalSimulation
 
@@ -40,6 +44,7 @@ def _get_result_workflow(
         expand_cyclic: Union[bool, List[Union[int, List[int]]]] = True,
         phase_angle_cyclic: Union[float, None] = None,
         averaging_config: AveragingConfig = AveragingConfig(),
+        rescoping: Optional[_Rescoping] = None,
     ) -> (dpf.Workflow, Union[str, list[str], None], str):
         """Generate (without evaluating) the Workflow to extract results."""
         result_workflow_inputs = _create_result_workflow_inputs(
@@ -51,15 +56,17 @@ def _get_result_workflow(
             selection=selection,
             create_operator_callable=self._model.operator,
             averaging_config=averaging_config,
+            rescoping=rescoping,
         )
         result_workflows = _create_result_workflows(
             server=self._model._server,
             create_operator_callable=self._model.operator,
             create_workflow_inputs=result_workflow_inputs,
         )
-        _connect_initial_results_inputs(
+        _connect_workflow_inputs(
             initial_result_workflow=result_workflows.initial_result_workflow,
             split_by_body_workflow=result_workflows.split_by_bodies_workflow,
+            rescoping_workflow=result_workflows.rescoping_workflow,
             selection=selection,
             data_sources=self._model.metadata.data_sources,
             streams_provider=self._model.metadata.streams_provider,
@@ -77,6 +84,7 @@ def _get_result_workflow(
             [
                 result_workflows.component_extraction_workflow,
                 result_workflows.norm_workflow,
+                result_workflows.rescoping_workflow,
             ],
             output_wf,
         )
@@ -199,7 +207,7 @@ def _get_result(
         elif tot == 0:
             set_ids = 1
 
-        selection = self._build_selection(
+        selection, rescoping = self._build_selection(
             base_name=base_name,
             category=category,
             selection=selection,
@@ -213,6 +221,7 @@ def _get_result(
             location=location,
             external_layer=external_layer,
             skin=skin,
+            average_per_body=averaging_config.average_per_body,
         )
 
         wf, comp, base_name = self._get_result_workflow(
@@ -225,6 +234,7 @@ def _get_result(
             expand_cyclic=expand_cyclic,
             phase_angle_cyclic=phase_angle_cyclic,
             averaging_config=averaging_config,
+            rescoping=rescoping,
         )
 
         # Evaluate  the workflow

src/ansys/dpf/post/result_workflows/_build_workflow.py

@@ -16,12 +16,14 @@
     _create_initial_result_workflow,
     _create_norm_workflow,
     _create_principal_workflow,
+    _create_rescoping_workflow,
     _create_split_scope_by_body_workflow,
     _create_sweeping_phase_workflow,
 )
 from ansys.dpf.post.result_workflows._utils import (
     AveragingConfig,
     _CreateOperatorCallable,
+    _Rescoping,
 )
 from ansys.dpf.post.selection import Selection, _WfNames
 
@@ -63,6 +65,7 @@ class ResultWorkflows:
     # Workflow to sweep the phase of the result
     sweeping_phase_workflow: Optional[Workflow] = None
     split_by_bodies_workflow: Optional[Workflow] = None
+    rescoping_workflow: Optional[Workflow] = None
 
 
 @dataclasses.dataclass
@@ -90,13 +93,15 @@ class _CreateWorkflowInputs:
     should_extract_components: bool
     averaging_config: AveragingConfig
     sweeping_phase_workflow_inputs: Optional[_SweepingPhaseWorkflowInputs] = None
+    rescoping_workflow_inputs: Optional[_Rescoping] = None
 
 
 def _requires_manual_averaging(
     base_name: str,
     location: str,
     category: ResultCategory,
-    selection: Optional[Selection],
+    has_skin: bool,
+    has_external_layer: bool,
     create_operator_callable: Callable[[str], Operator],
     average_per_body: bool,
 ):
@@ -110,12 +115,17 @@ def _requires_manual_averaging(
         return True
     if category == ResultCategory.equivalent and base_name[0] == "E":  # strain eqv
         return True
-    if res is not None and selection is not None:
-        return selection.requires_manual_averaging(
-            location=location,
-            result_native_location=res["location"],
-            is_model_cyclic=create_operator_callable("is_cyclic").eval(),
-        )
+    if res is not None:
+        is_model_cyclic = create_operator_callable("is_cyclic").eval()
+        is_model_cyclic = is_model_cyclic in ["single_stage", "multi_stage"]
+        if has_external_layer and is_model_cyclic and location != native_location:
+            return True
+        elif has_skin and (
+            native_location == locations.elemental
+            or native_location == locations.elemental_nodal
+        ):
+            return True
+        return False
     return False
 
 
@@ -215,6 +225,11 @@ def _create_result_workflows(
             )
         )
 
+    if create_workflow_inputs.rescoping_workflow_inputs is not None:
+        result_workflows.rescoping_workflow = _create_rescoping_workflow(
+            server, create_workflow_inputs.rescoping_workflow_inputs
+        )
+
     return result_workflows
 
 
@@ -227,6 +242,7 @@ def _create_result_workflow_inputs(
     selection: Selection,
     create_operator_callable: Callable[[str], Operator],
     averaging_config: AveragingConfig,
+    rescoping: Optional[_Rescoping] = None,
     amplitude: bool = False,
     sweeping_phase: Union[float, None] = 0.0,
 ) -> _CreateWorkflowInputs:
@@ -239,7 +255,9 @@ def _create_result_workflow_inputs(
         base_name=base_name,
         location=location,
         category=category,
-        selection=selection,
+        has_skin=_WfNames.skin in selection.spatial_selection._selection.output_names,
+        has_external_layer=_WfNames.external_layer
+        in selection.spatial_selection._selection.output_names,
         create_operator_callable=create_operator_callable,
         average_per_body=averaging_config.average_per_body,
     )
@@ -274,4 +292,5 @@ def _create_result_workflow_inputs(
         has_equivalent=category == ResultCategory.equivalent,
         sweeping_phase_workflow_inputs=sweeping_phase_workflow_inputs,
         averaging_config=averaging_config,
+        rescoping_workflow_inputs=rescoping,
     )

src/ansys/dpf/post/result_workflows/_connect_workflow_inputs.py

@@ -73,9 +73,10 @@ def _connect_cyclic_inputs(expand_cyclic, phase_angle_cyclic, result_wf: Workflo
         result_wf.connect(_WfNames.cyclic_phase, phase_angle_cyclic)
 
 
-def _connect_initial_results_inputs(
+def _connect_workflow_inputs(
     initial_result_workflow: Workflow,
     split_by_body_workflow: Optional[Workflow],
+    rescoping_workflow: Optional[Workflow],
     force_elemental_nodal: bool,
     location: str,
     selection: Selection,
@@ -146,6 +147,11 @@ def _connect_initial_results_inputs(
 
     initial_result_workflow.connect(_WfNames.mesh, mesh)
 
+    if rescoping_workflow:
+        rescoping_workflow.connect(_WfNames.mesh, mesh)
+        if _WfNames.data_sources in rescoping_workflow.input_names:
+            rescoping_workflow.connect(_WfNames.data_sources, data_sources)
+
 
 def _connect_averaging_eqv_and_principal_workflows(
     result_workflows: ResultWorkflows,

src/ansys/dpf/post/result_workflows/_sub_workflows.py

@@ -4,8 +4,8 @@
 from ansys.dpf.gate.common import locations
 
 from ansys.dpf.post.misc import _connect_any
-from ansys.dpf.post.result_workflows._utils import _CreateOperatorCallable
-from ansys.dpf.post.selection import _WfNames
+from ansys.dpf.post.result_workflows._utils import _CreateOperatorCallable, _Rescoping
+from ansys.dpf.post.selection import SpatialSelection, _WfNames
 
 
 def _create_averaging_workflow(
@@ -269,3 +269,43 @@ def _create_split_scope_by_body_workflow(server, body_defining_properties: list[
         _WfNames.scoping, split_scop_op.outputs.mesh_scoping
     )
     return split_scope_by_body_wf
+
+
+def _create_rescoping_workflow(server, rescoping: _Rescoping):
+    selection = SpatialSelection(server=server)
+
+    if rescoping.named_selections is not None:
+        selection.select_named_selection(rescoping.named_selections)
+
+    if rescoping.node_ids is not None:
+        selection.select_nodes(rescoping.node_ids)
+
+    rescoping_wf = Workflow(server=server)
+
+    transpose_scoping_op = operators.scoping.transpose()
+    rescoping_wf.add_operator(transpose_scoping_op)
+    transpose_scoping_op.inputs.requested_location(rescoping.requested_location)
+    rescoping_wf.set_input_name(
+        _WfNames.mesh, transpose_scoping_op.inputs.meshed_region
+    )
+
+    rescoping_op = operators.scoping.rescope_fc()
+    rescoping_wf.add_operator(rescoping_op)
+    rescoping_op.inputs.mesh_scoping(
+        transpose_scoping_op.outputs.mesh_scoping_as_scoping
+    )
+    rescoping_wf.set_input_name(
+        _WfNames.input_data, rescoping_op.inputs.fields_container
+    )
+    rescoping_wf.set_input_name(
+        _WfNames.scoping, transpose_scoping_op.inputs.mesh_scoping
+    )
+    rescoping_wf.set_output_name(
+        _WfNames.output_data, rescoping_op.outputs.fields_container
+    )
+
+    rescoping_wf.connect_with(
+        selection._selection, output_input_names={_WfNames.scoping: _WfNames.scoping}
+    )
+
+    return rescoping_wf