Do not turn element scoping into a nodal one (#898)

Author: FedericoNegri

src/ansys/dpf/post/simulation.py

@@ -34,7 +34,6 @@
 
 import ansys.dpf.core as dpf
 from ansys.dpf.core import DataSources, Model, TimeFreqSupport, errors
-from ansys.dpf.core.available_result import _result_properties
 from ansys.dpf.core.common import elemental_properties
 from ansys.dpf.core.plotter import DpfPlotter
 from ansys.dpf.core.server_types import BaseServer
@@ -600,14 +599,14 @@ def _build_selection(
         ] = None,
         all_sets: bool = False,
         named_selections: Union[List[str], str, None] = None,
-        element_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], dpf.Scoping, None] = None,
         node_ids: Union[List[int], None] = None,
         location: Union[locations, str] = locations.nodal,
         external_layer: bool = False,
         skin: Union[bool, List[int]] = False,
         expand_cyclic: Union[bool, List[Union[int, List[int]]]] = True,
         average_per_body: Optional[bool] = False,
-    ) -> (Selection, Optional[_Rescoping]):
+    ) -> Tuple[Selection, Optional[_Rescoping]]:
         tot = (
             (node_ids is not None)
             + (element_ids is not None)
@@ -659,26 +658,26 @@ def _build_selection(
         if requires_manual_averaging and location != locations.elemental_nodal:
             location = locations.elemental_nodal
 
+        available_results = self._model.metadata.result_info.available_results
+        result_info = next(
+            (r for r in available_results if r.operator_name == base_name), None
+        )
+        result_native_location = None
+        if result_info is not None:
+            result_native_location = result_info.native_location
+
         # Create the SpatialSelection
 
         # First: the skin and the external layer to be able to have both a mesh scoping and
         # the skin/external layer
         if (skin is not None and skin is not False) or (
             external_layer is not None and external_layer is not False
         ):
-            res = (
-                _result_properties[base_name]
-                if base_name in _result_properties
-                else None
-            )
-
             if external_layer not in [None, False]:
                 selection.select_external_layer(
                     elements=external_layer if external_layer is not True else None,
                     location=location,
-                    result_native_location=res["location"]
-                    if res is not None
-                    else location,
+                    result_native_location=result_native_location or location,
                     is_model_cyclic=self._model.operator("is_cyclic").eval()
                     if expand_cyclic is not False
                     else "not_cyclic",
@@ -687,9 +686,7 @@ def _build_selection(
                 selection.select_skin(
                     elements=skin if skin is not True else None,
                     location=location,
-                    result_native_location=res["location"]
-                    if res is not None
-                    else location,
+                    result_native_location=result_native_location or location,
                     is_model_cyclic=self._model.operator("is_cyclic").eval()
                     if expand_cyclic is not False
                     else "not_cyclic",
@@ -701,7 +698,7 @@ def _build_selection(
                 inclusive=requires_manual_averaging,
             )
         elif element_ids is not None:
-            if location == locations.nodal:
+            if result_native_location == locations.nodal:
                 selection.select_nodes_of_elements(elements=element_ids, mesh=self.mesh)
             else:
                 selection.select_elements(elements=element_ids)

tests/test_simulation.py

@@ -57,6 +57,7 @@
 from ansys.dpf.post.simulation import MechanicalSimulation, Simulation
 from conftest import (
     SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_4_0,
+    SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_5_0,
     SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_6_2,
     SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_7_1,
     SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_8_0,
@@ -4646,24 +4647,15 @@ def test_build_selection(
         set_ids=None,
         times=None,
         all_sets=True,
-        element_ids=scoping.ids,
+        element_ids=scoping,
     )
     selection_wf = selection.spatial_selection._selection
     if selection.spatial_selection.requires_mesh:
         selection_wf.connect(_WfNames.initial_mesh, simulation.mesh._meshed_region)
     scoping_from_selection = selection_wf.get_output(_WfNames.scoping, Scoping)
 
-    if is_skin or average_per_body:
-        # If request is for skin or average per body, the location should be elemental
-        # because force_elemental_nodal is True
-        assert scoping_from_selection.location == locations.elemental
-        assert set(scoping_from_selection.ids) == set(scoping.ids)
-    else:
-        assert scoping_from_selection.location == requested_location
-        if requested_location == locations.nodal:
-            assert len(scoping_from_selection.ids) == 36
-        else:
-            assert set(scoping_from_selection.ids) == set(scoping.ids)
+    assert scoping_from_selection.location == locations.elemental
+    assert set(scoping_from_selection.ids) == set(scoping.ids)
 
 
 def test_beam_results_on_skin(beam_example):
@@ -4694,3 +4686,56 @@ def test_beam_results_on_skin(beam_example):
     assert element_count_dict[element_types.Line2.value] == 40
 
     assert converted_field.max().data[0] == pytest.approx(190, 1e-2)
+
+
+@pytest.mark.skipif(
+    not SERVERS_VERSION_GREATER_THAN_OR_EQUAL_TO_5_0,
+    reason="The behavior of some operators was different before DPF 5.0.",
+)
+def test_nodal_averaging_on_elemental_scoping(average_per_body_two_cubes):
+    # reference results from Mechanical
+    rst_file = pathlib.Path(average_per_body_two_cubes)
+    simulation: StaticMechanicalSimulation = post.load_simulation(
+        data_sources=rst_file,
+        simulation_type=AvailableSimulationTypes.static_mechanical,
+    )
+
+    element_ids = [7]
+
+    # Test equivalent stress
+    result = simulation.stress_eqv_von_mises_nodal(
+        set_ids=[1], element_ids=element_ids, skin=False
+    )
+    assert len(result._fc) == 1
+    field = result._fc[0]
+
+    assert field.location == locations.nodal
+    assert field.size == 8
+    assert np.allclose(field.min().data[0], 0.7465022)
+    assert np.allclose(field.max().data[0], 1.733499)
+
+    # Test a strain component
+    result = simulation.elastic_strain_nodal(
+        set_ids=[1], element_ids=element_ids, skin=False, components=["YY"]
+    )
+
+    assert len(result._fc) == 1
+    field = result._fc[0]
+
+    assert field.location == locations.nodal
+    assert field.size == 8
+    assert np.allclose(field.min().data[0], -3.629157e-6)
+    assert np.allclose(field.max().data[0], -1.054446e-6)
+
+    # Let's also make sure a nodal quantity like displacement is correct
+    result = simulation.displacement(
+        set_ids=[1], element_ids=element_ids, skin=False, norm=True
+    )
+
+    assert len(result._fc) == 1
+    field = result._fc[0]
+
+    assert field.location == locations.nodal
+    assert field.size == 8
+    assert np.allclose(field.min().data[0], 1.724714e-5)
+    assert np.allclose(field.max().data[0], 6.407787e-5)