From 7872421c3a131d1732afec65ee75048933bd0c63 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Fri, 10 Feb 2023 15:03:16 +0100
Subject: [PATCH 01/33] Use the time_scoping of the FieldsContainer and not its
 TimeFreqSupport

---
 tests/test_simulation.py | 62 +++++++++++++++++-----------------------
 1 file changed, 26 insertions(+), 36 deletions(-)

diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index ba01b88ed..b8ef1db12 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -68,7 +68,7 @@ def test_displacement(self, static_simulation):
             component_ids=["X"], nodes=[42, 43, 44], set_ids=[1]
         )
         assert len(displacement_x._fc) == 1
-        assert displacement_x._fc.time_freq_support.time_frequencies.data == 1
+        assert displacement_x._fc.get_time_scoping().ids == [1]
         field = displacement_x._fc[0]
         op = static_simulation._model.operator("UX")
         mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
@@ -87,7 +87,7 @@ def test_displacement(self, static_simulation):
             sub_steps=[1],
         )
         assert len(displacement_y._fc) == 1
-        assert displacement_y._fc.time_freq_support.time_frequencies.data == 1
+        assert displacement_y._fc.get_time_scoping().ids == [1]
         field = displacement_y._fc[0]
         op = static_simulation._model.operator("UY")
         mesh_scoping = core.mesh_scoping_factory.named_selection_scoping(
@@ -108,7 +108,7 @@ def test_displacement(self, static_simulation):
             sub_steps=1,
         )
         assert len(displacement_z._fc) == 1
-        assert displacement_z._fc.time_freq_support.time_frequencies.data == 1
+        assert displacement_z._fc.get_time_scoping().ids == [1]
         field = displacement_z._fc[0]
         op = static_simulation._model.operator("UZ")
         mesh_scoping = core.mesh_scoping_factory.named_selection_scoping(
@@ -128,7 +128,7 @@ def test_displacement(self, static_simulation):
             set_ids=1,
         )
         assert len(displacement_z._fc) == 1
-        assert displacement_z._fc.time_freq_support.time_frequencies.data == 1
+        assert displacement_z._fc.get_time_scoping().ids == [1]
         field = displacement_z._fc[0]
         op = static_simulation._model.operator("UZ")
         mesh_scoping = core.mesh_scoping_factory.elemental_scoping(
@@ -151,7 +151,7 @@ def test_displacement(self, static_simulation):
             norm=True, nodes=[42, 43, 44], set_ids=[1]
         )
         assert len(displacement_norm._fc) == 1
-        assert displacement_norm._fc.time_freq_support.time_frequencies.data == 1
+        assert displacement_norm._fc.get_time_scoping().ids == [1]
         field = displacement_norm._fc[0]
         op = static_simulation._model.operator("U")
         mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
@@ -168,7 +168,7 @@ def test_displacement(self, static_simulation):
     def test_stress(self, static_simulation):
         stress_x = static_simulation.stress(component_ids=1)
         assert len(stress_x._fc) == 1
-        assert stress_x._fc.time_freq_support.time_frequencies.data == 1
+        assert stress_x._fc.get_time_scoping().ids == [1]
         field = stress_x._fc[0]
         op = static_simulation._model.operator("SX")
         op.connect(9, core.locations.elemental_nodal)
@@ -180,7 +180,7 @@ def test_stress(self, static_simulation):
     def test_stress_elemental(self, static_simulation):
         stress_x = static_simulation.stress_elemental(component_ids=1)
         assert len(stress_x._fc) == 1
-        assert stress_x._fc.time_freq_support.time_frequencies.data == 1
+        assert stress_x._fc.get_time_scoping().ids == [1]
         field = stress_x._fc[0]
         op = static_simulation._model.operator("SX")
         op.connect(9, core.locations.elemental)
@@ -192,7 +192,7 @@ def test_stress_elemental(self, static_simulation):
     def test_stress_nodal(self, static_simulation):
         stress_x = static_simulation.stress_nodal(component_ids=1)
         assert len(stress_x._fc) == 1
-        assert stress_x._fc.time_freq_support.time_frequencies.data == 1
+        assert stress_x._fc.get_time_scoping().ids == [1]
         field = stress_x._fc[0]
         op = static_simulation._model.operator("SX")
         op.connect(9, core.locations.nodal)
@@ -204,7 +204,7 @@ def test_stress_nodal(self, static_simulation):
     def test_stress_principal(self, static_simulation):
         result = static_simulation.stress_principal(component_ids=1)
         assert len(result._fc) == 1
-        assert result._fc.time_freq_support.time_frequencies.data == 1
+        assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
         op = static_simulation._model.operator("S1")
         op.connect(9, core.locations.elemental_nodal)
@@ -216,7 +216,7 @@ def test_stress_principal(self, static_simulation):
     def test_stress_principal_nodal(self, static_simulation):
         result = static_simulation.stress_principal_nodal(component_ids=2)
         assert len(result._fc) == 1
-        assert result._fc.time_freq_support.time_frequencies.data == 1
+        assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
         op = static_simulation._model.operator("S2")
         op.connect(9, core.locations.nodal)
@@ -228,7 +228,7 @@ def test_stress_principal_nodal(self, static_simulation):
     def test_stress_principal_elemental(self, static_simulation):
         result = static_simulation.stress_principal_elemental(component_ids=3)
         assert len(result._fc) == 1
-        assert result._fc.time_freq_support.time_frequencies.data == 1
+        assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
         op = static_simulation._model.operator("S3")
         op.connect(9, core.locations.elemental)
@@ -240,7 +240,7 @@ def test_stress_principal_elemental(self, static_simulation):
     def test_stress_eqv_von_mises(self, static_simulation):
         result = static_simulation.stress_eqv_von_mises()
         assert len(result._fc) == 1
-        assert result._fc.time_freq_support.time_frequencies.data == 1
+        assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
         op = static_simulation._model.operator("S_eqv")
         op.connect(9, core.locations.elemental_nodal)
@@ -252,7 +252,7 @@ def test_stress_eqv_von_mises(self, static_simulation):
     def test_stress_eqv_von_mises_elemental(self, static_simulation):
         stress_vm = static_simulation.stress_eqv_von_mises_elemental()
         assert len(stress_vm._fc) == 1
-        assert stress_vm._fc.time_freq_support.time_frequencies.data == 1
+        assert stress_vm._fc.get_time_scoping().ids == [1]
         field = stress_vm._fc[0]
         op = static_simulation._model.operator("S_eqv")
         op.connect(9, core.locations.elemental)
@@ -264,7 +264,7 @@ def test_stress_eqv_von_mises_elemental(self, static_simulation):
     def test_stress_eqv_von_mises_nodal(self, static_simulation):
         stress_vm = static_simulation.stress_eqv_von_mises_nodal()
         assert len(stress_vm._fc) == 1
-        assert stress_vm._fc.time_freq_support.time_frequencies.data == 1
+        assert stress_vm._fc.get_time_scoping().ids == [1]
         field = stress_vm._fc[0]
         op = static_simulation._model.operator("S_eqv")
         op.connect(9, core.locations.nodal)
@@ -276,7 +276,7 @@ def test_stress_eqv_von_mises_nodal(self, static_simulation):
     def test_reaction_force(self, static_simulation):
         reaction_force = static_simulation.reaction_force()
         assert len(reaction_force._fc) == 1
-        assert reaction_force._fc.time_freq_support.time_frequencies.data == 1
+        assert reaction_force._fc.get_time_scoping().ids == [1]
         field = reaction_force._fc[0]
         op = static_simulation._model.operator("RF")
         field_ref = op.eval()[0]
@@ -287,7 +287,7 @@ def test_reaction_force(self, static_simulation):
     def test_elemental_volume(self, static_simulation):
         elemental_volume = static_simulation.elemental_volume()
         assert len(elemental_volume._fc) == 1
-        assert elemental_volume._fc.time_freq_support.time_frequencies.data == 1
+        assert elemental_volume._fc.get_time_scoping().ids == [1]
         field = elemental_volume._fc[0]
         op = static_simulation._model.operator("ENG_VOL")
         field_ref = op.eval()[0]
@@ -299,7 +299,7 @@ def test_elemental_volume(self, static_simulation):
     def test_stiffness_matrix_energy(self, static_simulation):
         stiffness_matrix_energy = static_simulation.stiffness_matrix_energy()
         assert len(stiffness_matrix_energy._fc) == 1
-        assert stiffness_matrix_energy._fc.time_freq_support.time_frequencies.data == 1
+        assert stiffness_matrix_energy._fc.get_time_scoping().ids == [1]
         field = stiffness_matrix_energy._fc[0]
         op = static_simulation._model.operator("ENG_SE")
         field_ref = op.eval()[0]
@@ -310,9 +310,7 @@ def test_stiffness_matrix_energy(self, static_simulation):
     def test_artificial_hourglass_energy(self, static_simulation):
         artificial_hourglass_energy = static_simulation.artificial_hourglass_energy()
         assert len(artificial_hourglass_energy._fc) == 1
-        assert (
-            artificial_hourglass_energy._fc.time_freq_support.time_frequencies.data == 1
-        )
+        assert artificial_hourglass_energy._fc.get_time_scoping().ids == [1]
         field = artificial_hourglass_energy._fc[0]
         op = static_simulation._model.operator("ENG_AHO")
         field_ref = op.eval()[0]
@@ -323,9 +321,7 @@ def test_artificial_hourglass_energy(self, static_simulation):
     def test_thermal_dissipation_energy(self, static_simulation):
         thermal_dissipation_energy = static_simulation.thermal_dissipation_energy()
         assert len(thermal_dissipation_energy._fc) == 1
-        assert (
-            thermal_dissipation_energy._fc.time_freq_support.time_frequencies.data == 1
-        )
+        assert thermal_dissipation_energy._fc.get_time_scoping().ids == [1]
         field = thermal_dissipation_energy._fc[0]
         op = static_simulation._model.operator("ENG_TH")
         field_ref = op.eval()[0]
@@ -336,7 +332,7 @@ def test_thermal_dissipation_energy(self, static_simulation):
     def test_kinetic_energy(self, static_simulation):
         kinetic_energy = static_simulation.kinetic_energy()
         assert len(kinetic_energy._fc) == 1
-        assert kinetic_energy._fc.time_freq_support.time_frequencies.data == 1
+        assert kinetic_energy._fc.get_time_scoping().ids == [1]
         field = kinetic_energy._fc[0]
         op = static_simulation._model.operator("ENG_KE")
         field_ref = op.eval()[0]
@@ -347,7 +343,7 @@ def test_kinetic_energy(self, static_simulation):
     def test_structural_temperature(self, static_simulation):
         structural_temperature = static_simulation.structural_temperature()
         assert len(structural_temperature._fc) == 1
-        assert structural_temperature._fc.time_freq_support.time_frequencies.data == 1
+        assert structural_temperature._fc.get_time_scoping().ids == [1]
         field = structural_temperature._fc[0]
         op = static_simulation._model.operator("BFE")
         field_ref = op.eval()[0]
@@ -358,10 +354,7 @@ def test_structural_temperature(self, static_simulation):
     def test_structural_temperature_nodal(self, static_simulation):
         structural_temperature_nodal = static_simulation.structural_temperature_nodal()
         assert len(structural_temperature_nodal._fc) == 1
-        assert (
-            structural_temperature_nodal._fc.time_freq_support.time_frequencies.data
-            == 1
-        )
+        assert structural_temperature_nodal._fc.get_time_scoping().ids == [1]
         field = structural_temperature_nodal._fc[0]
         op = static_simulation._model.operator("BFE")
         op.connect(9, core.locations.nodal)
@@ -375,10 +368,7 @@ def test_structural_temperature_elemental(self, static_simulation):
             static_simulation.structural_temperature_elemental()
         )
         assert len(structural_temperature_elemental._fc) == 1
-        assert (
-            structural_temperature_elemental._fc.time_freq_support.time_frequencies.data
-            == 1
-        )
+        assert structural_temperature_elemental._fc.get_time_scoping().ids == [1]
         field = structural_temperature_elemental._fc[0]
         op = static_simulation._model.operator("BFE")
         op.connect(9, core.locations.elemental)
@@ -391,7 +381,7 @@ def test_element_nodal_forces(self, allkindofcomplexity):
         static_simulation = dpf.load_simulation(data_sources=allkindofcomplexity)
         element_nodal_forces = static_simulation.element_nodal_forces()
         assert len(element_nodal_forces._fc) == 1
-        assert element_nodal_forces._fc.time_freq_support.time_frequencies.data == 1
+        assert element_nodal_forces._fc.get_time_scoping().ids == [1]
         field = element_nodal_forces._fc[0]
         op = static_simulation._model.operator("ENF")
         field_ref = op.eval()[0]
@@ -403,7 +393,7 @@ def test_element_nodal_forces_nodal(self, allkindofcomplexity):
         static_simulation = dpf.load_simulation(data_sources=allkindofcomplexity)
         element_nodal_forces = static_simulation.element_nodal_forces_nodal()
         assert len(element_nodal_forces._fc) == 3
-        assert element_nodal_forces._fc.time_freq_support.time_frequencies.data == 1
+        assert element_nodal_forces._fc.get_time_scoping().ids == [1]
         field = element_nodal_forces._fc[0]
         op = static_simulation._model.operator("ENF")
         op.connect(9, core.locations.nodal)
@@ -416,7 +406,7 @@ def test_element_nodal_forces_elemental(self, allkindofcomplexity):
         static_simulation = dpf.load_simulation(data_sources=allkindofcomplexity)
         element_nodal_forces = static_simulation.element_nodal_forces_elemental()
         assert len(element_nodal_forces._fc) == 3
-        assert element_nodal_forces._fc.time_freq_support.time_frequencies.data == 1
+        assert element_nodal_forces._fc.get_time_scoping().ids == [1]
         field = element_nodal_forces._fc[0]
         op = static_simulation._model.operator("ENF")
         op.connect(9, core.locations.elemental)

From 863b71eb76b4b4608cd5c25211de988349c1aee0 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Fri, 10 Feb 2023 15:08:45 +0100
Subject: [PATCH 02/33] Add TransientMechanicalSimulation.displacement

---
 src/ansys/dpf/post/simulation.py | 234 ++++++++++++++++++++++++++++++-
 tests/test_simulation.py         |  37 ++++-
 2 files changed, 268 insertions(+), 3 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 785d39ce2..42fcdb362 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -4107,9 +4107,239 @@ def nodal_moment(
 class TransientMechanicalSimulation(MechanicalSimulation):
     """Provides methods for mechanical transient simulations."""
 
-    def _build_time_freq_scoping(self) -> core.time_freq_scoping_factory.Scoping:
+    def _build_time_freq_scoping(
+        self,
+        selection: Union[Selection, None],
+        times: Union[float, List[float], None],
+        time_step_ids: Union[int, List[int], None],
+    ) -> core.time_freq_scoping_factory.Scoping:
         """Generate a time_freq_scoping from input arguments."""
-        pass
+        # create from selection in priority
+        if selection:
+            return selection.time_freq_selection._evaluate_on(simulation=self)
+        # else from time_step_ids
+        if time_step_ids:
+            if isinstance(time_step_ids, int):
+                time_step_ids = [time_step_ids]
+            return core.time_freq_scoping_factory.scoping_by_sets(
+                cumulative_sets=time_step_ids, server=self._model._server
+            )
+        # else from times
+        if times:
+            if isinstance(times, float):
+                times = [times]
+            raise NotImplementedError
+        # Otherwise, no argument was given, create a time_freq_scoping of the whole results
+        return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
+
+    def _get_result(
+        self,
+        base_name: str,
+        location: str,
+        category: ResultCategory,
+        components: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            base_name:
+                Base name for the requested result.
+            location:
+                Location requested.
+            category:
+                Type of result requested. See the :class:`ResultCategory` class.
+            components:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        # Build the targeted time scoping
+        time_scoping = self._build_time_freq_scoping(selection, times, time_step_ids)
+
+        # Build the targeted mesh scoping
+        mesh_scoping = self._build_mesh_scoping(
+            selection,
+            nodes,
+            elements,
+            named_selection,
+            location=location,
+        )
+
+        # Build the list of requested results
+        if category in [ResultCategory.scalar, ResultCategory.equivalent]:
+            # A scalar or equivalent result has no components
+            to_extract = None
+            columns = [base_name]
+        elif category in [ResultCategory.vector, ResultCategory.matrix]:
+            # A matrix or vector result can have components selected
+            to_extract, columns = self._build_components_from_components(
+                base_name=base_name, category=category, components=components
+            )
+        elif category == ResultCategory.principal:
+            # A principal type of result can have components selected
+            to_extract, columns = self._build_components_from_principal(
+                base_name=base_name, components=components
+            )
+        else:
+            raise ValueError(f"'{category}' is not a valid category value.")
+
+        # Initialize a workflow
+        wf = core.Workflow(server=self._model._server)
+        wf.progress_bar = False
+
+        # Instantiate the main result operator
+        result_op = self._build_result_operator(
+            name=base_name,
+            time_scoping=time_scoping,
+            mesh_scoping=mesh_scoping,
+            location=location,
+        )
+        # Its output is selected as future workflow output for now
+        out = result_op.outputs.fields_container
+
+        # Add a step to compute principal invariants if result is principal
+        if category == ResultCategory.principal:
+            # Instantiate the required operator
+            principal_op = self._model.operator(name="eig_values_fc")
+            principal_op.connect(0, out)
+            wf.add_operator(operator=principal_op)
+            # Set as future output of the workflow
+            out = principal_op.outputs.fields_container
+
+        # Add a step to compute equivalent if result is equivalent
+        elif category == ResultCategory.equivalent:
+            # If a stress result, use one operator
+            if base_name[0] == "S":
+                equivalent_op = self._model.operator(name="segalmaneqv_fc")
+            # If a strain result, use another
+            elif base_name[0] == "E":
+                equivalent_op = self._model.operator(name="eqv_fc")
+            # Throw otherwise
+            else:
+                raise ValueError(
+                    f"Category {ResultCategory.equivalent} "
+                    "is only available for stress or strain results."
+                )
+            equivalent_op.connect(0, out)
+            wf.add_operator(operator=equivalent_op)
+            # Set as future output of the workflow
+            out = equivalent_op.outputs.fields_container
+
+        # Add an optional component selection step if result is vector, matrix, or principal
+        if (
+            category
+            in [ResultCategory.vector, ResultCategory.matrix, ResultCategory.principal]
+        ) and (to_extract is not None):
+            # Instantiate a component selector operator
+            extract_op = self._model.operator(name="component_selector_fc")
+            # Feed it the current workflow output
+            extract_op.connect(0, out)
+            # Feed it the requested components
+            extract_op.connect(1, to_extract)
+            wf.add_operator(operator=extract_op)
+            # Set as future output of the workflow
+            out = extract_op.outputs.fields_container
+
+        # Add an optional norm operation if requested
+        if norm:
+            norm_op = self._model.operator(name="norm_fc")
+            norm_op.connect(0, out)
+            wf.add_operator(operator=norm_op)
+            out = norm_op.outputs.fields_container
+
+        # Set the workflow output
+        wf.set_output_name("out", out)
+        # Evaluate  the workflow
+        fc = wf.get_output("out", core.types.fields_container)
+
+        # Test for empty results
+        if (len(fc) == 0) or all([len(f) == 0 for f in fc]):
+            warnings.warn(
+                message=f"Returned Dataframe with columns {columns} is empty.",
+                category=UserWarning,
+            )
+        # Return the result wrapped in a DPF_Dataframe
+        return DataObject(
+            fields_container=fc,
+            columns=columns,
+            mesh_scoping=mesh_scoping,
+        )
+
+    def displacement(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract displacement results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="U",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
 
 
 class ModalMechanicalSimulation(MechanicalSimulation):
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index b8ef1db12..88f611348 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -4,11 +4,23 @@
 from pytest import fixture
 
 import ansys.dpf.post as dpf
+from ansys.dpf.post.common import AvailableSimulationTypes
 
 
 @fixture
 def static_simulation(static_rst):
-    return dpf.load_simulation(data_sources=static_rst)
+    return dpf.load_simulation(
+        data_sources=static_rst,
+        simulation_type=AvailableSimulationTypes.static_mechanical,
+    )
+
+
+@fixture
+def transient_simulation(transient_rst):
+    return dpf.load_simulation(
+        data_sources=transient_rst,
+        simulation_type=AvailableSimulationTypes.transient_mechanical,
+    )
 
 
 def test_simulation_results(static_simulation):
@@ -414,3 +426,26 @@ def test_element_nodal_forces_elemental(self, allkindofcomplexity):
         assert field.component_count == 3
         assert field.data.shape == (9433, 3)
         assert np.allclose(field.data, field_ref.data)
+
+
+class TestTransientMechanicalSimulation:
+    def test_displacement(self, transient_simulation):
+        displacement_x = transient_simulation.displacement(
+            component_ids=["X"], nodes=[2, 3, 4], time_step_ids=[2]
+        )
+        assert len(displacement_x._fc) == 1
+        assert displacement_x._fc.get_time_scoping().ids == [2]
+        field = displacement_x._fc[0]
+        op = transient_simulation._model.operator("UX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
+            [2, 3, 4], server=transient_simulation._model._server
+        )
+        op.connect(1, mesh_scoping)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert field.data.shape == (3,)
+        assert np.allclose(field.data, field_ref.data)

From 83a262a4e0d927cfc067fc1d87c6508d70e030ab Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Fri, 10 Feb 2023 15:16:28 +0100
Subject: [PATCH 03/33] Add TransientMechanicalSimulation.velocity and
 acceleration

---
 src/ansys/dpf/post/simulation.py | 102 +++++++++++++++++++++++++++++++
 tests/test_simulation.py         |  54 ++++++++++++++--
 2 files changed, 150 insertions(+), 6 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 42fcdb362..50b6b8058 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -4341,6 +4341,108 @@ def displacement(
             named_selection=named_selection,
         )
 
+    def velocity(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract velocity results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="V",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def acceleration(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract acceleration results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="A",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
 
 class ModalMechanicalSimulation(MechanicalSimulation):
     """Provides methods for mechanical modal simulations."""
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index 88f611348..8e4854185 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -16,9 +16,9 @@ def static_simulation(static_rst):
 
 
 @fixture
-def transient_simulation(transient_rst):
+def transient_simulation(plate_msup):
     return dpf.load_simulation(
-        data_sources=transient_rst,
+        data_sources=plate_msup,
         simulation_type=AvailableSimulationTypes.transient_mechanical,
     )
 
@@ -430,12 +430,12 @@ def test_element_nodal_forces_elemental(self, allkindofcomplexity):
 
 class TestTransientMechanicalSimulation:
     def test_displacement(self, transient_simulation):
-        displacement_x = transient_simulation.displacement(
+        result = transient_simulation.displacement(
             component_ids=["X"], nodes=[2, 3, 4], time_step_ids=[2]
         )
-        assert len(displacement_x._fc) == 1
-        assert displacement_x._fc.get_time_scoping().ids == [2]
-        field = displacement_x._fc[0]
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
         op = transient_simulation._model.operator("UX")
         time_scoping = core.time_freq_scoping_factory.scoping_by_set(
             2, server=transient_simulation._model._server
@@ -449,3 +449,45 @@ def test_displacement(self, transient_simulation):
         assert field.component_count == 1
         assert field.data.shape == (3,)
         assert np.allclose(field.data, field_ref.data)
+
+    def test_velocity(self, transient_simulation):
+        result = transient_simulation.velocity(
+            component_ids=["X"], nodes=[2, 3, 4], time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("VX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
+            [2, 3, 4], server=transient_simulation._model._server
+        )
+        op.connect(1, mesh_scoping)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert field.data.shape == (3,)
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_acceleration(self, transient_simulation):
+        result = transient_simulation.acceleration(
+            component_ids=["X"], nodes=[2, 3, 4], time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("AX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
+            [2, 3, 4], server=transient_simulation._model._server
+        )
+        op.connect(1, mesh_scoping)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert field.data.shape == (3,)
+        assert np.allclose(field.data, field_ref.data)

From 062cb03abc58082352dae12358e9eaa95bd78201 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Fri, 10 Feb 2023 15:30:21 +0100
Subject: [PATCH 04/33] Add TransientMechanicalSimulation.stress and all
 variants

---
 src/ansys/dpf/post/simulation.py | 402 +++++++++++++++++++++++++++++++
 tests/test_simulation.py         | 143 +++++++++++
 2 files changed, 545 insertions(+)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 50b6b8058..911a754e6 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -4443,6 +4443,408 @@ def acceleration(
             named_selection=named_selection,
         )
 
+    def stress(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_principal(
+        self,
+        component_ids: Union[List[str], List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal principal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_principal_elemental(
+        self,
+        component_ids: Union[List[str], List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental principal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_principal_nodal(
+        self,
+        component_ids: Union[List[str], List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal principal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_eqv_von_mises(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal equivalent Von Mises stress results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_eqv_von_mises_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental equivalent Von Mises stress results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_eqv_von_mises_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal equivalent Von Mises stress results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
 
 class ModalMechanicalSimulation(MechanicalSimulation):
     """Provides methods for mechanical modal simulations."""
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index 8e4854185..cff41775b 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -491,3 +491,146 @@ def test_acceleration(self, transient_simulation):
         assert field.component_count == 1
         assert field.data.shape == (3,)
         assert np.allclose(field.data, field_ref.data)
+
+    def test_stress(self, transient_simulation):
+        result = transient_simulation.stress(component_ids=1, time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("SX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental_nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_stress_elemental(self, transient_simulation):
+        result = transient_simulation.stress_elemental(
+            component_ids=1, time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("SX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_stress_nodal(self, transient_simulation):
+        result = transient_simulation.stress_nodal(component_ids=1, time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("SX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_stress_principal(self, transient_simulation):
+        result = transient_simulation.stress_principal(
+            component_ids=1, time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("S1")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental_nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_stress_principal_nodal(self, transient_simulation):
+        result = transient_simulation.stress_principal_nodal(
+            component_ids=2, time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("S2")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_stress_principal_elemental(self, transient_simulation):
+        result = transient_simulation.stress_principal_elemental(
+            component_ids=3, time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("S3")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_stress_eqv_von_mises(self, transient_simulation):
+        result = transient_simulation.stress_eqv_von_mises(time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("S_eqv")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental_nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_stress_eqv_von_mises_elemental(self, transient_simulation):
+        result = transient_simulation.stress_eqv_von_mises_elemental(time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("S_eqv")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_stress_eqv_von_mises_nodal(self, transient_simulation):
+        result = transient_simulation.stress_eqv_von_mises_nodal(time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("S_eqv")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)

From 3bdba4b4e5043b212b8196fcc5f7aacbb2f2c787 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Fri, 10 Feb 2023 15:54:06 +0100
Subject: [PATCH 05/33] Add TransientMechanicalSimulation.elastic_strain and
 all variants

---
 src/ansys/dpf/post/simulation.py | 404 +++++++++++++++++++++++++++++++
 1 file changed, 404 insertions(+)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 911a754e6..b6d0e5444 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -4845,6 +4845,410 @@ def stress_eqv_von_mises_nodal(
             named_selection=named_selection,
         )
 
+    def elastic_strain(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_principal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal principal elastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_principal_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal principal elastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_principal_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental principal elastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_eqv(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal equivalent elastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_equivalent_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal equivalent elastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_equivalent_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental equivalent elastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
 
 class ModalMechanicalSimulation(MechanicalSimulation):
     """Provides methods for mechanical modal simulations."""

From 63774eaad9fb33646853c8bc2d97a9e112ee95cf Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Fri, 10 Feb 2023 16:09:11 +0100
Subject: [PATCH 06/33] Move TransientMechanicalSimulation and
 StaticMechanicalSimulation to individual modules

---
 src/ansys/dpf/post/common.py                  |    4 +-
 src/ansys/dpf/post/simulation.py              | 4807 -----------------
 .../dpf/post/static_mechanical_simulation.py  | 3667 +++++++++++++
 .../post/transient_mechanical_simulation.py   | 2713 ++++++++++
 tests/test_load_simulation.py                 |    4 +-
 5 files changed, 6384 insertions(+), 4811 deletions(-)
 create mode 100644 src/ansys/dpf/post/static_mechanical_simulation.py
 create mode 100644 src/ansys/dpf/post/transient_mechanical_simulation.py

diff --git a/src/ansys/dpf/post/common.py b/src/ansys/dpf/post/common.py
index 9f9b97ee6..5c581c995 100644
--- a/src/ansys/dpf/post/common.py
+++ b/src/ansys/dpf/post/common.py
@@ -3,9 +3,9 @@
 from ansys.dpf.post.simulation import (
     HarmonicMechanicalSimulation,
     ModalMechanicalSimulation,
-    StaticMechanicalSimulation,
-    TransientMechanicalSimulation,
 )
+from ansys.dpf.post.static_mechanical_simulation import StaticMechanicalSimulation
+from ansys.dpf.post.transient_mechanical_simulation import TransientMechanicalSimulation
 
 # class ElShapes(Enum):
 #     """Class with Enum inheritance. This class must be used to
diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index b6d0e5444..1ea6ad810 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -3,13 +3,11 @@
 from enum import Enum
 import re
 from typing import List, Union
-import warnings
 
 from ansys.dpf.core import DataSources, Model
 from ansys.dpf.core.plotter import DpfPlotter
 
 from ansys.dpf import core
-from ansys.dpf.post.data_object import DataObject
 from ansys.dpf.post.mesh import Mesh
 from ansys.dpf.post.selection import Selection
 
@@ -445,4811 +443,6 @@ def _build_mesh_scoping(
         return mesh_scoping
 
 
-class StaticMechanicalSimulation(MechanicalSimulation):
-    """Provides methods for mechanical static simulations."""
-
-    def _build_time_freq_scoping(
-        self,
-        selection: Union[Selection, None],
-        times: Union[float, List[float], None],
-        set_ids: Union[int, List[int], None],
-        load_steps: Union[int, List[int], None],
-        sub_steps: Union[int, List[int], None],
-    ) -> core.time_freq_scoping_factory.Scoping:
-        """Generate a time_freq_scoping from input arguments."""
-        # create from selection in priority
-        if selection:
-            return selection.time_freq_selection._evaluate_on(simulation=self)
-        # else from set_ids
-        if set_ids:
-            if isinstance(set_ids, int):
-                set_ids = [set_ids]
-            return core.time_freq_scoping_factory.scoping_by_sets(
-                cumulative_sets=set_ids, server=self._model._server
-            )
-        # else from times
-        if times:
-            if isinstance(times, float):
-                times = [times]
-            raise NotImplementedError
-        # else from sub_steps and load_steps
-        if sub_steps:
-            if isinstance(sub_steps, int):
-                sub_steps = [sub_steps]
-            if isinstance(load_steps, int):
-                load_steps = [load_steps]
-            elif (
-                not load_steps
-                or (isinstance(load_steps, list) and len(load_steps)) != 1
-            ):
-                raise ValueError(
-                    "Argument sub_steps requires argument load_steps to have one value."
-                )
-            # Translate to cumulative indices (set IDs)
-            set_ids = []
-            for sub_step in sub_steps:
-                set_id = (
-                    self._model.metadata.time_freq_support.get_cumulative_index(
-                        step=load_steps[0] - 1, substep=sub_step
-                    )
-                    + 2
-                )
-                set_ids.append(set_id)
-            return core.time_freq_scoping_factory.scoping_by_sets(
-                cumulative_sets=set_ids, server=self._model._server
-            )
-        # else load_steps only
-        if load_steps:
-            if isinstance(load_steps, int):
-                load_steps = [load_steps]
-            return core.time_freq_scoping_factory.scoping_by_load_steps(
-                load_steps=load_steps, server=self._model._server
-            )
-        # Otherwise, no argument was given, create a time_freq_scoping of the whole results
-        return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
-
-    def _get_result(
-        self,
-        base_name: str,
-        location: str,
-        category: ResultCategory,
-        components: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract stress results from the simulation.
-
-        Args:
-            base_name:
-                Base name for the requested result.
-            location:
-                Location requested.
-            category:
-                Type of result requested. See the :class:`ResultCategory` class.
-            components:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        # Build the targeted time scoping
-        time_scoping = self._build_time_freq_scoping(
-            selection, times, set_ids, load_steps, sub_steps
-        )
-
-        # Build the targeted mesh scoping
-        mesh_scoping = self._build_mesh_scoping(
-            selection,
-            nodes,
-            elements,
-            named_selection,
-            location=location,
-        )
-
-        # Build the list of requested results
-        if category in [ResultCategory.scalar, ResultCategory.equivalent]:
-            # A scalar or equivalent result has no components
-            to_extract = None
-            columns = [base_name]
-        elif category in [ResultCategory.vector, ResultCategory.matrix]:
-            # A matrix or vector result can have components selected
-            to_extract, columns = self._build_components_from_components(
-                base_name=base_name, category=category, components=components
-            )
-        elif category == ResultCategory.principal:
-            # A principal type of result can have components selected
-            to_extract, columns = self._build_components_from_principal(
-                base_name=base_name, components=components
-            )
-        else:
-            raise ValueError(f"'{category}' is not a valid category value.")
-
-        # Initialize a workflow
-        wf = core.Workflow(server=self._model._server)
-        wf.progress_bar = False
-
-        # Instantiate the main result operator
-        result_op = self._build_result_operator(
-            name=base_name,
-            time_scoping=time_scoping,
-            mesh_scoping=mesh_scoping,
-            location=location,
-        )
-        # Its output is selected as future workflow output for now
-        out = result_op.outputs.fields_container
-
-        # Add a step to compute principal invariants if result is principal
-        if category == ResultCategory.principal:
-            # Instantiate the required operator
-            principal_op = self._model.operator(name="eig_values_fc")
-            principal_op.connect(0, out)
-            wf.add_operator(operator=principal_op)
-            # Set as future output of the workflow
-            out = principal_op.outputs.fields_container
-
-        # Add a step to compute equivalent if result is equivalent
-        elif category == ResultCategory.equivalent:
-            # If a stress result, use one operator
-            if base_name[0] == "S":
-                equivalent_op = self._model.operator(name="segalmaneqv_fc")
-            # If a strain result, use another
-            elif base_name[0] == "E":
-                equivalent_op = self._model.operator(name="eqv_fc")
-            # Throw otherwise
-            else:
-                raise ValueError(
-                    f"Category {ResultCategory.equivalent} "
-                    "is only available for stress or strain results."
-                )
-            equivalent_op.connect(0, out)
-            wf.add_operator(operator=equivalent_op)
-            # Set as future output of the workflow
-            out = equivalent_op.outputs.fields_container
-
-        # Add an optional component selection step if result is vector, matrix, or principal
-        if (
-            category
-            in [ResultCategory.vector, ResultCategory.matrix, ResultCategory.principal]
-        ) and (to_extract is not None):
-            # Instantiate a component selector operator
-            extract_op = self._model.operator(name="component_selector_fc")
-            # Feed it the current workflow output
-            extract_op.connect(0, out)
-            # Feed it the requested components
-            extract_op.connect(1, to_extract)
-            wf.add_operator(operator=extract_op)
-            # Set as future output of the workflow
-            out = extract_op.outputs.fields_container
-
-        # Add an optional norm operation if requested
-        if norm:
-            norm_op = self._model.operator(name="norm_fc")
-            norm_op.connect(0, out)
-            wf.add_operator(operator=norm_op)
-            out = norm_op.outputs.fields_container
-
-        # Set the workflow output
-        wf.set_output_name("out", out)
-        # Evaluate  the workflow
-        fc = wf.get_output("out", core.types.fields_container)
-
-        # Test for empty results
-        if (len(fc) == 0) or all([len(f) == 0 for f in fc]):
-            warnings.warn(
-                message=f"Returned Dataframe with columns {columns} is empty.",
-                category=UserWarning,
-            )
-        # Return the result wrapped in a DPF_Dataframe
-        return DataObject(
-            fields_container=fc,
-            columns=columns,
-            mesh_scoping=mesh_scoping,
-        )
-
-    def displacement(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract displacement results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                Times to get results for.
-            set_ids:
-                Sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                Load steps to get results for.
-            sub_steps:
-                Sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="U",
-            location=core.locations.nodal,
-            category=ResultCategory.vector,
-            components=component_ids,
-            norm=norm,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_principal(
-        self,
-        component_ids: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal principal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_principal_elemental(
-        self,
-        component_ids: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental principal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_principal_nodal(
-        self,
-        component_ids: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal principal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_eqv_von_mises(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal equivalent Von Mises stress results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_eqv_von_mises_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental equivalent Von Mises stress results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_eqv_von_mises_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal equivalent Von Mises stress results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_principal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal principal elastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_principal_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal principal elastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_principal_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental principal elastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_eqv(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_equivalent_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_equivalent_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_state_variable(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal plastic state variable results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENL_PSV",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_state_variable_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental plastic state variable results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENL_PSV",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_state_variable_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal plastic state variable results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENL_PSV",
-            location=core.locations.nodal,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_strain(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal plastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPPL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_strain_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal plastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPPL",
-            location=core.locations.nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_strain_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental plastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPPL",
-            location=core.locations.elemental,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_strain_principal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal principal plastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPPL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_strain_principal_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal principal plastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPPL",
-            location=core.locations.nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_strain_principal_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental principal plastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPPL",
-            location=core.locations.elemental,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_strain_eqv(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal equivalent plastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPPL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_strain_equivalent_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal equivalent plastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPPL",
-            location=core.locations.nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def plastic_strain_equivalent_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental equivalent plastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPPL",
-            location=core.locations.elemental,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def creep_strain(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal creep strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ECR",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def creep_strain_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal creep strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ECR",
-            location=core.locations.nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def creep_strain_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental creep strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ECR",
-            location=core.locations.elemental,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def creep_strain_principal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal principal creep strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ECR",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def creep_strain_principal_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal principal creep strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ECR",
-            location=core.locations.nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def creep_strain_principal_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental principal creep strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ECR",
-            location=core.locations.elemental,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def creep_strain_eqv(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal equivalent creep strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ECR",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def creep_strain_equivalent_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal equivalent creep strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ECR",
-            location=core.locations.nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def creep_strain_equivalent_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental equivalent creep strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ECR",
-            location=core.locations.elemental,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def reaction_force(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract reaction force results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="RF",
-            location=core.locations.nodal,
-            category=ResultCategory.vector,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elemental_volume(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental volume results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENG_VOL",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elemental_mass(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental mass results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ElementalMass",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elemental_heat_generation(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental heat generation results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EHC",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def element_centroids(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract element centroids results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="centroids",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def thickness(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract element thickness results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="thickness",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def element_orientations(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal element orientations results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EUL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def element_orientations_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental element orientations results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EUL",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def element_orientations_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal element orientations results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EUL",
-            location=core.locations.nodal,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stiffness_matrix_energy(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract stiffness matrix energy results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENG_SE",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components="",
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def artificial_hourglass_energy(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract artificial hourglass energy results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENG_AHO",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components="",
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def thermal_dissipation_energy(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract thermal dissipation energy results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENG_TH",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components="",
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def kinetic_energy(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract kinetic energy results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENG_KE",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components="",
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def hydrostatic_pressure(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract hydrostatic pressure element nodal results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENL_HPRES",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def hydrostatic_pressure_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract hydrostatic pressure nodal results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENL_HPRES",
-            location=core.locations.nodal,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def hydrostatic_pressure_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract hydrostatic pressure elemental results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENL_HPRES",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def structural_temperature(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract structural temperature element nodal results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="BFE",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.scalar,
-            components="",
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def structural_temperature_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract structural temperature nodal results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="BFE",
-            location=core.locations.nodal,
-            category=ResultCategory.scalar,
-            components="",
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def structural_temperature_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract structural temperature elemental results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="BFE",
-            location=core.locations.elemental,
-            category=ResultCategory.scalar,
-            components="",
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def element_nodal_forces(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract element nodal forces results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENF",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.vector,
-            components=component_ids,
-            norm=norm,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def element_nodal_forces_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract element nodal forces nodal results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENF",
-            location=core.locations.nodal,
-            category=ResultCategory.vector,
-            components=component_ids,
-            norm=norm,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def element_nodal_forces_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract element nodal forces elemental results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="ENF",
-            location=core.locations.elemental,
-            category=ResultCategory.vector,
-            components=component_ids,
-            norm=norm,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def nodal_force(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal force results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                Times to get results for.
-            set_ids:
-                Sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                Load steps to get results for.
-            sub_steps:
-                Sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="F",
-            location=core.locations.nodal,
-            category=ResultCategory.vector,
-            components=component_ids,
-            norm=norm,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def nodal_moment(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal moment results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                Times to get results for.
-            set_ids:
-                Sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                Load steps to get results for.
-            sub_steps:
-                Sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="M",
-            location=core.locations.nodal,
-            category=ResultCategory.vector,
-            components=component_ids,
-            norm=norm,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-
-class TransientMechanicalSimulation(MechanicalSimulation):
-    """Provides methods for mechanical transient simulations."""
-
-    def _build_time_freq_scoping(
-        self,
-        selection: Union[Selection, None],
-        times: Union[float, List[float], None],
-        time_step_ids: Union[int, List[int], None],
-    ) -> core.time_freq_scoping_factory.Scoping:
-        """Generate a time_freq_scoping from input arguments."""
-        # create from selection in priority
-        if selection:
-            return selection.time_freq_selection._evaluate_on(simulation=self)
-        # else from time_step_ids
-        if time_step_ids:
-            if isinstance(time_step_ids, int):
-                time_step_ids = [time_step_ids]
-            return core.time_freq_scoping_factory.scoping_by_sets(
-                cumulative_sets=time_step_ids, server=self._model._server
-            )
-        # else from times
-        if times:
-            if isinstance(times, float):
-                times = [times]
-            raise NotImplementedError
-        # Otherwise, no argument was given, create a time_freq_scoping of the whole results
-        return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
-
-    def _get_result(
-        self,
-        base_name: str,
-        location: str,
-        category: ResultCategory,
-        components: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract stress results from the simulation.
-
-        Args:
-            base_name:
-                Base name for the requested result.
-            location:
-                Location requested.
-            category:
-                Type of result requested. See the :class:`ResultCategory` class.
-            components:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        # Build the targeted time scoping
-        time_scoping = self._build_time_freq_scoping(selection, times, time_step_ids)
-
-        # Build the targeted mesh scoping
-        mesh_scoping = self._build_mesh_scoping(
-            selection,
-            nodes,
-            elements,
-            named_selection,
-            location=location,
-        )
-
-        # Build the list of requested results
-        if category in [ResultCategory.scalar, ResultCategory.equivalent]:
-            # A scalar or equivalent result has no components
-            to_extract = None
-            columns = [base_name]
-        elif category in [ResultCategory.vector, ResultCategory.matrix]:
-            # A matrix or vector result can have components selected
-            to_extract, columns = self._build_components_from_components(
-                base_name=base_name, category=category, components=components
-            )
-        elif category == ResultCategory.principal:
-            # A principal type of result can have components selected
-            to_extract, columns = self._build_components_from_principal(
-                base_name=base_name, components=components
-            )
-        else:
-            raise ValueError(f"'{category}' is not a valid category value.")
-
-        # Initialize a workflow
-        wf = core.Workflow(server=self._model._server)
-        wf.progress_bar = False
-
-        # Instantiate the main result operator
-        result_op = self._build_result_operator(
-            name=base_name,
-            time_scoping=time_scoping,
-            mesh_scoping=mesh_scoping,
-            location=location,
-        )
-        # Its output is selected as future workflow output for now
-        out = result_op.outputs.fields_container
-
-        # Add a step to compute principal invariants if result is principal
-        if category == ResultCategory.principal:
-            # Instantiate the required operator
-            principal_op = self._model.operator(name="eig_values_fc")
-            principal_op.connect(0, out)
-            wf.add_operator(operator=principal_op)
-            # Set as future output of the workflow
-            out = principal_op.outputs.fields_container
-
-        # Add a step to compute equivalent if result is equivalent
-        elif category == ResultCategory.equivalent:
-            # If a stress result, use one operator
-            if base_name[0] == "S":
-                equivalent_op = self._model.operator(name="segalmaneqv_fc")
-            # If a strain result, use another
-            elif base_name[0] == "E":
-                equivalent_op = self._model.operator(name="eqv_fc")
-            # Throw otherwise
-            else:
-                raise ValueError(
-                    f"Category {ResultCategory.equivalent} "
-                    "is only available for stress or strain results."
-                )
-            equivalent_op.connect(0, out)
-            wf.add_operator(operator=equivalent_op)
-            # Set as future output of the workflow
-            out = equivalent_op.outputs.fields_container
-
-        # Add an optional component selection step if result is vector, matrix, or principal
-        if (
-            category
-            in [ResultCategory.vector, ResultCategory.matrix, ResultCategory.principal]
-        ) and (to_extract is not None):
-            # Instantiate a component selector operator
-            extract_op = self._model.operator(name="component_selector_fc")
-            # Feed it the current workflow output
-            extract_op.connect(0, out)
-            # Feed it the requested components
-            extract_op.connect(1, to_extract)
-            wf.add_operator(operator=extract_op)
-            # Set as future output of the workflow
-            out = extract_op.outputs.fields_container
-
-        # Add an optional norm operation if requested
-        if norm:
-            norm_op = self._model.operator(name="norm_fc")
-            norm_op.connect(0, out)
-            wf.add_operator(operator=norm_op)
-            out = norm_op.outputs.fields_container
-
-        # Set the workflow output
-        wf.set_output_name("out", out)
-        # Evaluate  the workflow
-        fc = wf.get_output("out", core.types.fields_container)
-
-        # Test for empty results
-        if (len(fc) == 0) or all([len(f) == 0 for f in fc]):
-            warnings.warn(
-                message=f"Returned Dataframe with columns {columns} is empty.",
-                category=UserWarning,
-            )
-        # Return the result wrapped in a DPF_Dataframe
-        return DataObject(
-            fields_container=fc,
-            columns=columns,
-            mesh_scoping=mesh_scoping,
-        )
-
-    def displacement(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract displacement results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                Times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="U",
-            location=core.locations.nodal,
-            category=ResultCategory.vector,
-            components=component_ids,
-            norm=norm,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def velocity(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract velocity results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                Times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="V",
-            location=core.locations.nodal,
-            category=ResultCategory.vector,
-            components=component_ids,
-            norm=norm,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def acceleration(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract acceleration results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            norm:
-                Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                Times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="A",
-            location=core.locations.nodal,
-            category=ResultCategory.vector,
-            components=component_ids,
-            norm=norm,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_principal(
-        self,
-        component_ids: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal principal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_principal_elemental(
-        self,
-        component_ids: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental principal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_principal_nodal(
-        self,
-        component_ids: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal principal stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_eqv_von_mises(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal equivalent Von Mises stress results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_eqv_von_mises_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental equivalent Von Mises stress results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.elemental,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def stress_eqv_von_mises_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal equivalent Von Mises stress results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="S",
-            location=core.locations.nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.nodal,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract stress results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental,
-            category=ResultCategory.matrix,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_principal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal principal elastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_principal_nodal(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal principal elastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.nodal,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_principal_elemental(
-        self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental principal elastic strain results from the simulation.
-
-        Args:
-            component_ids:
-                Components to get results for.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental,
-            category=ResultCategory.principal,
-            components=component_ids,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_eqv(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_equivalent_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_equivalent_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-
 class ModalMechanicalSimulation(MechanicalSimulation):
     """Provides methods for mechanical modal simulations."""
 
diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
new file mode 100644
index 000000000..11516d3ed
--- /dev/null
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -0,0 +1,3667 @@
+"""Module containing the ``StaticMechanicalSimulation`` class."""
+from typing import List, Union
+import warnings
+
+from ansys.dpf import core
+from ansys.dpf.post.data_object import DataObject
+from ansys.dpf.post.selection import Selection
+from ansys.dpf.post.simulation import MechanicalSimulation, ResultCategory
+
+
+class StaticMechanicalSimulation(MechanicalSimulation):
+    """Provides methods for mechanical static simulations."""
+
+    def _build_time_freq_scoping(
+        self,
+        selection: Union[Selection, None],
+        times: Union[float, List[float], None],
+        set_ids: Union[int, List[int], None],
+        load_steps: Union[int, List[int], None],
+        sub_steps: Union[int, List[int], None],
+    ) -> core.time_freq_scoping_factory.Scoping:
+        """Generate a time_freq_scoping from input arguments."""
+        # create from selection in priority
+        if selection:
+            return selection.time_freq_selection._evaluate_on(simulation=self)
+        # else from set_ids
+        if set_ids:
+            if isinstance(set_ids, int):
+                set_ids = [set_ids]
+            return core.time_freq_scoping_factory.scoping_by_sets(
+                cumulative_sets=set_ids, server=self._model._server
+            )
+        # else from times
+        if times:
+            if isinstance(times, float):
+                times = [times]
+            raise NotImplementedError
+        # else from sub_steps and load_steps
+        if sub_steps:
+            if isinstance(sub_steps, int):
+                sub_steps = [sub_steps]
+            if isinstance(load_steps, int):
+                load_steps = [load_steps]
+            elif (
+                not load_steps
+                or (isinstance(load_steps, list) and len(load_steps)) != 1
+            ):
+                raise ValueError(
+                    "Argument sub_steps requires argument load_steps to have one value."
+                )
+            # Translate to cumulative indices (set IDs)
+            set_ids = []
+            for sub_step in sub_steps:
+                set_id = (
+                    self._model.metadata.time_freq_support.get_cumulative_index(
+                        step=load_steps[0] - 1, substep=sub_step
+                    )
+                    + 2
+                )
+                set_ids.append(set_id)
+            return core.time_freq_scoping_factory.scoping_by_sets(
+                cumulative_sets=set_ids, server=self._model._server
+            )
+        # else load_steps only
+        if load_steps:
+            if isinstance(load_steps, int):
+                load_steps = [load_steps]
+            return core.time_freq_scoping_factory.scoping_by_load_steps(
+                load_steps=load_steps, server=self._model._server
+            )
+        # Otherwise, no argument was given, create a time_freq_scoping of the whole results
+        return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
+
+    def _get_result(
+        self,
+        base_name: str,
+        location: str,
+        category: ResultCategory,
+        components: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            base_name:
+                Base name for the requested result.
+            location:
+                Location requested.
+            category:
+                Type of result requested. See the :class:`ResultCategory` class.
+            components:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        # Build the targeted time scoping
+        time_scoping = self._build_time_freq_scoping(
+            selection, times, set_ids, load_steps, sub_steps
+        )
+
+        # Build the targeted mesh scoping
+        mesh_scoping = self._build_mesh_scoping(
+            selection,
+            nodes,
+            elements,
+            named_selection,
+            location=location,
+        )
+
+        # Build the list of requested results
+        if category in [ResultCategory.scalar, ResultCategory.equivalent]:
+            # A scalar or equivalent result has no components
+            to_extract = None
+            columns = [base_name]
+        elif category in [ResultCategory.vector, ResultCategory.matrix]:
+            # A matrix or vector result can have components selected
+            to_extract, columns = self._build_components_from_components(
+                base_name=base_name, category=category, components=components
+            )
+        elif category == ResultCategory.principal:
+            # A principal type of result can have components selected
+            to_extract, columns = self._build_components_from_principal(
+                base_name=base_name, components=components
+            )
+        else:
+            raise ValueError(f"'{category}' is not a valid category value.")
+
+        # Initialize a workflow
+        wf = core.Workflow(server=self._model._server)
+        wf.progress_bar = False
+
+        # Instantiate the main result operator
+        result_op = self._build_result_operator(
+            name=base_name,
+            time_scoping=time_scoping,
+            mesh_scoping=mesh_scoping,
+            location=location,
+        )
+        # Its output is selected as future workflow output for now
+        out = result_op.outputs.fields_container
+
+        # Add a step to compute principal invariants if result is principal
+        if category == ResultCategory.principal:
+            # Instantiate the required operator
+            principal_op = self._model.operator(name="eig_values_fc")
+            principal_op.connect(0, out)
+            wf.add_operator(operator=principal_op)
+            # Set as future output of the workflow
+            out = principal_op.outputs.fields_container
+
+        # Add a step to compute equivalent if result is equivalent
+        elif category == ResultCategory.equivalent:
+            # If a stress result, use one operator
+            if base_name[0] == "S":
+                equivalent_op = self._model.operator(name="segalmaneqv_fc")
+            # If a strain result, use another
+            elif base_name[0] == "E":
+                equivalent_op = self._model.operator(name="eqv_fc")
+            # Throw otherwise
+            else:
+                raise ValueError(
+                    f"Category {ResultCategory.equivalent} "
+                    "is only available for stress or strain results."
+                )
+            equivalent_op.connect(0, out)
+            wf.add_operator(operator=equivalent_op)
+            # Set as future output of the workflow
+            out = equivalent_op.outputs.fields_container
+
+        # Add an optional component selection step if result is vector, matrix, or principal
+        if (
+            category
+            in [ResultCategory.vector, ResultCategory.matrix, ResultCategory.principal]
+        ) and (to_extract is not None):
+            # Instantiate a component selector operator
+            extract_op = self._model.operator(name="component_selector_fc")
+            # Feed it the current workflow output
+            extract_op.connect(0, out)
+            # Feed it the requested components
+            extract_op.connect(1, to_extract)
+            wf.add_operator(operator=extract_op)
+            # Set as future output of the workflow
+            out = extract_op.outputs.fields_container
+
+        # Add an optional norm operation if requested
+        if norm:
+            norm_op = self._model.operator(name="norm_fc")
+            norm_op.connect(0, out)
+            wf.add_operator(operator=norm_op)
+            out = norm_op.outputs.fields_container
+
+        # Set the workflow output
+        wf.set_output_name("out", out)
+        # Evaluate  the workflow
+        fc = wf.get_output("out", core.types.fields_container)
+
+        # Test for empty results
+        if (len(fc) == 0) or all([len(f) == 0 for f in fc]):
+            warnings.warn(
+                message=f"Returned Dataframe with columns {columns} is empty.",
+                category=UserWarning,
+            )
+        # Return the result wrapped in a DPF_Dataframe
+        return DataObject(
+            fields_container=fc,
+            columns=columns,
+            mesh_scoping=mesh_scoping,
+        )
+
+    def displacement(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract displacement results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            set_ids:
+                Sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                Load steps to get results for.
+            sub_steps:
+                Sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="U",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_principal(
+        self,
+        component_ids: Union[List[str], List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        set_ids: Union[List[int], None] = None,
+        load_steps: Union[List[int], None] = None,
+        sub_steps: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal principal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_principal_elemental(
+        self,
+        component_ids: Union[List[str], List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        set_ids: Union[List[int], None] = None,
+        load_steps: Union[List[int], None] = None,
+        sub_steps: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental principal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_principal_nodal(
+        self,
+        component_ids: Union[List[str], List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        set_ids: Union[List[int], None] = None,
+        load_steps: Union[List[int], None] = None,
+        sub_steps: Union[List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal principal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_eqv_von_mises(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        set_ids: Union[List[int], None] = None,
+        load_steps: Union[List[int], None] = None,
+        sub_steps: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal equivalent Von Mises stress results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_eqv_von_mises_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        set_ids: Union[List[int], None] = None,
+        load_steps: Union[List[int], None] = None,
+        sub_steps: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental equivalent Von Mises stress results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_eqv_von_mises_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        set_ids: Union[List[int], None] = None,
+        load_steps: Union[List[int], None] = None,
+        sub_steps: Union[List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal equivalent Von Mises stress results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_principal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal principal elastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_principal_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal principal elastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_principal_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental principal elastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_eqv(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal equivalent elastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_equivalent_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal equivalent elastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_equivalent_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental equivalent elastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_state_variable(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal plastic state variable results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_PSV",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_state_variable_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental plastic state variable results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_PSV",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_state_variable_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal plastic state variable results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_PSV",
+            location=core.locations.nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_principal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal principal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_principal_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal principal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_principal_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental principal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_eqv(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal equivalent plastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_equivalent_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal equivalent plastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_equivalent_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental equivalent plastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def creep_strain(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal creep strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ECR",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def creep_strain_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal creep strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ECR",
+            location=core.locations.nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def creep_strain_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental creep strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ECR",
+            location=core.locations.elemental,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def creep_strain_principal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal principal creep strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ECR",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def creep_strain_principal_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal principal creep strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ECR",
+            location=core.locations.nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def creep_strain_principal_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental principal creep strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ECR",
+            location=core.locations.elemental,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def creep_strain_eqv(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal equivalent creep strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ECR",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def creep_strain_equivalent_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal equivalent creep strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ECR",
+            location=core.locations.nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def creep_strain_equivalent_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental equivalent creep strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ECR",
+            location=core.locations.elemental,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def reaction_force(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract reaction force results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="RF",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elemental_volume(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental volume results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENG_VOL",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elemental_mass(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental mass results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ElementalMass",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elemental_heat_generation(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental heat generation results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EHC",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_centroids(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element centroids results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="centroids",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def thickness(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element thickness results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="thickness",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_orientations(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal element orientations results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EUL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_orientations_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental element orientations results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EUL",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_orientations_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal element orientations results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EUL",
+            location=core.locations.nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stiffness_matrix_energy(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stiffness matrix energy results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENG_SE",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def artificial_hourglass_energy(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract artificial hourglass energy results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENG_AHO",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def thermal_dissipation_energy(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract thermal dissipation energy results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENG_TH",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def kinetic_energy(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract kinetic energy results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENG_KE",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def hydrostatic_pressure(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract hydrostatic pressure element nodal results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_HPRES",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def hydrostatic_pressure_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract hydrostatic pressure nodal results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_HPRES",
+            location=core.locations.nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def hydrostatic_pressure_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract hydrostatic pressure elemental results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_HPRES",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def structural_temperature(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract structural temperature element nodal results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="BFE",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def structural_temperature_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract structural temperature nodal results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="BFE",
+            location=core.locations.nodal,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def structural_temperature_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract structural temperature elemental results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="BFE",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_nodal_forces(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element nodal forces results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENF",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_nodal_forces_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element nodal forces nodal results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENF",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_nodal_forces_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element nodal forces elemental results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENF",
+            location=core.locations.elemental,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def nodal_force(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal force results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            set_ids:
+                Sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                Load steps to get results for.
+            sub_steps:
+                Sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="F",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def nodal_moment(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal moment results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            set_ids:
+                Sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                Load steps to get results for.
+            sub_steps:
+                Sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="M",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
new file mode 100644
index 000000000..2887bc55a
--- /dev/null
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -0,0 +1,2713 @@
+"""Module containing the ``TransientMechanicalSimulation`` class."""
+from typing import List, Union
+import warnings
+
+from ansys.dpf import core
+from ansys.dpf.post.data_object import DataObject
+from ansys.dpf.post.selection import Selection
+from ansys.dpf.post.simulation import MechanicalSimulation, ResultCategory
+
+
+class TransientMechanicalSimulation(MechanicalSimulation):
+    """Provides methods for mechanical transient simulations."""
+
+    def _build_time_freq_scoping(
+        self,
+        selection: Union[Selection, None],
+        times: Union[float, List[float], None],
+        time_step_ids: Union[int, List[int], None],
+    ) -> core.time_freq_scoping_factory.Scoping:
+        """Generate a time_freq_scoping from input arguments."""
+        # create from selection in priority
+        if selection:
+            return selection.time_freq_selection._evaluate_on(simulation=self)
+        # else from time_step_ids
+        if time_step_ids:
+            if isinstance(time_step_ids, int):
+                time_step_ids = [time_step_ids]
+            return core.time_freq_scoping_factory.scoping_by_sets(
+                cumulative_sets=time_step_ids, server=self._model._server
+            )
+        # else from times
+        if times:
+            if isinstance(times, float):
+                times = [times]
+            raise NotImplementedError
+        # Otherwise, no argument was given, create a time_freq_scoping of the whole results
+        return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
+
+    def _get_result(
+        self,
+        base_name: str,
+        location: str,
+        category: ResultCategory,
+        components: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            base_name:
+                Base name for the requested result.
+            location:
+                Location requested.
+            category:
+                Type of result requested. See the :class:`ResultCategory` class.
+            components:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        # Build the targeted time scoping
+        time_scoping = self._build_time_freq_scoping(selection, times, time_step_ids)
+
+        # Build the targeted mesh scoping
+        mesh_scoping = self._build_mesh_scoping(
+            selection,
+            nodes,
+            elements,
+            named_selection,
+            location=location,
+        )
+
+        # Build the list of requested results
+        if category in [ResultCategory.scalar, ResultCategory.equivalent]:
+            # A scalar or equivalent result has no components
+            to_extract = None
+            columns = [base_name]
+        elif category in [ResultCategory.vector, ResultCategory.matrix]:
+            # A matrix or vector result can have components selected
+            to_extract, columns = self._build_components_from_components(
+                base_name=base_name, category=category, components=components
+            )
+        elif category == ResultCategory.principal:
+            # A principal type of result can have components selected
+            to_extract, columns = self._build_components_from_principal(
+                base_name=base_name, components=components
+            )
+        else:
+            raise ValueError(f"'{category}' is not a valid category value.")
+
+        # Initialize a workflow
+        wf = core.Workflow(server=self._model._server)
+        wf.progress_bar = False
+
+        # Instantiate the main result operator
+        result_op = self._build_result_operator(
+            name=base_name,
+            time_scoping=time_scoping,
+            mesh_scoping=mesh_scoping,
+            location=location,
+        )
+        # Its output is selected as future workflow output for now
+        out = result_op.outputs.fields_container
+
+        # Add a step to compute principal invariants if result is principal
+        if category == ResultCategory.principal:
+            # Instantiate the required operator
+            principal_op = self._model.operator(name="eig_values_fc")
+            principal_op.connect(0, out)
+            wf.add_operator(operator=principal_op)
+            # Set as future output of the workflow
+            out = principal_op.outputs.fields_container
+
+        # Add a step to compute equivalent if result is equivalent
+        elif category == ResultCategory.equivalent:
+            # If a stress result, use one operator
+            if base_name[0] == "S":
+                equivalent_op = self._model.operator(name="segalmaneqv_fc")
+            # If a strain result, use another
+            elif base_name[0] == "E":
+                equivalent_op = self._model.operator(name="eqv_fc")
+            # Throw otherwise
+            else:
+                raise ValueError(
+                    f"Category {ResultCategory.equivalent} "
+                    "is only available for stress or strain results."
+                )
+            equivalent_op.connect(0, out)
+            wf.add_operator(operator=equivalent_op)
+            # Set as future output of the workflow
+            out = equivalent_op.outputs.fields_container
+
+        # Add an optional component selection step if result is vector, matrix, or principal
+        if (
+            category
+            in [ResultCategory.vector, ResultCategory.matrix, ResultCategory.principal]
+        ) and (to_extract is not None):
+            # Instantiate a component selector operator
+            extract_op = self._model.operator(name="component_selector_fc")
+            # Feed it the current workflow output
+            extract_op.connect(0, out)
+            # Feed it the requested components
+            extract_op.connect(1, to_extract)
+            wf.add_operator(operator=extract_op)
+            # Set as future output of the workflow
+            out = extract_op.outputs.fields_container
+
+        # Add an optional norm operation if requested
+        if norm:
+            norm_op = self._model.operator(name="norm_fc")
+            norm_op.connect(0, out)
+            wf.add_operator(operator=norm_op)
+            out = norm_op.outputs.fields_container
+
+        # Set the workflow output
+        wf.set_output_name("out", out)
+        # Evaluate  the workflow
+        fc = wf.get_output("out", core.types.fields_container)
+
+        # Test for empty results
+        if (len(fc) == 0) or all([len(f) == 0 for f in fc]):
+            warnings.warn(
+                message=f"Returned Dataframe with columns {columns} is empty.",
+                category=UserWarning,
+            )
+        # Return the result wrapped in a DPF_Dataframe
+        return DataObject(
+            fields_container=fc,
+            columns=columns,
+            mesh_scoping=mesh_scoping,
+        )
+
+    def displacement(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract displacement results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="U",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def velocity(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract velocity results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="V",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def acceleration(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract acceleration results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="A",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_principal(
+        self,
+        component_ids: Union[List[str], List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal principal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_principal_elemental(
+        self,
+        component_ids: Union[List[str], List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental principal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_principal_nodal(
+        self,
+        component_ids: Union[List[str], List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal principal stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_eqv_von_mises(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal equivalent Von Mises stress results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_eqv_von_mises_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental equivalent Von Mises stress results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.elemental,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def stress_eqv_von_mises_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal equivalent Von Mises stress results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="S",
+            location=core.locations.nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract stress results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_principal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal principal elastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_principal_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal principal elastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_principal_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental principal elastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_eqv(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal equivalent elastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_equivalent_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal equivalent elastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elastic_strain_equivalent_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental equivalent elastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPEL",
+            location=core.locations.elemental,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_state_variable(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal plastic state variable results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_PSV",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_state_variable_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental plastic state variable results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_PSV",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_state_variable_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal plastic state variable results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_PSV",
+            location=core.locations.nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.nodal,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental,
+            category=ResultCategory.matrix,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_principal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal principal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_principal_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal principal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.nodal,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_principal_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental principal plastic strain results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental,
+            category=ResultCategory.principal,
+            components=component_ids,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_eqv(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal equivalent plastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_equivalent_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal equivalent plastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.nodal,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def plastic_strain_equivalent_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental equivalent plastic strain results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EPPL",
+            location=core.locations.elemental,
+            category=ResultCategory.equivalent,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def reaction_force(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract reaction force results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="RF",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elemental_volume(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental volume results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENG_VOL",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elemental_mass(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental mass results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ElementalMass",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def elemental_heat_generation(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental heat generation results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EHC",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_centroids(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element centroids results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="centroids",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def thickness(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element thickness results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="thickness",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_orientations(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental nodal element orientations results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EUL",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_orientations_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract elemental element orientations results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EUL",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_orientations_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal element orientations results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="EUL",
+            location=core.locations.nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def artificial_hourglass_energy(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract artificial hourglass energy results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENG_AHO",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def thermal_dissipation_energy(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract thermal dissipation energy results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENG_TH",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def kinetic_energy(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract kinetic energy results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENG_KE",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def hydrostatic_pressure(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract hydrostatic pressure element nodal results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_HPRES",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def hydrostatic_pressure_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract hydrostatic pressure nodal results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_HPRES",
+            location=core.locations.nodal,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def hydrostatic_pressure_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract hydrostatic pressure elemental results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENL_HPRES",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components=None,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def structural_temperature(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract structural temperature element nodal results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="BFE",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def structural_temperature_nodal(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract structural temperature nodal results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="BFE",
+            location=core.locations.nodal,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def structural_temperature_elemental(
+        self,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract structural temperature elemental results from the simulation.
+
+        Args:
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="BFE",
+            location=core.locations.elemental,
+            category=ResultCategory.scalar,
+            components="",
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_nodal_forces(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element nodal forces results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENF",
+            location=core.locations.elemental_nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_nodal_forces_nodal(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element nodal forces nodal results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENF",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def element_nodal_forces_elemental(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract element nodal forces elemental results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            elements:
+                List of elements to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="ENF",
+            location=core.locations.elemental,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=None,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def nodal_force(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal force results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            set_ids:
+                Sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                Load steps to get results for.
+            sub_steps:
+                Sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="F",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
+
+    def nodal_moment(
+        self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
+        selection: Union[Selection, None] = None,
+        times: Union[float, List[float], None] = None,
+        time_step_ids: Union[int, List[int], None] = None,
+        nodes: Union[List[int], None] = None,
+        elements: Union[List[int], None] = None,
+        named_selection: Union[str, None] = None,
+    ) -> DataObject:
+        """Extract nodal moment results from the simulation.
+
+        Args:
+            component_ids:
+                Components to get results for.
+            norm:
+                Whether to return the norm of the results.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+            times:
+                Times to get results for.
+            set_ids:
+                Sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                Load steps to get results for.
+            sub_steps:
+                Sub-steps to get results for. Requires load_steps to be defined.
+            nodes:
+                List of nodes to get results for.
+            elements:
+                List of elements whose nodes to get results for.
+            named_selection:
+                Named selection to get results for.
+
+        Returns
+        -------
+            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
+
+        """
+        return self._get_result(
+            base_name="M",
+            location=core.locations.nodal,
+            category=ResultCategory.vector,
+            components=component_ids,
+            norm=norm,
+            selection=selection,
+            times=times,
+            time_step_ids=time_step_ids,
+            nodes=nodes,
+            elements=elements,
+            named_selection=named_selection,
+        )
diff --git a/tests/test_load_simulation.py b/tests/test_load_simulation.py
index 01bfdd501..1125211e8 100644
--- a/tests/test_load_simulation.py
+++ b/tests/test_load_simulation.py
@@ -5,9 +5,9 @@
 from ansys.dpf.post.simulation import (
     HarmonicMechanicalSimulation,
     ModalMechanicalSimulation,
-    StaticMechanicalSimulation,
-    TransientMechanicalSimulation,
 )
+from ansys.dpf.post.static_mechanical_simulation import StaticMechanicalSimulation
+from ansys.dpf.post.transient_mechanical_simulation import TransientMechanicalSimulation
 
 
 def test_load_simulation_static_mechanical(simple_bar, complex_model):

From 3dd2322cbfbff39c7cdd95bf38f34b2311764d95 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Fri, 10 Feb 2023 16:32:03 +0100
Subject: [PATCH 07/33] Confirm a first set of results for
 TransientMechanicalSimulation

---
 .../dpf/post/static_mechanical_simulation.py  | 157 +-----------
 .../post/transient_mechanical_simulation.py   | 130 +---------
 tests/test_simulation.py                      | 233 ++++++++++++++++++
 3 files changed, 237 insertions(+), 283 deletions(-)

diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index 11516d3ed..c22df66f5 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -1111,159 +1111,6 @@ def elastic_strain_principal_elemental(
             named_selection=named_selection,
         )
 
-    def elastic_strain_eqv(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_equivalent_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_equivalent_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            set_ids:
-                List of sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            set_ids=set_ids,
-            load_steps=load_steps,
-            sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
     def plastic_state_variable(
         self,
         selection: Union[Selection, None] = None,
@@ -1797,7 +1644,7 @@ def plastic_strain_eqv(
             named_selection=named_selection,
         )
 
-    def plastic_strain_equivalent_nodal(
+    def plastic_strain_eqv_nodal(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -1850,7 +1697,7 @@ def plastic_strain_equivalent_nodal(
             named_selection=named_selection,
         )
 
-    def plastic_strain_equivalent_elemental(
+    def plastic_strain_eqv_elemental(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index 2887bc55a..a32f9f2bd 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -1025,132 +1025,6 @@ def elastic_strain_principal_elemental(
             named_selection=named_selection,
         )
 
-    def elastic_strain_eqv(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental nodal equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental_nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_equivalent_nodal(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract nodal equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.nodal,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
-    def elastic_strain_equivalent_elemental(
-        self,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
-    ) -> DataObject:
-        """Extract elemental equivalent elastic strain results from the simulation.
-
-        Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
-
-        Returns
-        -------
-            Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
-
-        """
-        return self._get_result(
-            base_name="EPEL",
-            location=core.locations.elemental,
-            category=ResultCategory.equivalent,
-            components=None,
-            selection=selection,
-            times=times,
-            time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
-        )
-
     def plastic_state_variable(
         self,
         selection: Union[Selection, None] = None,
@@ -1594,7 +1468,7 @@ def plastic_strain_eqv(
             named_selection=named_selection,
         )
 
-    def plastic_strain_equivalent_nodal(
+    def plastic_strain_eqv_nodal(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -1638,7 +1512,7 @@ def plastic_strain_equivalent_nodal(
             named_selection=named_selection,
         )
 
-    def plastic_strain_equivalent_elemental(
+    def plastic_strain_eqv_elemental(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index cff41775b..8f1bedcd8 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -634,3 +634,236 @@ def test_stress_eqv_von_mises_nodal(self, transient_simulation):
         field_ref = op.eval()[0]
         assert field.component_count == 1
         assert np.allclose(field.data, field_ref.data)
+
+    def test_elastic_strain(self, transient_simulation):
+        result = transient_simulation.elastic_strain(component_ids=1, time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("EPELX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental_nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_elastic_strain_elemental(self, transient_simulation):
+        result = transient_simulation.elastic_strain_elemental(
+            component_ids=1, time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("EPELX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_elastic_strain_nodal(self, transient_simulation):
+        result = transient_simulation.elastic_strain_nodal(
+            component_ids=1, time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("EPELX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_elastic_strain_principal(self, transient_simulation):
+        result = transient_simulation.elastic_strain_principal(
+            component_ids=1, time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("EPEL1")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental_nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_elastic_strain_principal_nodal(self, transient_simulation):
+        result = transient_simulation.elastic_strain_principal_nodal(
+            component_ids=2, time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("EPEL2")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_elastic_strain_principal_elemental(self, transient_simulation):
+        result = transient_simulation.elastic_strain_principal_elemental(
+            component_ids=3, time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("EPEL3")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            2, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        op.connect(9, core.locations.elemental)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_reaction_force(self, allkindofcomplexity):
+        transient_simulation = dpf.load_simulation(
+            data_sources=allkindofcomplexity,
+            simulation_type=AvailableSimulationTypes.transient_mechanical,
+        )
+        result = transient_simulation.reaction_force(time_step_ids=[1])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [1]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("RF")
+        field_ref = op.eval()[0]
+        assert field.component_count == 3
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_elemental_volume(self, transient_simulation):
+        result = transient_simulation.elemental_volume(time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("ENG_VOL")
+        field_ref = op.eval()[0]
+        print(field_ref)
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_artificial_hourglass_energy(self, transient_simulation):
+        result = transient_simulation.artificial_hourglass_energy(time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("ENG_AHO")
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_thermal_dissipation_energy(self, transient_simulation):
+        result = transient_simulation.thermal_dissipation_energy(time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("ENG_TH")
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_kinetic_energy(self, transient_simulation):
+        result = transient_simulation.kinetic_energy(time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("ENG_KE")
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_structural_temperature(self, transient_simulation):
+        result = transient_simulation.structural_temperature(time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("BFE")
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_structural_temperature_nodal(self, transient_simulation):
+        result = transient_simulation.structural_temperature_nodal(time_step_ids=[2])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("BFE")
+        op.connect(9, core.locations.nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_structural_temperature_elemental(self, transient_simulation):
+        result = transient_simulation.structural_temperature_elemental(
+            time_step_ids=[2]
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("BFE")
+        op.connect(9, core.locations.elemental)
+        field_ref = op.eval()[0]
+        assert field.component_count == 1
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_element_nodal_forces(self, allkindofcomplexity):
+        transient_simulation = dpf.load_simulation(
+            data_sources=allkindofcomplexity,
+            simulation_type=AvailableSimulationTypes.transient_mechanical,
+        )
+        result = transient_simulation.element_nodal_forces(time_step_ids=[1])
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [1]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("ENF")
+        field_ref = op.eval()[0]
+        assert field.component_count == 3
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_element_nodal_forces_nodal(self, allkindofcomplexity):
+        transient_simulation = dpf.load_simulation(
+            data_sources=allkindofcomplexity,
+            simulation_type=AvailableSimulationTypes.transient_mechanical,
+        )
+        result = transient_simulation.element_nodal_forces_nodal(time_step_ids=[1])
+        assert len(result._fc) == 3
+        assert result._fc.get_time_scoping().ids == [1]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("ENF")
+        op.connect(9, core.locations.nodal)
+        field_ref = op.eval()[0]
+        assert field.component_count == 3
+        assert np.allclose(field.data, field_ref.data)
+
+    def test_element_nodal_forces_elemental(self, allkindofcomplexity):
+        transient_simulation = dpf.load_simulation(
+            data_sources=allkindofcomplexity,
+            simulation_type=AvailableSimulationTypes.transient_mechanical,
+        )
+        result = transient_simulation.element_nodal_forces_elemental(time_step_ids=[1])
+        assert len(result._fc) == 3
+        assert result._fc.get_time_scoping().ids == [1]
+        field = result._fc[0]
+        op = transient_simulation._model.operator("ENF")
+        op.connect(9, core.locations.elemental)
+        field_ref = op.eval()[0]
+        assert field.component_count == 3
+        assert np.allclose(field.data, field_ref.data)

From 93f99ca16a93c732b57107fc1d57d954858e1774 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 10:05:33 +0100
Subject: [PATCH 08/33] Specify available component IDs for vectorial results.

---
 .../post/transient_mechanical_simulation.py   | 34 ++++++++++++++-----
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index a32f9f2bd..bb5a86fc1 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -209,7 +209,8 @@ def displacement(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z",
+                or their respective equivalents "1", "2", "3".
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -260,7 +261,8 @@ def velocity(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z",
+                or their respective equivalents "1", "2", "3".
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -311,7 +313,8 @@ def acceleration(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z",
+                or their respective equivalents "1", "2", "3".
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -1555,6 +1558,8 @@ def plastic_strain_eqv_elemental(
 
     def reaction_force(
         self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -1565,6 +1570,11 @@ def reaction_force(
         """Extract reaction force results from the simulation.
 
         Args:
+            component_ids:
+                Components to get results for. Can be one or several of "X", "Y", "Z",
+                or their respective equivalents "1", "2", "3".
+            norm:
+                Whether to return the norm of the results.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1588,7 +1598,8 @@ def reaction_force(
             base_name="RF",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=None,
+            components=component_ids,
+            norm=norm,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -2339,7 +2350,8 @@ def element_nodal_forces(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z",
+                or their respective equivalents "1", "2", "3".
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2390,7 +2402,8 @@ def element_nodal_forces_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z",
+                or their respective equivalents "1", "2", "3".
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2440,7 +2453,8 @@ def element_nodal_forces_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z",
+                or their respective equivalents "1", "2", "3".
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2489,7 +2503,8 @@ def nodal_force(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z",
+                or their respective equivalents "1", "2", "3".
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2545,7 +2560,8 @@ def nodal_moment(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z",
+                or their respective equivalents "1", "2", "3".
             norm:
                 Whether to return the norm of the results.
             selection:

From 2d5766054e8990ddd8ea72126760a1ef113d2bb7 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 10:08:47 +0100
Subject: [PATCH 09/33] Specify available component IDs for matrix results.

---
 .../post/transient_mechanical_simulation.py   | 45 +++++++++++--------
 1 file changed, 27 insertions(+), 18 deletions(-)

diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index bb5a86fc1..9845d429f 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -210,7 +210,7 @@ def displacement(
         Args:
             component_ids:
                 Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents "1", "2", "3".
+                or their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -262,7 +262,7 @@ def velocity(
         Args:
             component_ids:
                 Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents "1", "2", "3".
+                or their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -314,7 +314,7 @@ def acceleration(
         Args:
             component_ids:
                 Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents "1", "2", "3".
+                or their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -364,7 +364,8 @@ def stress(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
+                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -411,7 +412,8 @@ def stress_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
+                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -458,7 +460,8 @@ def stress_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
+                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -766,7 +769,8 @@ def elastic_strain(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
+                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -813,7 +817,8 @@ def elastic_strain_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
+                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -860,7 +865,8 @@ def elastic_strain_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
+                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1168,7 +1174,8 @@ def plastic_strain(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
+                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1215,7 +1222,8 @@ def plastic_strain_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
+                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1262,7 +1270,8 @@ def plastic_strain_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
+                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1572,7 +1581,7 @@ def reaction_force(
         Args:
             component_ids:
                 Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents "1", "2", "3".
+                or their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2351,7 +2360,7 @@ def element_nodal_forces(
         Args:
             component_ids:
                 Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents "1", "2", "3".
+                or their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2403,7 +2412,7 @@ def element_nodal_forces_nodal(
         Args:
             component_ids:
                 Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents "1", "2", "3".
+                or their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2454,7 +2463,7 @@ def element_nodal_forces_elemental(
         Args:
             component_ids:
                 Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents "1", "2", "3".
+                or their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2504,7 +2513,7 @@ def nodal_force(
         Args:
             component_ids:
                 Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents "1", "2", "3".
+                or their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2561,7 +2570,7 @@ def nodal_moment(
         Args:
             component_ids:
                 Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents "1", "2", "3".
+                or their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:

From 95c53864378edd68567934931097fb08d39b9755 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 10:13:13 +0100
Subject: [PATCH 10/33] Specify available component IDs for principal results.
 Rework all.

---
 .../post/transient_mechanical_simulation.py   | 90 +++++++++----------
 1 file changed, 45 insertions(+), 45 deletions(-)

diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index 9845d429f..8fff2446c 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -209,8 +209,8 @@ def displacement(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents 1, 2, 3.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -261,8 +261,8 @@ def velocity(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents 1, 2, 3.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -313,8 +313,8 @@ def acceleration(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents 1, 2, 3.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -364,8 +364,8 @@ def stress(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
-                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -412,8 +412,8 @@ def stress_elemental(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
-                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -460,8 +460,8 @@ def stress_nodal(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
-                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -507,7 +507,7 @@ def stress_principal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -551,7 +551,7 @@ def stress_principal_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -596,7 +596,7 @@ def stress_principal_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -769,8 +769,8 @@ def elastic_strain(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
-                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -817,8 +817,8 @@ def elastic_strain_nodal(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
-                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -865,8 +865,8 @@ def elastic_strain_elemental(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
-                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -912,7 +912,7 @@ def elastic_strain_principal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -957,7 +957,7 @@ def elastic_strain_principal_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1003,7 +1003,7 @@ def elastic_strain_principal_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1174,8 +1174,8 @@ def plastic_strain(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
-                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1222,8 +1222,8 @@ def plastic_strain_nodal(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
-                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1270,8 +1270,8 @@ def plastic_strain_elemental(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z", "XX", "XY",
-                "XZ", or their respective equivalents 1, 2, 3, 4, 5, 6.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1317,7 +1317,7 @@ def plastic_strain_principal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1362,7 +1362,7 @@ def plastic_strain_principal_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1408,7 +1408,7 @@ def plastic_strain_principal_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1580,8 +1580,8 @@ def reaction_force(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents 1, 2, 3.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2359,8 +2359,8 @@ def element_nodal_forces(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents 1, 2, 3.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2411,8 +2411,8 @@ def element_nodal_forces_nodal(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents 1, 2, 3.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2462,8 +2462,8 @@ def element_nodal_forces_elemental(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents 1, 2, 3.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2512,8 +2512,8 @@ def nodal_force(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents 1, 2, 3.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2569,8 +2569,8 @@ def nodal_moment(
 
         Args:
             component_ids:
-                Components to get results for. Can be one or several of "X", "Y", "Z",
-                or their respective equivalents 1, 2, 3.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:

From cd5f8f40527a30c14a74bfd04910a5e17564cdaf Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 10:22:00 +0100
Subject: [PATCH 11/33] Switching to node_ids and element_ids.

---
 .../post/transient_mechanical_simulation.py   | 574 +++++++++---------
 1 file changed, 282 insertions(+), 292 deletions(-)

diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index 8fff2446c..e000952c0 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -46,8 +46,8 @@ def _get_result(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
@@ -70,10 +70,10 @@ def _get_result(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             named_selection:
                 Named selection to get results for.
 
@@ -88,8 +88,8 @@ def _get_result(
         # Build the targeted mesh scoping
         mesh_scoping = self._build_mesh_scoping(
             selection,
-            nodes,
-            elements,
+            node_ids,
+            element_ids,
             named_selection,
             location=location,
         )
@@ -201,8 +201,8 @@ def displacement(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract displacement results from the simulation.
@@ -220,10 +220,10 @@ def displacement(
                 Times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of element whose nodes to get results for.
             named_selection:
                 Named selection to get results for.
 
@@ -241,8 +241,8 @@ def displacement(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -253,8 +253,8 @@ def velocity(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract velocity results from the simulation.
@@ -272,10 +272,10 @@ def velocity(
                 Times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of element whose nodes to get results for.
             named_selection:
                 Named selection to get results for.
 
@@ -293,8 +293,8 @@ def velocity(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -305,8 +305,8 @@ def acceleration(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract acceleration results from the simulation.
@@ -324,10 +324,10 @@ def acceleration(
                 Times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of element whose nodes to get results for.
             named_selection:
                 Named selection to get results for.
 
@@ -345,8 +345,8 @@ def acceleration(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -356,8 +356,8 @@ def stress(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
@@ -373,8 +373,8 @@ def stress(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -393,8 +393,8 @@ def stress(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -404,8 +404,8 @@ def stress_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
@@ -421,8 +421,8 @@ def stress_elemental(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -441,8 +441,8 @@ def stress_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -452,8 +452,8 @@ def stress_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
@@ -469,8 +469,8 @@ def stress_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -489,8 +489,8 @@ def stress_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -500,7 +500,7 @@ def stress_principal(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
@@ -533,8 +533,8 @@ def stress_principal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -544,7 +544,7 @@ def stress_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
@@ -577,8 +577,8 @@ def stress_principal_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -588,8 +588,8 @@ def stress_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
@@ -604,8 +604,8 @@ def stress_principal_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -624,8 +624,8 @@ def stress_principal_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -634,7 +634,7 @@ def stress_eqv_von_mises(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
@@ -665,8 +665,8 @@ def stress_eqv_von_mises(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -675,7 +675,7 @@ def stress_eqv_von_mises_elemental(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
@@ -706,8 +706,8 @@ def stress_eqv_von_mises_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -716,8 +716,8 @@ def stress_eqv_von_mises_nodal(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
@@ -730,8 +730,8 @@ def stress_eqv_von_mises_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -750,8 +750,8 @@ def stress_eqv_von_mises_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -761,8 +761,8 @@ def elastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
@@ -778,8 +778,8 @@ def elastic_strain(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -798,8 +798,8 @@ def elastic_strain(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -809,8 +809,8 @@ def elastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
@@ -826,8 +826,8 @@ def elastic_strain_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -846,8 +846,8 @@ def elastic_strain_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -857,8 +857,8 @@ def elastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
@@ -874,8 +874,8 @@ def elastic_strain_elemental(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -894,8 +894,8 @@ def elastic_strain_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -905,7 +905,7 @@ def elastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
@@ -938,8 +938,8 @@ def elastic_strain_principal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -949,8 +949,8 @@ def elastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
@@ -965,8 +965,8 @@ def elastic_strain_principal_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -985,8 +985,8 @@ def elastic_strain_principal_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -996,7 +996,7 @@ def elastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
@@ -1029,8 +1029,8 @@ def elastic_strain_principal_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1039,7 +1039,7 @@ def plastic_state_variable(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
@@ -1070,8 +1070,8 @@ def plastic_state_variable(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1080,7 +1080,7 @@ def plastic_state_variable_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
@@ -1111,8 +1111,8 @@ def plastic_state_variable_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1121,8 +1121,8 @@ def plastic_state_variable_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
@@ -1135,8 +1135,8 @@ def plastic_state_variable_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1155,8 +1155,8 @@ def plastic_state_variable_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1166,8 +1166,8 @@ def plastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
@@ -1183,8 +1183,8 @@ def plastic_strain(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1203,8 +1203,8 @@ def plastic_strain(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1214,8 +1214,8 @@ def plastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
@@ -1231,8 +1231,8 @@ def plastic_strain_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1251,8 +1251,8 @@ def plastic_strain_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1262,8 +1262,8 @@ def plastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
@@ -1279,8 +1279,8 @@ def plastic_strain_elemental(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1299,8 +1299,8 @@ def plastic_strain_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1310,7 +1310,7 @@ def plastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
@@ -1343,8 +1343,8 @@ def plastic_strain_principal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1354,8 +1354,8 @@ def plastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
@@ -1370,8 +1370,8 @@ def plastic_strain_principal_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1390,8 +1390,8 @@ def plastic_strain_principal_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1401,7 +1401,7 @@ def plastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
@@ -1434,8 +1434,8 @@ def plastic_strain_principal_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1444,7 +1444,7 @@ def plastic_strain_eqv(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
@@ -1475,8 +1475,8 @@ def plastic_strain_eqv(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1485,8 +1485,8 @@ def plastic_strain_eqv_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
@@ -1499,8 +1499,8 @@ def plastic_strain_eqv_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1519,8 +1519,8 @@ def plastic_strain_eqv_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1529,7 +1529,7 @@ def plastic_strain_eqv_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
@@ -1560,8 +1560,8 @@ def plastic_strain_eqv_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1572,8 +1572,8 @@ def reaction_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract reaction force results from the simulation.
@@ -1591,8 +1591,8 @@ def reaction_force(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1612,8 +1612,8 @@ def reaction_force(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1622,7 +1622,7 @@ def elemental_volume(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
@@ -1653,8 +1653,8 @@ def elemental_volume(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1663,7 +1663,7 @@ def elemental_mass(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
@@ -1694,8 +1694,8 @@ def elemental_mass(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1704,7 +1704,7 @@ def elemental_heat_generation(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
@@ -1735,8 +1735,8 @@ def elemental_heat_generation(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1745,7 +1745,7 @@ def element_centroids(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract element centroids results from the simulation.
@@ -1776,8 +1776,8 @@ def element_centroids(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1786,7 +1786,7 @@ def thickness(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract element thickness results from the simulation.
@@ -1817,8 +1817,8 @@ def thickness(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1827,7 +1827,7 @@ def element_orientations(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
@@ -1858,8 +1858,8 @@ def element_orientations(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1868,7 +1868,7 @@ def element_orientations_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
@@ -1899,8 +1899,8 @@ def element_orientations_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1909,8 +1909,8 @@ def element_orientations_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
@@ -1923,8 +1923,8 @@ def element_orientations_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1943,8 +1943,8 @@ def element_orientations_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1953,8 +1953,8 @@ def artificial_hourglass_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
@@ -1967,8 +1967,8 @@ def artificial_hourglass_energy(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1987,8 +1987,8 @@ def artificial_hourglass_energy(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -1997,8 +1997,8 @@ def thermal_dissipation_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
@@ -2011,8 +2011,8 @@ def thermal_dissipation_energy(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2031,8 +2031,8 @@ def thermal_dissipation_energy(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2041,8 +2041,8 @@ def kinetic_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
@@ -2055,8 +2055,8 @@ def kinetic_energy(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2075,8 +2075,8 @@ def kinetic_energy(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2085,8 +2085,8 @@ def hydrostatic_pressure(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
@@ -2099,8 +2099,8 @@ def hydrostatic_pressure(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2119,8 +2119,8 @@ def hydrostatic_pressure(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2129,8 +2129,8 @@ def hydrostatic_pressure_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
@@ -2143,8 +2143,8 @@ def hydrostatic_pressure_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2163,8 +2163,8 @@ def hydrostatic_pressure_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2173,8 +2173,8 @@ def hydrostatic_pressure_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
@@ -2187,8 +2187,8 @@ def hydrostatic_pressure_elemental(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2207,8 +2207,8 @@ def hydrostatic_pressure_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2217,8 +2217,8 @@ def structural_temperature(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
@@ -2231,8 +2231,8 @@ def structural_temperature(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2251,8 +2251,8 @@ def structural_temperature(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2261,8 +2261,8 @@ def structural_temperature_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
@@ -2275,8 +2275,8 @@ def structural_temperature_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2295,8 +2295,8 @@ def structural_temperature_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2305,8 +2305,8 @@ def structural_temperature_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
@@ -2319,8 +2319,8 @@ def structural_temperature_elemental(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2339,8 +2339,8 @@ def structural_temperature_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2351,8 +2351,8 @@ def element_nodal_forces(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
@@ -2370,8 +2370,8 @@ def element_nodal_forces(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2391,8 +2391,8 @@ def element_nodal_forces(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2403,8 +2403,8 @@ def element_nodal_forces_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
@@ -2422,8 +2422,8 @@ def element_nodal_forces_nodal(
                 List of times to get results for.
             time_steps_ids:
                 List of time steps IDs to get results for.
-            nodes:
-                List of nodes to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2443,8 +2443,8 @@ def element_nodal_forces_nodal(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2455,7 +2455,7 @@ def element_nodal_forces_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
@@ -2492,8 +2492,8 @@ def element_nodal_forces_elemental(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=None,
-            elements=elements,
+            node_ids=None,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2504,8 +2504,8 @@ def nodal_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal force results from the simulation.
@@ -2520,18 +2520,13 @@ def nodal_force(
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
             times:
-                Times to get results for.
-            set_ids:
-                Sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                Load steps to get results for.
-            sub_steps:
-                Sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of element whose nodes to get results for.
             named_selection:
                 Named selection to get results for.
 
@@ -2549,8 +2544,8 @@ def nodal_force(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )
 
@@ -2561,8 +2556,8 @@ def nodal_moment(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         named_selection: Union[str, None] = None,
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
@@ -2577,18 +2572,13 @@ def nodal_moment(
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
             times:
-                Times to get results for.
-            set_ids:
-                Sets to get results for.
-                A set is defined as a unique combination of {time, load step, sub-step}.
-            load_steps:
-                Load steps to get results for.
-            sub_steps:
-                Sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
+                List of times to get results for.
+            time_steps_ids:
+                List of time steps IDs to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of element whose nodes to get results for.
             named_selection:
                 Named selection to get results for.
 
@@ -2606,7 +2596,7 @@ def nodal_moment(
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
-            nodes=nodes,
-            elements=elements,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selection=named_selection,
         )

From e7f2b76d6ddfb1550cb8bd81adf44cbbd7ae6bf2 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 10:36:03 +0100
Subject: [PATCH 12/33] Add the case of list of named selections

---
 src/ansys/dpf/post/simulation.py              |  27 +-
 .../post/transient_mechanical_simulation.py   | 432 +++++++++---------
 2 files changed, 236 insertions(+), 223 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 1ea6ad810..52f00bcf2 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -389,16 +389,16 @@ def _build_mesh_scoping(
         selection=None,
         nodes=None,
         elements=None,
-        named_selection=None,
+        named_selections=None,
         location=core.locations.nodal,
     ) -> Union[core.mesh_scoping_factory.Scoping, None]:
-        if (nodes is not None or elements is not None) and named_selection is not None:
+        if (nodes is not None or elements is not None) and named_selections is not None:
             raise ValueError(
                 "nodes/elements and named_selection are mutually exclusive"
             )
 
         if selection is not None and (
-            nodes is not None or named_selection is not None or elements is not None
+            nodes is not None or named_selections is not None or elements is not None
         ):
             raise ValueError(
                 "selection and nodes/elements/named_selection are mutually exclusive"
@@ -408,10 +408,23 @@ def _build_mesh_scoping(
         if selection:
             mesh_scoping = selection.mesh_scoping
 
-        if named_selection:
-            mesh_scoping = core.mesh_scoping_factory.named_selection_scoping(
-                named_selection, server=self._model._server, model=self._model
-            )
+        if named_selections:
+            if type(named_selections) == str:
+                mesh_scoping = core.mesh_scoping_factory.named_selection_scoping(
+                    named_selections, server=self._model._server, model=self._model
+                )
+            elif type(named_selections) == list:
+                merge_scopings_op = self._model.operator(name="merge::scoping")
+                for pin, named_selection in enumerate(named_selections):
+                    mesh_scoping_on_ns_op = self._model.operator(
+                        name="scoping_provider_by_ns"
+                    )
+                    mesh_scoping_on_ns_op.connect(0, location)
+                    mesh_scoping_on_ns_op.connect(1, named_selection)
+                    merge_scopings_op.connect(
+                        pin, mesh_scoping_on_ns_op.outputs.mesh_scoping
+                    )
+                mesh_scoping = merge_scopings_op.outputs.merged_scoping
 
         if nodes:
             mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index e000952c0..787d1b6f0 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -48,7 +48,7 @@ def _get_result(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -74,8 +74,8 @@ def _get_result(
                 List of IDs of nodes to get results for.
             element_ids:
                 List of IDs of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -90,7 +90,7 @@ def _get_result(
             selection,
             node_ids,
             element_ids,
-            named_selection,
+            named_selections,
             location=location,
         )
 
@@ -203,7 +203,7 @@ def displacement(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
@@ -224,8 +224,8 @@ def displacement(
                 List of IDs of nodes to get results for.
             element_ids:
                 List of IDs of element whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -243,7 +243,7 @@ def displacement(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def velocity(
@@ -255,7 +255,7 @@ def velocity(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract velocity results from the simulation.
 
@@ -276,8 +276,8 @@ def velocity(
                 List of IDs of nodes to get results for.
             element_ids:
                 List of IDs of element whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -295,7 +295,7 @@ def velocity(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def acceleration(
@@ -307,7 +307,7 @@ def acceleration(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract acceleration results from the simulation.
 
@@ -328,8 +328,8 @@ def acceleration(
                 List of IDs of nodes to get results for.
             element_ids:
                 List of IDs of element whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -347,7 +347,7 @@ def acceleration(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def stress(
@@ -358,7 +358,7 @@ def stress(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
@@ -377,8 +377,8 @@ def stress(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -395,7 +395,7 @@ def stress(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def stress_elemental(
@@ -406,7 +406,7 @@ def stress_elemental(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
@@ -425,8 +425,8 @@ def stress_elemental(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -443,7 +443,7 @@ def stress_elemental(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def stress_nodal(
@@ -454,7 +454,7 @@ def stress_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
@@ -473,8 +473,8 @@ def stress_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -491,7 +491,7 @@ def stress_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def stress_principal(
@@ -501,7 +501,7 @@ def stress_principal(
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
@@ -517,8 +517,8 @@ def stress_principal(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -535,7 +535,7 @@ def stress_principal(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def stress_principal_elemental(
@@ -545,7 +545,7 @@ def stress_principal_elemental(
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
@@ -561,8 +561,8 @@ def stress_principal_elemental(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -579,7 +579,7 @@ def stress_principal_elemental(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def stress_principal_nodal(
@@ -590,7 +590,7 @@ def stress_principal_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
@@ -608,8 +608,8 @@ def stress_principal_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -626,7 +626,7 @@ def stress_principal_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def stress_eqv_von_mises(
@@ -635,7 +635,7 @@ def stress_eqv_von_mises(
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
@@ -649,8 +649,8 @@ def stress_eqv_von_mises(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -667,7 +667,7 @@ def stress_eqv_von_mises(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def stress_eqv_von_mises_elemental(
@@ -676,7 +676,7 @@ def stress_eqv_von_mises_elemental(
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
@@ -690,8 +690,8 @@ def stress_eqv_von_mises_elemental(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -708,7 +708,7 @@ def stress_eqv_von_mises_elemental(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def stress_eqv_von_mises_nodal(
@@ -718,7 +718,7 @@ def stress_eqv_von_mises_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
@@ -734,8 +734,8 @@ def stress_eqv_von_mises_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -752,7 +752,7 @@ def stress_eqv_von_mises_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def elastic_strain(
@@ -763,7 +763,7 @@ def elastic_strain(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -782,8 +782,8 @@ def elastic_strain(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -800,7 +800,7 @@ def elastic_strain(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def elastic_strain_nodal(
@@ -811,7 +811,7 @@ def elastic_strain_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -830,8 +830,8 @@ def elastic_strain_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -848,7 +848,7 @@ def elastic_strain_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def elastic_strain_elemental(
@@ -859,7 +859,7 @@ def elastic_strain_elemental(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -878,8 +878,8 @@ def elastic_strain_elemental(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -896,7 +896,7 @@ def elastic_strain_elemental(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def elastic_strain_principal(
@@ -906,7 +906,7 @@ def elastic_strain_principal(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
@@ -922,8 +922,8 @@ def elastic_strain_principal(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -940,7 +940,7 @@ def elastic_strain_principal(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def elastic_strain_principal_nodal(
@@ -951,7 +951,7 @@ def elastic_strain_principal_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
@@ -969,8 +969,8 @@ def elastic_strain_principal_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -987,7 +987,7 @@ def elastic_strain_principal_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def elastic_strain_principal_elemental(
@@ -997,7 +997,7 @@ def elastic_strain_principal_elemental(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
@@ -1013,8 +1013,8 @@ def elastic_strain_principal_elemental(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1031,7 +1031,7 @@ def elastic_strain_principal_elemental(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_state_variable(
@@ -1040,7 +1040,7 @@ def plastic_state_variable(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
@@ -1054,8 +1054,8 @@ def plastic_state_variable(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1072,7 +1072,7 @@ def plastic_state_variable(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_state_variable_elemental(
@@ -1081,7 +1081,7 @@ def plastic_state_variable_elemental(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
@@ -1095,8 +1095,8 @@ def plastic_state_variable_elemental(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1113,7 +1113,7 @@ def plastic_state_variable_elemental(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_state_variable_nodal(
@@ -1123,7 +1123,7 @@ def plastic_state_variable_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
@@ -1139,8 +1139,8 @@ def plastic_state_variable_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1157,7 +1157,7 @@ def plastic_state_variable_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_strain(
@@ -1168,7 +1168,7 @@ def plastic_strain(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
@@ -1187,8 +1187,8 @@ def plastic_strain(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1205,7 +1205,7 @@ def plastic_strain(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_strain_nodal(
@@ -1216,7 +1216,7 @@ def plastic_strain_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
@@ -1235,8 +1235,8 @@ def plastic_strain_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1253,7 +1253,7 @@ def plastic_strain_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_strain_elemental(
@@ -1264,7 +1264,7 @@ def plastic_strain_elemental(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
@@ -1283,8 +1283,8 @@ def plastic_strain_elemental(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1301,7 +1301,7 @@ def plastic_strain_elemental(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_strain_principal(
@@ -1311,7 +1311,7 @@ def plastic_strain_principal(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
@@ -1327,8 +1327,8 @@ def plastic_strain_principal(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1345,7 +1345,7 @@ def plastic_strain_principal(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_strain_principal_nodal(
@@ -1356,7 +1356,7 @@ def plastic_strain_principal_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
@@ -1374,8 +1374,8 @@ def plastic_strain_principal_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1392,7 +1392,7 @@ def plastic_strain_principal_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_strain_principal_elemental(
@@ -1402,7 +1402,7 @@ def plastic_strain_principal_elemental(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
@@ -1418,8 +1418,8 @@ def plastic_strain_principal_elemental(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1436,7 +1436,7 @@ def plastic_strain_principal_elemental(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_strain_eqv(
@@ -1445,7 +1445,7 @@ def plastic_strain_eqv(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
@@ -1459,8 +1459,8 @@ def plastic_strain_eqv(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1477,7 +1477,7 @@ def plastic_strain_eqv(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_strain_eqv_nodal(
@@ -1487,7 +1487,7 @@ def plastic_strain_eqv_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
@@ -1503,8 +1503,8 @@ def plastic_strain_eqv_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1521,7 +1521,7 @@ def plastic_strain_eqv_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def plastic_strain_eqv_elemental(
@@ -1530,7 +1530,7 @@ def plastic_strain_eqv_elemental(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
@@ -1544,8 +1544,8 @@ def plastic_strain_eqv_elemental(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1562,7 +1562,7 @@ def plastic_strain_eqv_elemental(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def reaction_force(
@@ -1574,7 +1574,7 @@ def reaction_force(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
@@ -1595,8 +1595,8 @@ def reaction_force(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1614,7 +1614,7 @@ def reaction_force(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def elemental_volume(
@@ -1623,7 +1623,7 @@ def elemental_volume(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
@@ -1637,8 +1637,8 @@ def elemental_volume(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1655,7 +1655,7 @@ def elemental_volume(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def elemental_mass(
@@ -1664,7 +1664,7 @@ def elemental_mass(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
@@ -1678,8 +1678,8 @@ def elemental_mass(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1696,7 +1696,7 @@ def elemental_mass(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def elemental_heat_generation(
@@ -1705,7 +1705,7 @@ def elemental_heat_generation(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
@@ -1719,8 +1719,8 @@ def elemental_heat_generation(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1737,7 +1737,7 @@ def elemental_heat_generation(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def element_centroids(
@@ -1746,7 +1746,7 @@ def element_centroids(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
@@ -1760,8 +1760,8 @@ def element_centroids(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1778,7 +1778,7 @@ def element_centroids(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def thickness(
@@ -1787,7 +1787,7 @@ def thickness(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
@@ -1801,8 +1801,8 @@ def thickness(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1819,7 +1819,7 @@ def thickness(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def element_orientations(
@@ -1828,7 +1828,7 @@ def element_orientations(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
@@ -1842,8 +1842,8 @@ def element_orientations(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1860,7 +1860,7 @@ def element_orientations(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def element_orientations_elemental(
@@ -1869,7 +1869,7 @@ def element_orientations_elemental(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
@@ -1883,8 +1883,8 @@ def element_orientations_elemental(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1901,7 +1901,7 @@ def element_orientations_elemental(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def element_orientations_nodal(
@@ -1911,7 +1911,7 @@ def element_orientations_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
@@ -1927,8 +1927,8 @@ def element_orientations_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1945,7 +1945,7 @@ def element_orientations_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def artificial_hourglass_energy(
@@ -1955,7 +1955,7 @@ def artificial_hourglass_energy(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
@@ -1971,8 +1971,8 @@ def artificial_hourglass_energy(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1989,7 +1989,7 @@ def artificial_hourglass_energy(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def thermal_dissipation_energy(
@@ -1999,7 +1999,7 @@ def thermal_dissipation_energy(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
@@ -2015,8 +2015,8 @@ def thermal_dissipation_energy(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2033,7 +2033,7 @@ def thermal_dissipation_energy(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def kinetic_energy(
@@ -2043,7 +2043,7 @@ def kinetic_energy(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
@@ -2059,8 +2059,8 @@ def kinetic_energy(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2077,7 +2077,7 @@ def kinetic_energy(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def hydrostatic_pressure(
@@ -2087,7 +2087,7 @@ def hydrostatic_pressure(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
@@ -2103,8 +2103,8 @@ def hydrostatic_pressure(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2121,7 +2121,7 @@ def hydrostatic_pressure(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def hydrostatic_pressure_nodal(
@@ -2131,7 +2131,7 @@ def hydrostatic_pressure_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
@@ -2147,8 +2147,8 @@ def hydrostatic_pressure_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2165,7 +2165,7 @@ def hydrostatic_pressure_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def hydrostatic_pressure_elemental(
@@ -2175,7 +2175,7 @@ def hydrostatic_pressure_elemental(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
@@ -2191,8 +2191,8 @@ def hydrostatic_pressure_elemental(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2209,7 +2209,7 @@ def hydrostatic_pressure_elemental(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def structural_temperature(
@@ -2219,7 +2219,7 @@ def structural_temperature(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
@@ -2235,8 +2235,8 @@ def structural_temperature(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2253,7 +2253,7 @@ def structural_temperature(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def structural_temperature_nodal(
@@ -2263,7 +2263,7 @@ def structural_temperature_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
@@ -2279,8 +2279,8 @@ def structural_temperature_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2297,7 +2297,7 @@ def structural_temperature_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def structural_temperature_elemental(
@@ -2307,7 +2307,7 @@ def structural_temperature_elemental(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
@@ -2323,8 +2323,8 @@ def structural_temperature_elemental(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2341,7 +2341,7 @@ def structural_temperature_elemental(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def element_nodal_forces(
@@ -2353,7 +2353,7 @@ def element_nodal_forces(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
@@ -2374,8 +2374,8 @@ def element_nodal_forces(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2393,7 +2393,7 @@ def element_nodal_forces(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def element_nodal_forces_nodal(
@@ -2405,7 +2405,7 @@ def element_nodal_forces_nodal(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
@@ -2426,8 +2426,8 @@ def element_nodal_forces_nodal(
                 List of IDs of nodes to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2445,7 +2445,7 @@ def element_nodal_forces_nodal(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def element_nodal_forces_elemental(
@@ -2456,7 +2456,7 @@ def element_nodal_forces_elemental(
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
@@ -2475,8 +2475,8 @@ def element_nodal_forces_elemental(
                 List of time steps IDs to get results for.
             elements:
                 List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2494,7 +2494,7 @@ def element_nodal_forces_elemental(
             time_step_ids=time_step_ids,
             node_ids=None,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def nodal_force(
@@ -2506,7 +2506,7 @@ def nodal_force(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
@@ -2527,8 +2527,8 @@ def nodal_force(
                 List of IDs of nodes to get results for.
             element_ids:
                 List of IDs of element whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2546,7 +2546,7 @@ def nodal_force(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )
 
     def nodal_moment(
@@ -2558,7 +2558,7 @@ def nodal_moment(
         time_step_ids: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
@@ -2579,8 +2579,8 @@ def nodal_moment(
                 List of IDs of nodes to get results for.
             element_ids:
                 List of IDs of element whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2598,5 +2598,5 @@ def nodal_moment(
             time_step_ids=time_step_ids,
             node_ids=node_ids,
             element_ids=element_ids,
-            named_selection=named_selection,
+            named_selections=named_selections,
         )

From ad599e8b542ca7aad156992f2f69262d185f04a5 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 10:38:59 +0100
Subject: [PATCH 13/33] Switch to node_ids in
 TestTransientMechanicalSimulation.

---
 tests/test_simulation.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index 8f1bedcd8..07de3fa87 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -431,7 +431,7 @@ def test_element_nodal_forces_elemental(self, allkindofcomplexity):
 class TestTransientMechanicalSimulation:
     def test_displacement(self, transient_simulation):
         result = transient_simulation.displacement(
-            component_ids=["X"], nodes=[2, 3, 4], time_step_ids=[2]
+            component_ids=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -452,7 +452,7 @@ def test_displacement(self, transient_simulation):
 
     def test_velocity(self, transient_simulation):
         result = transient_simulation.velocity(
-            component_ids=["X"], nodes=[2, 3, 4], time_step_ids=[2]
+            component_ids=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -473,7 +473,7 @@ def test_velocity(self, transient_simulation):
 
     def test_acceleration(self, transient_simulation):
         result = transient_simulation.acceleration(
-            component_ids=["X"], nodes=[2, 3, 4], time_step_ids=[2]
+            component_ids=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]

From b19f45313b46f486226551feedfc033d14424986 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 10:45:06 +0100
Subject: [PATCH 14/33] Add testing for list of named_selections.

---
 src/ansys/dpf/post/simulation.py |  2 +-
 tests/test_simulation.py         | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 52f00bcf2..4a889517d 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -424,7 +424,7 @@ def _build_mesh_scoping(
                     merge_scopings_op.connect(
                         pin, mesh_scoping_on_ns_op.outputs.mesh_scoping
                     )
-                mesh_scoping = merge_scopings_op.outputs.merged_scoping
+                mesh_scoping = merge_scopings_op.eval()
 
         if nodes:
             mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index 07de3fa87..5ff61e9bf 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -450,6 +450,17 @@ def test_displacement(self, transient_simulation):
         assert field.data.shape == (3,)
         assert np.allclose(field.data, field_ref.data)
 
+        result = transient_simulation.displacement(
+            component_ids=1,
+            named_selections=transient_simulation.named_selections[:2],
+            time_step_ids=[2],
+        )
+        assert len(result._fc) == 1
+        assert result._fc.get_time_scoping().ids == [2]
+        field = result._fc[0]
+        assert field.component_count == 1
+        assert field.data.shape == (393,)
+
     def test_velocity(self, transient_simulation):
         result = transient_simulation.velocity(
             component_ids=["X"], node_ids=[2, 3, 4], time_step_ids=[2]

From 27905f89d61071e2115eca943ee1b72d89987bc2 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 11:08:20 +0100
Subject: [PATCH 15/33] Specify precedence of "selection" argument.

---
 .../post/transient_mechanical_simulation.py   | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index 787d1b6f0..23b915931 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -66,6 +66,7 @@ def _get_result(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -216,6 +217,7 @@ def displacement(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 Times to get results for.
             time_steps_ids:
@@ -268,6 +270,7 @@ def velocity(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 Times to get results for.
             time_steps_ids:
@@ -320,6 +323,7 @@ def acceleration(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 Times to get results for.
             time_steps_ids:
@@ -369,6 +373,7 @@ def stress(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -417,6 +422,7 @@ def stress_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -465,6 +471,7 @@ def stress_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -511,6 +518,7 @@ def stress_principal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -555,6 +563,7 @@ def stress_principal_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -600,6 +609,7 @@ def stress_principal_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -643,6 +653,7 @@ def stress_eqv_von_mises(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -684,6 +695,7 @@ def stress_eqv_von_mises_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -726,6 +738,7 @@ def stress_eqv_von_mises_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -774,6 +787,7 @@ def elastic_strain(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -822,6 +836,7 @@ def elastic_strain_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -870,6 +885,7 @@ def elastic_strain_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -916,6 +932,7 @@ def elastic_strain_principal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -961,6 +978,7 @@ def elastic_strain_principal_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1007,6 +1025,7 @@ def elastic_strain_principal_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1048,6 +1067,7 @@ def plastic_state_variable(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1089,6 +1109,7 @@ def plastic_state_variable_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1131,6 +1152,7 @@ def plastic_state_variable_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1179,6 +1201,7 @@ def plastic_strain(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1227,6 +1250,7 @@ def plastic_strain_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1275,6 +1299,7 @@ def plastic_strain_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1321,6 +1346,7 @@ def plastic_strain_principal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1366,6 +1392,7 @@ def plastic_strain_principal_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1412,6 +1439,7 @@ def plastic_strain_principal_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1453,6 +1481,7 @@ def plastic_strain_eqv(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1495,6 +1524,7 @@ def plastic_strain_eqv_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1538,6 +1568,7 @@ def plastic_strain_eqv_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1587,6 +1618,7 @@ def reaction_force(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1631,6 +1663,7 @@ def elemental_volume(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1672,6 +1705,7 @@ def elemental_mass(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1713,6 +1747,7 @@ def elemental_heat_generation(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1754,6 +1789,7 @@ def element_centroids(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1795,6 +1831,7 @@ def thickness(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1836,6 +1873,7 @@ def element_orientations(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1877,6 +1915,7 @@ def element_orientations_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1919,6 +1958,7 @@ def element_orientations_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -1963,6 +2003,7 @@ def artificial_hourglass_energy(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2007,6 +2048,7 @@ def thermal_dissipation_energy(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2051,6 +2093,7 @@ def kinetic_energy(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2095,6 +2138,7 @@ def hydrostatic_pressure(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2139,6 +2183,7 @@ def hydrostatic_pressure_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2183,6 +2228,7 @@ def hydrostatic_pressure_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2227,6 +2273,7 @@ def structural_temperature(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2271,6 +2318,7 @@ def structural_temperature_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2315,6 +2363,7 @@ def structural_temperature_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2366,6 +2415,7 @@ def element_nodal_forces(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2418,6 +2468,7 @@ def element_nodal_forces_nodal(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2469,6 +2520,7 @@ def element_nodal_forces_elemental(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2519,6 +2571,7 @@ def nodal_force(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:
@@ -2571,6 +2624,7 @@ def nodal_moment(
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
+                It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
             time_steps_ids:

From 04bfee11810d85de97cd63262d7262144670ea04 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 11:13:49 +0100
Subject: [PATCH 16/33] Mention priority order for filtering arguments.

---
 src/ansys/dpf/post/simulation.py              |   5 -
 .../post/transient_mechanical_simulation.py   | 164 +++++++++++++++++-
 2 files changed, 163 insertions(+), 6 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 4a889517d..0235d5859 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -350,11 +350,6 @@ def _build_components_from_principal(self, base_name, components):
             columns = [base_name + self._principal_names[i] for i in out]
         return out, columns
 
-    @abstractmethod
-    def _build_time_freq_scoping(self) -> core.time_freq_scoping_factory.Scoping:
-        """Generate a time_freq_scoping from input arguments."""
-        pass
-
     @abstractmethod
     def _build_mesh_scoping(self) -> core.mesh_scoping_factory.Scoping:
         """Generate a mesh_scoping from input arguments."""
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index 23b915931..e5546d287 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -14,8 +14,8 @@ class TransientMechanicalSimulation(MechanicalSimulation):
     def _build_time_freq_scoping(
         self,
         selection: Union[Selection, None],
-        times: Union[float, List[float], None],
         time_step_ids: Union[int, List[int], None],
+        times: Union[float, List[float], None],
     ) -> core.time_freq_scoping_factory.Scoping:
         """Generate a time_freq_scoping from input arguments."""
         # create from selection in priority
@@ -52,6 +52,9 @@ def _get_result(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             base_name:
                 Base name for the requested result.
@@ -208,6 +211,9 @@ def displacement(
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -261,6 +267,9 @@ def velocity(
     ) -> DataObject:
         """Extract velocity results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -314,6 +323,9 @@ def acceleration(
     ) -> DataObject:
         """Extract acceleration results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -366,6 +378,9 @@ def stress(
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -415,6 +430,9 @@ def stress_elemental(
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -464,6 +482,9 @@ def stress_nodal(
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -512,6 +533,9 @@ def stress_principal(
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -557,6 +581,9 @@ def stress_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -603,6 +630,9 @@ def stress_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -649,6 +679,9 @@ def stress_eqv_von_mises(
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -691,6 +724,9 @@ def stress_eqv_von_mises_elemental(
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -734,6 +770,9 @@ def stress_eqv_von_mises_nodal(
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -780,6 +819,9 @@ def elastic_strain(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -829,6 +871,9 @@ def elastic_strain_nodal(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -878,6 +923,9 @@ def elastic_strain_elemental(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -926,6 +974,9 @@ def elastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -972,6 +1023,9 @@ def elastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1019,6 +1073,9 @@ def elastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1063,6 +1120,9 @@ def plastic_state_variable(
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1105,6 +1165,9 @@ def plastic_state_variable_elemental(
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1148,6 +1211,9 @@ def plastic_state_variable_nodal(
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1194,6 +1260,9 @@ def plastic_strain(
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -1243,6 +1312,9 @@ def plastic_strain_nodal(
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -1292,6 +1364,9 @@ def plastic_strain_elemental(
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -1340,6 +1415,9 @@ def plastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1386,6 +1464,9 @@ def plastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1433,6 +1514,9 @@ def plastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1477,6 +1561,9 @@ def plastic_strain_eqv(
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1520,6 +1607,9 @@ def plastic_strain_eqv_nodal(
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1564,6 +1654,9 @@ def plastic_strain_eqv_elemental(
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1609,6 +1702,9 @@ def reaction_force(
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -1659,6 +1755,9 @@ def elemental_volume(
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1701,6 +1800,9 @@ def elemental_mass(
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1743,6 +1845,9 @@ def elemental_heat_generation(
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1785,6 +1890,9 @@ def element_centroids(
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1827,6 +1935,9 @@ def thickness(
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1869,6 +1980,9 @@ def element_orientations(
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1911,6 +2025,9 @@ def element_orientations_elemental(
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1954,6 +2071,9 @@ def element_orientations_nodal(
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1999,6 +2119,9 @@ def artificial_hourglass_energy(
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2044,6 +2167,9 @@ def thermal_dissipation_energy(
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2089,6 +2215,9 @@ def kinetic_energy(
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2134,6 +2263,9 @@ def hydrostatic_pressure(
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2179,6 +2311,9 @@ def hydrostatic_pressure_nodal(
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2224,6 +2359,9 @@ def hydrostatic_pressure_elemental(
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2269,6 +2407,9 @@ def structural_temperature(
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2314,6 +2455,9 @@ def structural_temperature_nodal(
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2359,6 +2503,9 @@ def structural_temperature_elemental(
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2406,6 +2553,9 @@ def element_nodal_forces(
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -2459,6 +2609,9 @@ def element_nodal_forces_nodal(
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -2511,6 +2664,9 @@ def element_nodal_forces_elemental(
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -2562,6 +2718,9 @@ def nodal_force(
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -2615,6 +2774,9 @@ def nodal_moment(
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        The `time_step_ids` argument then takes precedence over `times`.
+
         Args:
             component_ids:
                 Components to get results for. Available components are "X", "Y", "Z",

From 4eb49bd9545df990aa4a5817967be2886aec34a6 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 11:21:52 +0100
Subject: [PATCH 17/33] Switch to node_ids, element_ids and named_selections in
 static_mechanical_simulation.py.

---
 .../dpf/post/static_mechanical_simulation.py  | 1152 ++++++++---------
 1 file changed, 576 insertions(+), 576 deletions(-)

diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index c22df66f5..6b36ad138 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -83,9 +83,9 @@ def _get_result(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -112,12 +112,12 @@ def _get_result(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -132,9 +132,9 @@ def _get_result(
         # Build the targeted mesh scoping
         mesh_scoping = self._build_mesh_scoping(
             selection,
-            nodes,
-            elements,
-            named_selection,
+            node_ids,
+            element_ids,
+            named_selections,
             location=location,
         )
 
@@ -247,9 +247,9 @@ def displacement(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
@@ -270,12 +270,12 @@ def displacement(
                 Load steps to get results for.
             sub_steps:
                 Sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements whose nodes to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -293,9 +293,9 @@ def displacement(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stress(
@@ -306,9 +306,9 @@ def stress(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
@@ -327,12 +327,12 @@ def stress(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -349,9 +349,9 @@ def stress(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stress_elemental(
@@ -362,9 +362,9 @@ def stress_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
@@ -383,12 +383,12 @@ def stress_elemental(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -405,9 +405,9 @@ def stress_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stress_nodal(
@@ -418,9 +418,9 @@ def stress_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
@@ -439,12 +439,12 @@ def stress_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -461,9 +461,9 @@ def stress_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stress_principal(
@@ -474,8 +474,8 @@ def stress_principal(
         set_ids: Union[List[int], None] = None,
         load_steps: Union[List[int], None] = None,
         sub_steps: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
@@ -514,9 +514,9 @@ def stress_principal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stress_principal_elemental(
@@ -527,8 +527,8 @@ def stress_principal_elemental(
         set_ids: Union[List[int], None] = None,
         load_steps: Union[List[int], None] = None,
         sub_steps: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
@@ -567,9 +567,9 @@ def stress_principal_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stress_principal_nodal(
@@ -580,9 +580,9 @@ def stress_principal_nodal(
         set_ids: Union[List[int], None] = None,
         load_steps: Union[List[int], None] = None,
         sub_steps: Union[List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
@@ -601,12 +601,12 @@ def stress_principal_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -623,9 +623,9 @@ def stress_principal_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stress_eqv_von_mises(
@@ -635,8 +635,8 @@ def stress_eqv_von_mises(
         set_ids: Union[List[int], None] = None,
         load_steps: Union[List[int], None] = None,
         sub_steps: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
@@ -673,9 +673,9 @@ def stress_eqv_von_mises(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stress_eqv_von_mises_elemental(
@@ -685,8 +685,8 @@ def stress_eqv_von_mises_elemental(
         set_ids: Union[List[int], None] = None,
         load_steps: Union[List[int], None] = None,
         sub_steps: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
@@ -723,9 +723,9 @@ def stress_eqv_von_mises_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stress_eqv_von_mises_nodal(
@@ -735,9 +735,9 @@ def stress_eqv_von_mises_nodal(
         set_ids: Union[List[int], None] = None,
         load_steps: Union[List[int], None] = None,
         sub_steps: Union[List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
@@ -754,12 +754,12 @@ def stress_eqv_von_mises_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -776,9 +776,9 @@ def stress_eqv_von_mises_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def elastic_strain(
@@ -789,9 +789,9 @@ def elastic_strain(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -810,12 +810,12 @@ def elastic_strain(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -832,9 +832,9 @@ def elastic_strain(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def elastic_strain_nodal(
@@ -845,9 +845,9 @@ def elastic_strain_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -866,12 +866,12 @@ def elastic_strain_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -888,9 +888,9 @@ def elastic_strain_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def elastic_strain_elemental(
@@ -901,9 +901,9 @@ def elastic_strain_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -922,12 +922,12 @@ def elastic_strain_elemental(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -944,9 +944,9 @@ def elastic_strain_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def elastic_strain_principal(
@@ -957,8 +957,8 @@ def elastic_strain_principal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
@@ -997,9 +997,9 @@ def elastic_strain_principal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def elastic_strain_principal_nodal(
@@ -1010,9 +1010,9 @@ def elastic_strain_principal_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
@@ -1031,12 +1031,12 @@ def elastic_strain_principal_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1053,9 +1053,9 @@ def elastic_strain_principal_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def elastic_strain_principal_elemental(
@@ -1066,8 +1066,8 @@ def elastic_strain_principal_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
@@ -1106,9 +1106,9 @@ def elastic_strain_principal_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_state_variable(
@@ -1118,8 +1118,8 @@ def plastic_state_variable(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
@@ -1156,9 +1156,9 @@ def plastic_state_variable(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_state_variable_elemental(
@@ -1168,8 +1168,8 @@ def plastic_state_variable_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
@@ -1206,9 +1206,9 @@ def plastic_state_variable_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_state_variable_nodal(
@@ -1218,9 +1218,9 @@ def plastic_state_variable_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
@@ -1237,12 +1237,12 @@ def plastic_state_variable_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1259,9 +1259,9 @@ def plastic_state_variable_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_strain(
@@ -1272,9 +1272,9 @@ def plastic_strain(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
@@ -1293,12 +1293,12 @@ def plastic_strain(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1315,9 +1315,9 @@ def plastic_strain(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_strain_nodal(
@@ -1328,9 +1328,9 @@ def plastic_strain_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
@@ -1349,12 +1349,12 @@ def plastic_strain_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1371,9 +1371,9 @@ def plastic_strain_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_strain_elemental(
@@ -1384,9 +1384,9 @@ def plastic_strain_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
@@ -1405,12 +1405,12 @@ def plastic_strain_elemental(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1427,9 +1427,9 @@ def plastic_strain_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_strain_principal(
@@ -1440,8 +1440,8 @@ def plastic_strain_principal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
@@ -1480,9 +1480,9 @@ def plastic_strain_principal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_strain_principal_nodal(
@@ -1493,9 +1493,9 @@ def plastic_strain_principal_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
@@ -1514,12 +1514,12 @@ def plastic_strain_principal_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1536,9 +1536,9 @@ def plastic_strain_principal_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_strain_principal_elemental(
@@ -1549,8 +1549,8 @@ def plastic_strain_principal_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
@@ -1589,9 +1589,9 @@ def plastic_strain_principal_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_strain_eqv(
@@ -1601,8 +1601,8 @@ def plastic_strain_eqv(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
@@ -1639,9 +1639,9 @@ def plastic_strain_eqv(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_strain_eqv_nodal(
@@ -1651,9 +1651,9 @@ def plastic_strain_eqv_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
@@ -1670,12 +1670,12 @@ def plastic_strain_eqv_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1692,9 +1692,9 @@ def plastic_strain_eqv_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def plastic_strain_eqv_elemental(
@@ -1704,8 +1704,8 @@ def plastic_strain_eqv_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
@@ -1742,9 +1742,9 @@ def plastic_strain_eqv_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def creep_strain(
@@ -1755,9 +1755,9 @@ def creep_strain(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal creep strain results from the simulation.
 
@@ -1776,12 +1776,12 @@ def creep_strain(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1798,9 +1798,9 @@ def creep_strain(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def creep_strain_nodal(
@@ -1811,9 +1811,9 @@ def creep_strain_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal creep strain results from the simulation.
 
@@ -1832,12 +1832,12 @@ def creep_strain_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1854,9 +1854,9 @@ def creep_strain_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def creep_strain_elemental(
@@ -1867,9 +1867,9 @@ def creep_strain_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental creep strain results from the simulation.
 
@@ -1888,12 +1888,12 @@ def creep_strain_elemental(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -1910,9 +1910,9 @@ def creep_strain_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def creep_strain_principal(
@@ -1923,8 +1923,8 @@ def creep_strain_principal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal creep strain results from the simulation.
 
@@ -1963,9 +1963,9 @@ def creep_strain_principal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def creep_strain_principal_nodal(
@@ -1976,9 +1976,9 @@ def creep_strain_principal_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal principal creep strain results from the simulation.
 
@@ -1997,12 +1997,12 @@ def creep_strain_principal_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2019,9 +2019,9 @@ def creep_strain_principal_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def creep_strain_principal_elemental(
@@ -2032,8 +2032,8 @@ def creep_strain_principal_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal creep strain results from the simulation.
 
@@ -2072,9 +2072,9 @@ def creep_strain_principal_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def creep_strain_eqv(
@@ -2084,8 +2084,8 @@ def creep_strain_eqv(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent creep strain results from the simulation.
 
@@ -2122,9 +2122,9 @@ def creep_strain_eqv(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def creep_strain_equivalent_nodal(
@@ -2134,9 +2134,9 @@ def creep_strain_equivalent_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent creep strain results from the simulation.
 
@@ -2153,12 +2153,12 @@ def creep_strain_equivalent_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2175,9 +2175,9 @@ def creep_strain_equivalent_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def creep_strain_equivalent_elemental(
@@ -2187,8 +2187,8 @@ def creep_strain_equivalent_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent creep strain results from the simulation.
 
@@ -2225,9 +2225,9 @@ def creep_strain_equivalent_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def reaction_force(
@@ -2237,9 +2237,9 @@ def reaction_force(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
@@ -2256,12 +2256,12 @@ def reaction_force(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2278,9 +2278,9 @@ def reaction_force(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def elemental_volume(
@@ -2290,8 +2290,8 @@ def elemental_volume(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
@@ -2328,9 +2328,9 @@ def elemental_volume(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def elemental_mass(
@@ -2340,8 +2340,8 @@ def elemental_mass(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
@@ -2378,9 +2378,9 @@ def elemental_mass(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def elemental_heat_generation(
@@ -2390,8 +2390,8 @@ def elemental_heat_generation(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
@@ -2428,9 +2428,9 @@ def elemental_heat_generation(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def element_centroids(
@@ -2440,8 +2440,8 @@ def element_centroids(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
@@ -2478,9 +2478,9 @@ def element_centroids(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def thickness(
@@ -2490,8 +2490,8 @@ def thickness(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
@@ -2528,9 +2528,9 @@ def thickness(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def element_orientations(
@@ -2540,8 +2540,8 @@ def element_orientations(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
@@ -2578,9 +2578,9 @@ def element_orientations(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def element_orientations_elemental(
@@ -2590,8 +2590,8 @@ def element_orientations_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
@@ -2628,9 +2628,9 @@ def element_orientations_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def element_orientations_nodal(
@@ -2640,9 +2640,9 @@ def element_orientations_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
@@ -2659,12 +2659,12 @@ def element_orientations_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2681,9 +2681,9 @@ def element_orientations_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def stiffness_matrix_energy(
@@ -2693,9 +2693,9 @@ def stiffness_matrix_energy(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract stiffness matrix energy results from the simulation.
 
@@ -2712,12 +2712,12 @@ def stiffness_matrix_energy(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2734,9 +2734,9 @@ def stiffness_matrix_energy(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def artificial_hourglass_energy(
@@ -2746,9 +2746,9 @@ def artificial_hourglass_energy(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
@@ -2765,12 +2765,12 @@ def artificial_hourglass_energy(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2787,9 +2787,9 @@ def artificial_hourglass_energy(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def thermal_dissipation_energy(
@@ -2799,9 +2799,9 @@ def thermal_dissipation_energy(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
@@ -2818,12 +2818,12 @@ def thermal_dissipation_energy(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2840,9 +2840,9 @@ def thermal_dissipation_energy(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def kinetic_energy(
@@ -2852,9 +2852,9 @@ def kinetic_energy(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
@@ -2871,12 +2871,12 @@ def kinetic_energy(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2893,9 +2893,9 @@ def kinetic_energy(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def hydrostatic_pressure(
@@ -2905,9 +2905,9 @@ def hydrostatic_pressure(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
@@ -2924,12 +2924,12 @@ def hydrostatic_pressure(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2946,9 +2946,9 @@ def hydrostatic_pressure(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def hydrostatic_pressure_nodal(
@@ -2958,9 +2958,9 @@ def hydrostatic_pressure_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
@@ -2977,12 +2977,12 @@ def hydrostatic_pressure_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -2999,9 +2999,9 @@ def hydrostatic_pressure_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def hydrostatic_pressure_elemental(
@@ -3011,9 +3011,9 @@ def hydrostatic_pressure_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
@@ -3030,12 +3030,12 @@ def hydrostatic_pressure_elemental(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -3052,9 +3052,9 @@ def hydrostatic_pressure_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def structural_temperature(
@@ -3064,9 +3064,9 @@ def structural_temperature(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
@@ -3083,12 +3083,12 @@ def structural_temperature(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -3105,9 +3105,9 @@ def structural_temperature(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def structural_temperature_nodal(
@@ -3117,9 +3117,9 @@ def structural_temperature_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
@@ -3136,12 +3136,12 @@ def structural_temperature_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -3158,9 +3158,9 @@ def structural_temperature_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def structural_temperature_elemental(
@@ -3170,9 +3170,9 @@ def structural_temperature_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
@@ -3189,12 +3189,12 @@ def structural_temperature_elemental(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -3211,9 +3211,9 @@ def structural_temperature_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def element_nodal_forces(
@@ -3225,9 +3225,9 @@ def element_nodal_forces(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
@@ -3248,12 +3248,12 @@ def element_nodal_forces(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -3271,9 +3271,9 @@ def element_nodal_forces(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def element_nodal_forces_nodal(
@@ -3285,9 +3285,9 @@ def element_nodal_forces_nodal(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
@@ -3308,12 +3308,12 @@ def element_nodal_forces_nodal(
                 List of load steps to get results for.
             sub_steps:
                 List of sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -3331,9 +3331,9 @@ def element_nodal_forces_nodal(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def element_nodal_forces_elemental(
@@ -3345,8 +3345,8 @@ def element_nodal_forces_elemental(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
@@ -3388,9 +3388,9 @@ def element_nodal_forces_elemental(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=None,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=None,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def nodal_force(
@@ -3402,9 +3402,9 @@ def nodal_force(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
@@ -3425,12 +3425,12 @@ def nodal_force(
                 Load steps to get results for.
             sub_steps:
                 Sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements whose nodes to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -3448,9 +3448,9 @@ def nodal_force(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )
 
     def nodal_moment(
@@ -3462,9 +3462,9 @@ def nodal_moment(
         set_ids: Union[int, List[int], None] = None,
         load_steps: Union[int, List[int], None] = None,
         sub_steps: Union[int, List[int], None] = None,
-        nodes: Union[List[int], None] = None,
-        elements: Union[List[int], None] = None,
-        named_selection: Union[str, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
@@ -3485,12 +3485,12 @@ def nodal_moment(
                 Load steps to get results for.
             sub_steps:
                 Sub-steps to get results for. Requires load_steps to be defined.
-            nodes:
-                List of nodes to get results for.
-            elements:
-                List of elements whose nodes to get results for.
-            named_selection:
-                Named selection to get results for.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements whose nodes to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
 
         Returns
         -------
@@ -3508,7 +3508,7 @@ def nodal_moment(
             set_ids=set_ids,
             load_steps=load_steps,
             sub_steps=sub_steps,
-            nodes=nodes,
-            elements=elements,
-            named_selection=named_selection,
+            node_ids=node_ids,
+            element_ids=element_ids,
+            named_selections=named_selections,
         )

From 0c6d34aa8cc077d11206cbeb7c3a16d437d564ec Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 11:28:27 +0100
Subject: [PATCH 18/33] Add component info for vector results in
 static_mechanical_simulation.py

---
 .../dpf/post/static_mechanical_simulation.py  | 28 ++++++++++++++-----
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index 6b36ad138..b75e29655 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -255,7 +255,8 @@ def displacement(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -2232,6 +2233,8 @@ def creep_strain_equivalent_elemental(
 
     def reaction_force(
         self,
+        component_ids: Union[str, List[str], int, List[int], None] = None,
+        norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -2244,6 +2247,11 @@ def reaction_force(
         """Extract reaction force results from the simulation.
 
         Args:
+            component_ids:
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
+            norm:
+                Whether to return the norm of the results.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -2272,7 +2280,8 @@ def reaction_force(
             base_name="RF",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=None,
+            components=component_ids,
+            norm=norm,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -3233,7 +3242,8 @@ def element_nodal_forces(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -3293,7 +3303,8 @@ def element_nodal_forces_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -3352,7 +3363,8 @@ def element_nodal_forces_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -3410,7 +3422,8 @@ def nodal_force(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:
@@ -3470,7 +3483,8 @@ def nodal_moment(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z",
+                and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
             selection:

From e1e569df7c274f57f0cf78ac0c4784f302ef261f Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 11:30:18 +0100
Subject: [PATCH 19/33] Add component info for matrix results in
 static_mechanical_simulation.py

---
 .../dpf/post/static_mechanical_simulation.py  | 36 ++++++++++++-------
 1 file changed, 24 insertions(+), 12 deletions(-)

diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index b75e29655..3b9be86b5 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -315,7 +315,8 @@ def stress(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -371,7 +372,8 @@ def stress_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -427,7 +429,8 @@ def stress_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -798,7 +801,8 @@ def elastic_strain(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -854,7 +858,8 @@ def elastic_strain_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -910,7 +915,8 @@ def elastic_strain_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1281,7 +1287,8 @@ def plastic_strain(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1337,7 +1344,8 @@ def plastic_strain_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1393,7 +1401,8 @@ def plastic_strain_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1764,7 +1773,8 @@ def creep_strain(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1820,7 +1830,8 @@ def creep_strain_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1876,7 +1887,8 @@ def creep_strain_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
+                "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.

From 0d5d470e0760bcfa27daeaff89792f159b88307b Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 11:31:46 +0100
Subject: [PATCH 20/33] Add component info for principal results in
 static_mechanical_simulation.py

---
 .../dpf/post/static_mechanical_simulation.py  | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index 3b9be86b5..3943dec19 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -485,7 +485,7 @@ def stress_principal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -538,7 +538,7 @@ def stress_principal_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -592,7 +592,7 @@ def stress_principal_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -971,7 +971,7 @@ def elastic_strain_principal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1025,7 +1025,7 @@ def elastic_strain_principal_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1080,7 +1080,7 @@ def elastic_strain_principal_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1457,7 +1457,7 @@ def plastic_strain_principal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1511,7 +1511,7 @@ def plastic_strain_principal_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1566,7 +1566,7 @@ def plastic_strain_principal_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1943,7 +1943,7 @@ def creep_strain_principal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -1997,7 +1997,7 @@ def creep_strain_principal_nodal(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.
@@ -2052,7 +2052,7 @@ def creep_strain_principal_elemental(
 
         Args:
             component_ids:
-                Components to get results for.
+                Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
                 A Selection defines both spatial and time-like criteria for filtering.

From 0faa1b0f98f5d95c2c3a8bc229d8327c07116bc3 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 11:36:29 +0100
Subject: [PATCH 21/33] Fix tests

---
 .../dpf/post/transient_mechanical_simulation.py      |  2 +-
 tests/test_simulation.py                             | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index e5546d287..d38a2da84 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -87,7 +87,7 @@ def _get_result(
 
         """
         # Build the targeted time scoping
-        time_scoping = self._build_time_freq_scoping(selection, times, time_step_ids)
+        time_scoping = self._build_time_freq_scoping(selection, time_step_ids, times)
 
         # Build the targeted mesh scoping
         mesh_scoping = self._build_mesh_scoping(
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index 5ff61e9bf..b8a2a4a83 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -72,12 +72,12 @@ class TestStaticMechanicalSimulation:
     def test_warning_empty(self, static_simulation):
         with pytest.warns(expected_warning=UserWarning, match="empty"):
             _ = static_simulation.displacement(
-                component_ids=1, nodes=[1001, 1002, 1003]
+                component_ids=1, node_ids=[1001, 1002, 1003]
             )
 
     def test_displacement(self, static_simulation):
         displacement_x = static_simulation.displacement(
-            component_ids=["X"], nodes=[42, 43, 44], set_ids=[1]
+            component_ids=["X"], node_ids=[42, 43, 44], set_ids=[1]
         )
         assert len(displacement_x._fc) == 1
         assert displacement_x._fc.get_time_scoping().ids == [1]
@@ -94,7 +94,7 @@ def test_displacement(self, static_simulation):
 
         displacement_y = static_simulation.displacement(
             component_ids=["2"],
-            named_selection=static_simulation.named_selections[0],
+            named_selections=static_simulation.named_selections[0],
             load_steps=[1],
             sub_steps=[1],
         )
@@ -115,7 +115,7 @@ def test_displacement(self, static_simulation):
 
         displacement_z = static_simulation.displacement(
             component_ids="Z",
-            named_selection=static_simulation.named_selections[0],
+            named_selections=static_simulation.named_selections[0],
             load_steps=1,
             sub_steps=1,
         )
@@ -136,7 +136,7 @@ def test_displacement(self, static_simulation):
 
         displacement_z = static_simulation.displacement(
             component_ids="Z",
-            elements=[1, 2, 3],
+            element_ids=[1, 2, 3],
             set_ids=1,
         )
         assert len(displacement_z._fc) == 1
@@ -160,7 +160,7 @@ def test_displacement(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
         displacement_norm = static_simulation.displacement(
-            norm=True, nodes=[42, 43, 44], set_ids=[1]
+            norm=True, node_ids=[42, 43, 44], set_ids=[1]
         )
         assert len(displacement_norm._fc) == 1
         assert displacement_norm._fc.get_time_scoping().ids == [1]

From e32deefe3eb7960633f5e09e8ed12aa231f88dca Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 11:49:15 +0100
Subject: [PATCH 22/33] Fix DataObject docstring

---
 src/ansys/dpf/post/data_object.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/ansys/dpf/post/data_object.py b/src/ansys/dpf/post/data_object.py
index 2f548b915..ddcf542b9 100644
--- a/src/ansys/dpf/post/data_object.py
+++ b/src/ansys/dpf/post/data_object.py
@@ -69,7 +69,7 @@ def as_data_frame(self, columns=None, **kwargs):
         >>> from ansys.dpf.post import examples
         >>> simulation = post.load_simulation(examples.multishells_rst)
         >>> # Export the displacements vector field at step 1 as a DataFrame
-        >>> displacement = simulation.displacement(load_steps=[1], nodes=[1, 2, 3])
+        >>> displacement = simulation.displacement(load_steps=[1], node_ids=[1, 2, 3])
         >>> df = displacement.as_data_frame()
         >>> print(df)
                  UX         UY        UZ
@@ -113,7 +113,7 @@ def as_array(self):
         >>> from ansys.dpf.post import examples
         >>> simulation = post.load_simulation(examples.multishells_rst)
         >>> # Export the displacements vector field at step 1 as a DataFrame
-        >>> displacement = simulation.displacement(load_steps=[1], nodes=[1, 2, 3])
+        >>> displacement = simulation.displacement(load_steps=[1], node_ids=[1, 2, 3])
         >>> arr = displacement.as_array()
         >>> print(arr)
         [[  0.39831985 -13.79737819  -0.16376683]

From b4c137839ddac10ad7d51abfd0ce578ada60189a Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Mon, 13 Feb 2023 13:39:27 +0100
Subject: [PATCH 23/33] Fix 02-get_data_from_static_simulation.py

---
 examples/00-Overview/02-get_data_from_static_simulation.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/00-Overview/02-get_data_from_static_simulation.py b/examples/00-Overview/02-get_data_from_static_simulation.py
index bd8cea123..03ee6c030 100644
--- a/examples/00-Overview/02-get_data_from_static_simulation.py
+++ b/examples/00-Overview/02-get_data_from_static_simulation.py
@@ -47,7 +47,7 @@
 # Get stresses at only 5 nodes
 # ------------------------------
 # Request stress only at the first 5 nodes using their IDs.
-stress_nodes = simulation.stress_nodal(nodes=range(1, 6))
+stress_nodes = simulation.stress_nodal(node_ids=range(1, 6))
 
 ###############################################################################
 # Print information
@@ -63,7 +63,7 @@
 # Get the name of the first named selection in the simulation
 ns = simulation.named_selections[0]
 # Request nodal stresses for this named selection
-stress_named_sel = simulation.stress_nodal(named_selection=ns)
+stress_named_sel = simulation.stress_nodal(named_selections=ns)
 
 ###############################################################################
 # Print information
@@ -77,7 +77,7 @@
 # Get stresses in a few elements
 # ------------------------------
 # Request stress only for a few elements selected by their ID
-stress_elements = simulation.stress_nodal(elements=[1, 2, 3])
+stress_elements = simulation.stress_nodal(element_ids=[1, 2, 3])
 
 ###############################################################################
 # Print information

From e439c52a0bfbd6abc5e13a35c543b1c8b042d2ee Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Tue, 14 Feb 2023 09:58:41 +0100
Subject: [PATCH 24/33] component_ids -> components

---
 .../02-get_data_from_static_simulation.py     |   2 +-
 .../dpf/post/static_mechanical_simulation.py  | 186 +++++++++---------
 .../post/transient_mechanical_simulation.py   | 162 +++++++--------
 tests/test_simulation.py                      |  58 +++---
 4 files changed, 202 insertions(+), 206 deletions(-)

diff --git a/examples/00-Overview/02-get_data_from_static_simulation.py b/examples/00-Overview/02-get_data_from_static_simulation.py
index 03ee6c030..5c1ae02a2 100644
--- a/examples/00-Overview/02-get_data_from_static_simulation.py
+++ b/examples/00-Overview/02-get_data_from_static_simulation.py
@@ -33,7 +33,7 @@
 # Get and plot stresses
 # ---------------------
 # Request "XY" stress component averaged on nodes
-stress = simulation.stress_nodal(component_ids="XY")
+stress = simulation.stress_nodal(components="XY")
 
 ###############################################################################
 # Print information
diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index 3943dec19..78aa6e02c 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -240,7 +240,7 @@ def _get_result(
 
     def displacement(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -254,7 +254,7 @@ def displacement(
         """Extract displacement results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -287,7 +287,7 @@ def displacement(
             base_name="U",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -301,7 +301,7 @@ def displacement(
 
     def stress(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -314,7 +314,7 @@ def stress(
         """Extract elemental nodal stress results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -345,7 +345,7 @@ def stress(
             base_name="S",
             location=core.locations.elemental_nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -358,7 +358,7 @@ def stress(
 
     def stress_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -371,7 +371,7 @@ def stress_elemental(
         """Extract elemental stress results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -402,7 +402,7 @@ def stress_elemental(
             base_name="S",
             location=core.locations.elemental,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -415,7 +415,7 @@ def stress_elemental(
 
     def stress_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -428,7 +428,7 @@ def stress_nodal(
         """Extract nodal stress results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -459,7 +459,7 @@ def stress_nodal(
             base_name="S",
             location=core.locations.nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -472,7 +472,7 @@ def stress_nodal(
 
     def stress_principal(
         self,
-        component_ids: Union[List[str], List[int], None] = None,
+        components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[List[int], None] = None,
@@ -484,7 +484,7 @@ def stress_principal(
         """Extract elemental nodal principal stress results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -512,7 +512,7 @@ def stress_principal(
             base_name="S",
             location=core.locations.elemental_nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -525,7 +525,7 @@ def stress_principal(
 
     def stress_principal_elemental(
         self,
-        component_ids: Union[List[str], List[int], None] = None,
+        components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[List[int], None] = None,
@@ -537,7 +537,7 @@ def stress_principal_elemental(
         """Extract elemental principal stress results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -565,7 +565,7 @@ def stress_principal_elemental(
             base_name="S",
             location=core.locations.elemental,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -578,7 +578,7 @@ def stress_principal_elemental(
 
     def stress_principal_nodal(
         self,
-        component_ids: Union[List[str], List[int], None] = None,
+        components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[List[int], None] = None,
@@ -591,7 +591,7 @@ def stress_principal_nodal(
         """Extract nodal principal stress results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -621,7 +621,7 @@ def stress_principal_nodal(
             base_name="S",
             location=core.locations.nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -787,7 +787,7 @@ def stress_eqv_von_mises_nodal(
 
     def elastic_strain(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -800,7 +800,7 @@ def elastic_strain(
         """Extract stress results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -831,7 +831,7 @@ def elastic_strain(
             base_name="EPEL",
             location=core.locations.elemental_nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -844,7 +844,7 @@ def elastic_strain(
 
     def elastic_strain_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -857,7 +857,7 @@ def elastic_strain_nodal(
         """Extract stress results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -888,7 +888,7 @@ def elastic_strain_nodal(
             base_name="EPEL",
             location=core.locations.nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -901,7 +901,7 @@ def elastic_strain_nodal(
 
     def elastic_strain_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -914,7 +914,7 @@ def elastic_strain_elemental(
         """Extract stress results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -945,7 +945,7 @@ def elastic_strain_elemental(
             base_name="EPEL",
             location=core.locations.elemental,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -958,7 +958,7 @@ def elastic_strain_elemental(
 
     def elastic_strain_principal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -970,7 +970,7 @@ def elastic_strain_principal(
         """Extract elemental nodal principal elastic strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -998,7 +998,7 @@ def elastic_strain_principal(
             base_name="EPEL",
             location=core.locations.elemental_nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1011,7 +1011,7 @@ def elastic_strain_principal(
 
     def elastic_strain_principal_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1024,7 +1024,7 @@ def elastic_strain_principal_nodal(
         """Extract nodal principal elastic strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1054,7 +1054,7 @@ def elastic_strain_principal_nodal(
             base_name="EPEL",
             location=core.locations.nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1067,7 +1067,7 @@ def elastic_strain_principal_nodal(
 
     def elastic_strain_principal_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1079,7 +1079,7 @@ def elastic_strain_principal_elemental(
         """Extract elemental principal elastic strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1107,7 +1107,7 @@ def elastic_strain_principal_elemental(
             base_name="EPEL",
             location=core.locations.elemental,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1273,7 +1273,7 @@ def plastic_state_variable_nodal(
 
     def plastic_strain(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1286,7 +1286,7 @@ def plastic_strain(
         """Extract elemental nodal plastic strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -1317,7 +1317,7 @@ def plastic_strain(
             base_name="EPPL",
             location=core.locations.elemental_nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1330,7 +1330,7 @@ def plastic_strain(
 
     def plastic_strain_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1343,7 +1343,7 @@ def plastic_strain_nodal(
         """Extract nodal plastic strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -1374,7 +1374,7 @@ def plastic_strain_nodal(
             base_name="EPPL",
             location=core.locations.nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1387,7 +1387,7 @@ def plastic_strain_nodal(
 
     def plastic_strain_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1400,7 +1400,7 @@ def plastic_strain_elemental(
         """Extract elemental plastic strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -1431,7 +1431,7 @@ def plastic_strain_elemental(
             base_name="EPPL",
             location=core.locations.elemental,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1444,7 +1444,7 @@ def plastic_strain_elemental(
 
     def plastic_strain_principal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1456,7 +1456,7 @@ def plastic_strain_principal(
         """Extract elemental nodal principal plastic strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1484,7 +1484,7 @@ def plastic_strain_principal(
             base_name="EPPL",
             location=core.locations.elemental_nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1497,7 +1497,7 @@ def plastic_strain_principal(
 
     def plastic_strain_principal_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1510,7 +1510,7 @@ def plastic_strain_principal_nodal(
         """Extract nodal principal plastic strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1540,7 +1540,7 @@ def plastic_strain_principal_nodal(
             base_name="EPPL",
             location=core.locations.nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1553,7 +1553,7 @@ def plastic_strain_principal_nodal(
 
     def plastic_strain_principal_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1565,7 +1565,7 @@ def plastic_strain_principal_elemental(
         """Extract elemental principal plastic strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1593,7 +1593,7 @@ def plastic_strain_principal_elemental(
             base_name="EPPL",
             location=core.locations.elemental,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1759,7 +1759,7 @@ def plastic_strain_eqv_elemental(
 
     def creep_strain(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1772,7 +1772,7 @@ def creep_strain(
         """Extract elemental nodal creep strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -1803,7 +1803,7 @@ def creep_strain(
             base_name="ECR",
             location=core.locations.elemental_nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1816,7 +1816,7 @@ def creep_strain(
 
     def creep_strain_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1829,7 +1829,7 @@ def creep_strain_nodal(
         """Extract nodal creep strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -1860,7 +1860,7 @@ def creep_strain_nodal(
             base_name="ECR",
             location=core.locations.nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1873,7 +1873,7 @@ def creep_strain_nodal(
 
     def creep_strain_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1886,7 +1886,7 @@ def creep_strain_elemental(
         """Extract elemental creep strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -1917,7 +1917,7 @@ def creep_strain_elemental(
             base_name="ECR",
             location=core.locations.elemental,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1930,7 +1930,7 @@ def creep_strain_elemental(
 
     def creep_strain_principal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1942,7 +1942,7 @@ def creep_strain_principal(
         """Extract elemental nodal principal creep strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1970,7 +1970,7 @@ def creep_strain_principal(
             base_name="ECR",
             location=core.locations.elemental_nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -1983,7 +1983,7 @@ def creep_strain_principal(
 
     def creep_strain_principal_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -1996,7 +1996,7 @@ def creep_strain_principal_nodal(
         """Extract nodal principal creep strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -2026,7 +2026,7 @@ def creep_strain_principal_nodal(
             base_name="ECR",
             location=core.locations.nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -2039,7 +2039,7 @@ def creep_strain_principal_nodal(
 
     def creep_strain_principal_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
@@ -2051,7 +2051,7 @@ def creep_strain_principal_elemental(
         """Extract elemental principal creep strain results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -2079,7 +2079,7 @@ def creep_strain_principal_elemental(
             base_name="ECR",
             location=core.locations.elemental,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             set_ids=set_ids,
@@ -2245,7 +2245,7 @@ def creep_strain_equivalent_elemental(
 
     def reaction_force(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -2259,7 +2259,7 @@ def reaction_force(
         """Extract reaction force results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -2292,7 +2292,7 @@ def reaction_force(
             base_name="RF",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -3239,7 +3239,7 @@ def structural_temperature_elemental(
 
     def element_nodal_forces(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -3253,7 +3253,7 @@ def element_nodal_forces(
         """Extract element nodal forces results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -3286,7 +3286,7 @@ def element_nodal_forces(
             base_name="ENF",
             location=core.locations.elemental_nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -3300,7 +3300,7 @@ def element_nodal_forces(
 
     def element_nodal_forces_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -3314,7 +3314,7 @@ def element_nodal_forces_nodal(
         """Extract element nodal forces nodal results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -3347,7 +3347,7 @@ def element_nodal_forces_nodal(
             base_name="ENF",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -3361,7 +3361,7 @@ def element_nodal_forces_nodal(
 
     def element_nodal_forces_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -3374,7 +3374,7 @@ def element_nodal_forces_elemental(
         """Extract element nodal forces elemental results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -3405,7 +3405,7 @@ def element_nodal_forces_elemental(
             base_name="ENF",
             location=core.locations.elemental,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -3419,7 +3419,7 @@ def element_nodal_forces_elemental(
 
     def nodal_force(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -3433,7 +3433,7 @@ def nodal_force(
         """Extract nodal force results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -3466,7 +3466,7 @@ def nodal_force(
             base_name="F",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -3480,7 +3480,7 @@ def nodal_force(
 
     def nodal_moment(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -3494,7 +3494,7 @@ def nodal_moment(
         """Extract nodal moment results from the simulation.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -3527,7 +3527,7 @@ def nodal_moment(
             base_name="M",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index d38a2da84..9640a06bf 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -200,7 +200,7 @@ def _get_result(
 
     def displacement(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -215,7 +215,7 @@ def displacement(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -244,7 +244,7 @@ def displacement(
             base_name="U",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -256,7 +256,7 @@ def displacement(
 
     def velocity(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -271,7 +271,7 @@ def velocity(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -300,7 +300,7 @@ def velocity(
             base_name="V",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -312,7 +312,7 @@ def velocity(
 
     def acceleration(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -327,7 +327,7 @@ def acceleration(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -356,7 +356,7 @@ def acceleration(
             base_name="A",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -368,7 +368,7 @@ def acceleration(
 
     def stress(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -382,7 +382,7 @@ def stress(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -409,7 +409,7 @@ def stress(
             base_name="S",
             location=core.locations.elemental_nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -420,7 +420,7 @@ def stress(
 
     def stress_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -434,7 +434,7 @@ def stress_elemental(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -461,7 +461,7 @@ def stress_elemental(
             base_name="S",
             location=core.locations.elemental,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -472,7 +472,7 @@ def stress_elemental(
 
     def stress_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -486,7 +486,7 @@ def stress_nodal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -513,7 +513,7 @@ def stress_nodal(
             base_name="S",
             location=core.locations.nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -524,7 +524,7 @@ def stress_nodal(
 
     def stress_principal(
         self,
-        component_ids: Union[List[str], List[int], None] = None,
+        components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -537,7 +537,7 @@ def stress_principal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -561,7 +561,7 @@ def stress_principal(
             base_name="S",
             location=core.locations.elemental_nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -572,7 +572,7 @@ def stress_principal(
 
     def stress_principal_elemental(
         self,
-        component_ids: Union[List[str], List[int], None] = None,
+        components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -585,7 +585,7 @@ def stress_principal_elemental(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -609,7 +609,7 @@ def stress_principal_elemental(
             base_name="S",
             location=core.locations.elemental,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -620,7 +620,7 @@ def stress_principal_elemental(
 
     def stress_principal_nodal(
         self,
-        component_ids: Union[List[str], List[int], None] = None,
+        components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -634,7 +634,7 @@ def stress_principal_nodal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -660,7 +660,7 @@ def stress_principal_nodal(
             base_name="S",
             location=core.locations.nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -809,7 +809,7 @@ def stress_eqv_von_mises_nodal(
 
     def elastic_strain(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -823,7 +823,7 @@ def elastic_strain(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -850,7 +850,7 @@ def elastic_strain(
             base_name="EPEL",
             location=core.locations.elemental_nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -861,7 +861,7 @@ def elastic_strain(
 
     def elastic_strain_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -875,7 +875,7 @@ def elastic_strain_nodal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -902,7 +902,7 @@ def elastic_strain_nodal(
             base_name="EPEL",
             location=core.locations.nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -913,7 +913,7 @@ def elastic_strain_nodal(
 
     def elastic_strain_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -927,7 +927,7 @@ def elastic_strain_elemental(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -954,7 +954,7 @@ def elastic_strain_elemental(
             base_name="EPEL",
             location=core.locations.elemental,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -965,7 +965,7 @@ def elastic_strain_elemental(
 
     def elastic_strain_principal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -978,7 +978,7 @@ def elastic_strain_principal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1002,7 +1002,7 @@ def elastic_strain_principal(
             base_name="EPEL",
             location=core.locations.elemental_nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -1013,7 +1013,7 @@ def elastic_strain_principal(
 
     def elastic_strain_principal_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -1027,7 +1027,7 @@ def elastic_strain_principal_nodal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1053,7 +1053,7 @@ def elastic_strain_principal_nodal(
             base_name="EPEL",
             location=core.locations.nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -1064,7 +1064,7 @@ def elastic_strain_principal_nodal(
 
     def elastic_strain_principal_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -1077,7 +1077,7 @@ def elastic_strain_principal_elemental(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1101,7 +1101,7 @@ def elastic_strain_principal_elemental(
             base_name="EPEL",
             location=core.locations.elemental,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -1250,7 +1250,7 @@ def plastic_state_variable_nodal(
 
     def plastic_strain(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -1264,7 +1264,7 @@ def plastic_strain(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -1291,7 +1291,7 @@ def plastic_strain(
             base_name="EPPL",
             location=core.locations.elemental_nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -1302,7 +1302,7 @@ def plastic_strain(
 
     def plastic_strain_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -1316,7 +1316,7 @@ def plastic_strain_nodal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -1343,7 +1343,7 @@ def plastic_strain_nodal(
             base_name="EPPL",
             location=core.locations.nodal,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -1354,7 +1354,7 @@ def plastic_strain_nodal(
 
     def plastic_strain_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -1368,7 +1368,7 @@ def plastic_strain_elemental(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
             selection:
@@ -1395,7 +1395,7 @@ def plastic_strain_elemental(
             base_name="EPPL",
             location=core.locations.elemental,
             category=ResultCategory.matrix,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -1406,7 +1406,7 @@ def plastic_strain_elemental(
 
     def plastic_strain_principal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -1419,7 +1419,7 @@ def plastic_strain_principal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1443,7 +1443,7 @@ def plastic_strain_principal(
             base_name="EPPL",
             location=core.locations.elemental_nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -1454,7 +1454,7 @@ def plastic_strain_principal(
 
     def plastic_strain_principal_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -1468,7 +1468,7 @@ def plastic_strain_principal_nodal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1494,7 +1494,7 @@ def plastic_strain_principal_nodal(
             base_name="EPPL",
             location=core.locations.nodal,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -1505,7 +1505,7 @@ def plastic_strain_principal_nodal(
 
     def plastic_strain_principal_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         time_step_ids: Union[int, List[int], None] = None,
@@ -1518,7 +1518,7 @@ def plastic_strain_principal_elemental(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are: 1, 2, and 3.
             selection:
                 Selection to get results for.
@@ -1542,7 +1542,7 @@ def plastic_strain_principal_elemental(
             base_name="EPPL",
             location=core.locations.elemental,
             category=ResultCategory.principal,
-            components=component_ids,
+            components=components,
             selection=selection,
             times=times,
             time_step_ids=time_step_ids,
@@ -1691,7 +1691,7 @@ def plastic_strain_eqv_elemental(
 
     def reaction_force(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -1706,7 +1706,7 @@ def reaction_force(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -1735,7 +1735,7 @@ def reaction_force(
             base_name="RF",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -2542,7 +2542,7 @@ def structural_temperature_elemental(
 
     def element_nodal_forces(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -2557,7 +2557,7 @@ def element_nodal_forces(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -2586,7 +2586,7 @@ def element_nodal_forces(
             base_name="ENF",
             location=core.locations.elemental_nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -2598,7 +2598,7 @@ def element_nodal_forces(
 
     def element_nodal_forces_nodal(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -2613,7 +2613,7 @@ def element_nodal_forces_nodal(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -2642,7 +2642,7 @@ def element_nodal_forces_nodal(
             base_name="ENF",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -2654,7 +2654,7 @@ def element_nodal_forces_nodal(
 
     def element_nodal_forces_elemental(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -2668,7 +2668,7 @@ def element_nodal_forces_elemental(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -2695,7 +2695,7 @@ def element_nodal_forces_elemental(
             base_name="ENF",
             location=core.locations.elemental,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -2707,7 +2707,7 @@ def element_nodal_forces_elemental(
 
     def nodal_force(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -2722,7 +2722,7 @@ def nodal_force(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -2751,7 +2751,7 @@ def nodal_force(
             base_name="F",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
@@ -2763,7 +2763,7 @@ def nodal_force(
 
     def nodal_moment(
         self,
-        component_ids: Union[str, List[str], int, List[int], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
@@ -2778,7 +2778,7 @@ def nodal_moment(
         The `time_step_ids` argument then takes precedence over `times`.
 
         Args:
-            component_ids:
+            components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
@@ -2807,7 +2807,7 @@ def nodal_moment(
             base_name="M",
             location=core.locations.nodal,
             category=ResultCategory.vector,
-            components=component_ids,
+            components=components,
             norm=norm,
             selection=selection,
             times=times,
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index b8a2a4a83..3f7f826eb 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -72,12 +72,12 @@ class TestStaticMechanicalSimulation:
     def test_warning_empty(self, static_simulation):
         with pytest.warns(expected_warning=UserWarning, match="empty"):
             _ = static_simulation.displacement(
-                component_ids=1, node_ids=[1001, 1002, 1003]
+                components=1, node_ids=[1001, 1002, 1003]
             )
 
     def test_displacement(self, static_simulation):
         displacement_x = static_simulation.displacement(
-            component_ids=["X"], node_ids=[42, 43, 44], set_ids=[1]
+            components=["X"], node_ids=[42, 43, 44], set_ids=[1]
         )
         assert len(displacement_x._fc) == 1
         assert displacement_x._fc.get_time_scoping().ids == [1]
@@ -93,7 +93,7 @@ def test_displacement(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
         displacement_y = static_simulation.displacement(
-            component_ids=["2"],
+            components=["2"],
             named_selections=static_simulation.named_selections[0],
             load_steps=[1],
             sub_steps=[1],
@@ -114,7 +114,7 @@ def test_displacement(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
         displacement_z = static_simulation.displacement(
-            component_ids="Z",
+            components="Z",
             named_selections=static_simulation.named_selections[0],
             load_steps=1,
             sub_steps=1,
@@ -135,7 +135,7 @@ def test_displacement(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
         displacement_z = static_simulation.displacement(
-            component_ids="Z",
+            components="Z",
             element_ids=[1, 2, 3],
             set_ids=1,
         )
@@ -178,7 +178,7 @@ def test_displacement(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress(self, static_simulation):
-        stress_x = static_simulation.stress(component_ids=1)
+        stress_x = static_simulation.stress(components=1)
         assert len(stress_x._fc) == 1
         assert stress_x._fc.get_time_scoping().ids == [1]
         field = stress_x._fc[0]
@@ -190,7 +190,7 @@ def test_stress(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_elemental(self, static_simulation):
-        stress_x = static_simulation.stress_elemental(component_ids=1)
+        stress_x = static_simulation.stress_elemental(components=1)
         assert len(stress_x._fc) == 1
         assert stress_x._fc.get_time_scoping().ids == [1]
         field = stress_x._fc[0]
@@ -202,7 +202,7 @@ def test_stress_elemental(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_nodal(self, static_simulation):
-        stress_x = static_simulation.stress_nodal(component_ids=1)
+        stress_x = static_simulation.stress_nodal(components=1)
         assert len(stress_x._fc) == 1
         assert stress_x._fc.get_time_scoping().ids == [1]
         field = stress_x._fc[0]
@@ -214,7 +214,7 @@ def test_stress_nodal(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_principal(self, static_simulation):
-        result = static_simulation.stress_principal(component_ids=1)
+        result = static_simulation.stress_principal(components=1)
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
@@ -226,7 +226,7 @@ def test_stress_principal(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_principal_nodal(self, static_simulation):
-        result = static_simulation.stress_principal_nodal(component_ids=2)
+        result = static_simulation.stress_principal_nodal(components=2)
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
@@ -238,7 +238,7 @@ def test_stress_principal_nodal(self, static_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_principal_elemental(self, static_simulation):
-        result = static_simulation.stress_principal_elemental(component_ids=3)
+        result = static_simulation.stress_principal_elemental(components=3)
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
@@ -431,7 +431,7 @@ def test_element_nodal_forces_elemental(self, allkindofcomplexity):
 class TestTransientMechanicalSimulation:
     def test_displacement(self, transient_simulation):
         result = transient_simulation.displacement(
-            component_ids=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
+            components=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -451,7 +451,7 @@ def test_displacement(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
         result = transient_simulation.displacement(
-            component_ids=1,
+            components=1,
             named_selections=transient_simulation.named_selections[:2],
             time_step_ids=[2],
         )
@@ -463,7 +463,7 @@ def test_displacement(self, transient_simulation):
 
     def test_velocity(self, transient_simulation):
         result = transient_simulation.velocity(
-            component_ids=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
+            components=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -484,7 +484,7 @@ def test_velocity(self, transient_simulation):
 
     def test_acceleration(self, transient_simulation):
         result = transient_simulation.acceleration(
-            component_ids=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
+            components=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -504,7 +504,7 @@ def test_acceleration(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress(self, transient_simulation):
-        result = transient_simulation.stress(component_ids=1, time_step_ids=[2])
+        result = transient_simulation.stress(components=1, time_step_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -519,9 +519,7 @@ def test_stress(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_elemental(self, transient_simulation):
-        result = transient_simulation.stress_elemental(
-            component_ids=1, time_step_ids=[2]
-        )
+        result = transient_simulation.stress_elemental(components=1, time_step_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -536,7 +534,7 @@ def test_stress_elemental(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_nodal(self, transient_simulation):
-        result = transient_simulation.stress_nodal(component_ids=1, time_step_ids=[2])
+        result = transient_simulation.stress_nodal(components=1, time_step_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -551,9 +549,7 @@ def test_stress_nodal(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_principal(self, transient_simulation):
-        result = transient_simulation.stress_principal(
-            component_ids=1, time_step_ids=[2]
-        )
+        result = transient_simulation.stress_principal(components=1, time_step_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -569,7 +565,7 @@ def test_stress_principal(self, transient_simulation):
 
     def test_stress_principal_nodal(self, transient_simulation):
         result = transient_simulation.stress_principal_nodal(
-            component_ids=2, time_step_ids=[2]
+            components=2, time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -586,7 +582,7 @@ def test_stress_principal_nodal(self, transient_simulation):
 
     def test_stress_principal_elemental(self, transient_simulation):
         result = transient_simulation.stress_principal_elemental(
-            component_ids=3, time_step_ids=[2]
+            components=3, time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -647,7 +643,7 @@ def test_stress_eqv_von_mises_nodal(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_elastic_strain(self, transient_simulation):
-        result = transient_simulation.elastic_strain(component_ids=1, time_step_ids=[2])
+        result = transient_simulation.elastic_strain(components=1, time_step_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -663,7 +659,7 @@ def test_elastic_strain(self, transient_simulation):
 
     def test_elastic_strain_elemental(self, transient_simulation):
         result = transient_simulation.elastic_strain_elemental(
-            component_ids=1, time_step_ids=[2]
+            components=1, time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -680,7 +676,7 @@ def test_elastic_strain_elemental(self, transient_simulation):
 
     def test_elastic_strain_nodal(self, transient_simulation):
         result = transient_simulation.elastic_strain_nodal(
-            component_ids=1, time_step_ids=[2]
+            components=1, time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -697,7 +693,7 @@ def test_elastic_strain_nodal(self, transient_simulation):
 
     def test_elastic_strain_principal(self, transient_simulation):
         result = transient_simulation.elastic_strain_principal(
-            component_ids=1, time_step_ids=[2]
+            components=1, time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -714,7 +710,7 @@ def test_elastic_strain_principal(self, transient_simulation):
 
     def test_elastic_strain_principal_nodal(self, transient_simulation):
         result = transient_simulation.elastic_strain_principal_nodal(
-            component_ids=2, time_step_ids=[2]
+            components=2, time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -731,7 +727,7 @@ def test_elastic_strain_principal_nodal(self, transient_simulation):
 
     def test_elastic_strain_principal_elemental(self, transient_simulation):
         result = transient_simulation.elastic_strain_principal_elemental(
-            component_ids=3, time_step_ids=[2]
+            components=3, time_step_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]

From 9df31140e24873c33eafa90e959a7d6932075601 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Tue, 14 Feb 2023 10:13:20 +0100
Subject: [PATCH 25/33] Also use set_ids, load_steps, and sub_steps, in
 signatures for transient_mechanical_simulation.py

---
 src/ansys/dpf/post/simulation.py              |   60 +
 .../dpf/post/static_mechanical_simulation.py  |  308 +++-
 .../post/transient_mechanical_simulation.py   | 1321 +++++++++++++----
 tests/test_simulation.py                      |   66 +-
 4 files changed, 1364 insertions(+), 391 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 0235d5859..020232ec9 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -450,6 +450,66 @@ def _build_mesh_scoping(
 
         return mesh_scoping
 
+    def _build_time_freq_scoping(
+        self,
+        selection: Union[Selection, None],
+        times: Union[float, List[float], None],
+        set_ids: Union[int, List[int], None],
+        load_steps: Union[int, List[int], None],
+        sub_steps: Union[int, List[int], None],
+    ) -> core.time_freq_scoping_factory.Scoping:
+        """Generate a time_freq_scoping from input arguments."""
+        # create from selection in priority
+        if selection:
+            return selection.time_freq_selection._evaluate_on(simulation=self)
+        # else from set_ids
+        if set_ids:
+            if isinstance(set_ids, int):
+                set_ids = [set_ids]
+            return core.time_freq_scoping_factory.scoping_by_sets(
+                cumulative_sets=set_ids, server=self._model._server
+            )
+        # else from times
+        if times:
+            if isinstance(times, float):
+                times = [times]
+            raise NotImplementedError
+        # else from sub_steps and load_steps
+        if sub_steps:
+            if isinstance(sub_steps, int):
+                sub_steps = [sub_steps]
+            if isinstance(load_steps, int):
+                load_steps = [load_steps]
+            elif (
+                not load_steps
+                or (isinstance(load_steps, list) and len(load_steps)) != 1
+            ):
+                raise ValueError(
+                    "Argument sub_steps requires argument load_steps to have one value."
+                )
+            # Translate to cumulative indices (set IDs)
+            set_ids = []
+            for sub_step in sub_steps:
+                set_id = (
+                    self._model.metadata.time_freq_support.get_cumulative_index(
+                        step=load_steps[0] - 1, substep=sub_step
+                    )
+                    + 2
+                )
+                set_ids.append(set_id)
+            return core.time_freq_scoping_factory.scoping_by_sets(
+                cumulative_sets=set_ids, server=self._model._server
+            )
+        # else load_steps only
+        if load_steps:
+            if isinstance(load_steps, int):
+                load_steps = [load_steps]
+            return core.time_freq_scoping_factory.scoping_by_load_steps(
+                load_steps=load_steps, server=self._model._server
+            )
+        # Otherwise, no argument was given, create a time_freq_scoping of the whole results
+        return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
+
 
 class ModalMechanicalSimulation(MechanicalSimulation):
     """Provides methods for mechanical modal simulations."""
diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index 78aa6e02c..fdbfab320 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -11,66 +11,6 @@
 class StaticMechanicalSimulation(MechanicalSimulation):
     """Provides methods for mechanical static simulations."""
 
-    def _build_time_freq_scoping(
-        self,
-        selection: Union[Selection, None],
-        times: Union[float, List[float], None],
-        set_ids: Union[int, List[int], None],
-        load_steps: Union[int, List[int], None],
-        sub_steps: Union[int, List[int], None],
-    ) -> core.time_freq_scoping_factory.Scoping:
-        """Generate a time_freq_scoping from input arguments."""
-        # create from selection in priority
-        if selection:
-            return selection.time_freq_selection._evaluate_on(simulation=self)
-        # else from set_ids
-        if set_ids:
-            if isinstance(set_ids, int):
-                set_ids = [set_ids]
-            return core.time_freq_scoping_factory.scoping_by_sets(
-                cumulative_sets=set_ids, server=self._model._server
-            )
-        # else from times
-        if times:
-            if isinstance(times, float):
-                times = [times]
-            raise NotImplementedError
-        # else from sub_steps and load_steps
-        if sub_steps:
-            if isinstance(sub_steps, int):
-                sub_steps = [sub_steps]
-            if isinstance(load_steps, int):
-                load_steps = [load_steps]
-            elif (
-                not load_steps
-                or (isinstance(load_steps, list) and len(load_steps)) != 1
-            ):
-                raise ValueError(
-                    "Argument sub_steps requires argument load_steps to have one value."
-                )
-            # Translate to cumulative indices (set IDs)
-            set_ids = []
-            for sub_step in sub_steps:
-                set_id = (
-                    self._model.metadata.time_freq_support.get_cumulative_index(
-                        step=load_steps[0] - 1, substep=sub_step
-                    )
-                    + 2
-                )
-                set_ids.append(set_id)
-            return core.time_freq_scoping_factory.scoping_by_sets(
-                cumulative_sets=set_ids, server=self._model._server
-            )
-        # else load_steps only
-        if load_steps:
-            if isinstance(load_steps, int):
-                load_steps = [load_steps]
-            return core.time_freq_scoping_factory.scoping_by_load_steps(
-                load_steps=load_steps, server=self._model._server
-            )
-        # Otherwise, no argument was given, create a time_freq_scoping of the whole results
-        return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
-
     def _get_result(
         self,
         base_name: str,
@@ -89,6 +29,10 @@ def _get_result(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             base_name:
                 Base name for the requested result.
@@ -253,6 +197,10 @@ def displacement(
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -313,6 +261,10 @@ def stress(
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -370,6 +322,10 @@ def stress_elemental(
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -427,6 +383,10 @@ def stress_nodal(
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -483,6 +443,10 @@ def stress_principal(
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -536,6 +500,10 @@ def stress_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -590,6 +558,10 @@ def stress_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -644,6 +616,10 @@ def stress_eqv_von_mises(
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -694,6 +670,10 @@ def stress_eqv_von_mises_elemental(
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -745,6 +725,10 @@ def stress_eqv_von_mises_nodal(
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -799,6 +783,10 @@ def elastic_strain(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -856,6 +844,10 @@ def elastic_strain_nodal(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -913,6 +905,10 @@ def elastic_strain_elemental(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -969,6 +965,10 @@ def elastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1023,6 +1023,10 @@ def elastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1078,6 +1082,10 @@ def elastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1130,6 +1138,10 @@ def plastic_state_variable(
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1180,6 +1192,10 @@ def plastic_state_variable_elemental(
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1231,6 +1247,10 @@ def plastic_state_variable_nodal(
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1285,6 +1305,10 @@ def plastic_strain(
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -1342,6 +1366,10 @@ def plastic_strain_nodal(
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -1399,6 +1427,10 @@ def plastic_strain_elemental(
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -1455,6 +1487,10 @@ def plastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1509,6 +1545,10 @@ def plastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1564,6 +1604,10 @@ def plastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1616,6 +1660,10 @@ def plastic_strain_eqv(
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1667,6 +1715,10 @@ def plastic_strain_eqv_nodal(
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1719,6 +1771,10 @@ def plastic_strain_eqv_elemental(
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -1771,6 +1827,10 @@ def creep_strain(
     ) -> DataObject:
         """Extract elemental nodal creep strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -1828,6 +1888,10 @@ def creep_strain_nodal(
     ) -> DataObject:
         """Extract nodal creep strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -1885,6 +1949,10 @@ def creep_strain_elemental(
     ) -> DataObject:
         """Extract elemental creep strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
@@ -1941,6 +2009,10 @@ def creep_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal creep strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -1995,6 +2067,10 @@ def creep_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal creep strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -2050,6 +2126,10 @@ def creep_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal creep strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
@@ -2102,6 +2182,10 @@ def creep_strain_eqv(
     ) -> DataObject:
         """Extract elemental nodal equivalent creep strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2153,6 +2237,10 @@ def creep_strain_equivalent_nodal(
     ) -> DataObject:
         """Extract nodal equivalent creep strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2205,6 +2293,10 @@ def creep_strain_equivalent_elemental(
     ) -> DataObject:
         """Extract elemental equivalent creep strain results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2258,6 +2350,10 @@ def reaction_force(
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -2316,6 +2412,10 @@ def elemental_volume(
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2366,6 +2466,10 @@ def elemental_mass(
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2416,6 +2520,10 @@ def elemental_heat_generation(
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2466,6 +2574,10 @@ def element_centroids(
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2516,6 +2628,10 @@ def thickness(
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2566,6 +2682,10 @@ def element_orientations(
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2616,6 +2736,10 @@ def element_orientations_elemental(
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2667,6 +2791,10 @@ def element_orientations_nodal(
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2720,6 +2848,10 @@ def stiffness_matrix_energy(
     ) -> DataObject:
         """Extract stiffness matrix energy results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2773,6 +2905,10 @@ def artificial_hourglass_energy(
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2826,6 +2962,10 @@ def thermal_dissipation_energy(
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2879,6 +3019,10 @@ def kinetic_energy(
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2932,6 +3076,10 @@ def hydrostatic_pressure(
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -2985,6 +3133,10 @@ def hydrostatic_pressure_nodal(
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -3038,6 +3190,10 @@ def hydrostatic_pressure_elemental(
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -3091,6 +3247,10 @@ def structural_temperature(
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -3144,6 +3304,10 @@ def structural_temperature_nodal(
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -3197,6 +3361,10 @@ def structural_temperature_elemental(
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             selection:
                 Selection to get results for.
@@ -3252,6 +3420,10 @@ def element_nodal_forces(
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -3313,6 +3485,10 @@ def element_nodal_forces_nodal(
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -3373,6 +3549,10 @@ def element_nodal_forces_elemental(
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -3432,6 +3612,10 @@ def nodal_force(
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
@@ -3493,6 +3677,10 @@ def nodal_moment(
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
         Args:
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index 9640a06bf..dbabb6fe3 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -11,31 +11,6 @@
 class TransientMechanicalSimulation(MechanicalSimulation):
     """Provides methods for mechanical transient simulations."""
 
-    def _build_time_freq_scoping(
-        self,
-        selection: Union[Selection, None],
-        time_step_ids: Union[int, List[int], None],
-        times: Union[float, List[float], None],
-    ) -> core.time_freq_scoping_factory.Scoping:
-        """Generate a time_freq_scoping from input arguments."""
-        # create from selection in priority
-        if selection:
-            return selection.time_freq_selection._evaluate_on(simulation=self)
-        # else from time_step_ids
-        if time_step_ids:
-            if isinstance(time_step_ids, int):
-                time_step_ids = [time_step_ids]
-            return core.time_freq_scoping_factory.scoping_by_sets(
-                cumulative_sets=time_step_ids, server=self._model._server
-            )
-        # else from times
-        if times:
-            if isinstance(times, float):
-                times = [times]
-            raise NotImplementedError
-        # Otherwise, no argument was given, create a time_freq_scoping of the whole results
-        return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
-
     def _get_result(
         self,
         base_name: str,
@@ -45,7 +20,9 @@ def _get_result(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -53,7 +30,12 @@ def _get_result(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             base_name:
@@ -72,8 +54,13 @@ def _get_result(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -87,7 +74,9 @@ def _get_result(
 
         """
         # Build the targeted time scoping
-        time_scoping = self._build_time_freq_scoping(selection, time_step_ids, times)
+        time_scoping = self._build_time_freq_scoping(
+            selection, times, set_ids, load_steps, sub_steps
+        )
 
         # Build the targeted mesh scoping
         mesh_scoping = self._build_mesh_scoping(
@@ -204,7 +193,9 @@ def displacement(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -212,7 +203,12 @@ def displacement(
         """Extract displacement results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -226,8 +222,13 @@ def displacement(
                 It takes precedence over any other filter argument.
             times:
                 Times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -248,7 +249,9 @@ def displacement(
             norm=norm,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -260,7 +263,9 @@ def velocity(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -268,7 +273,12 @@ def velocity(
         """Extract velocity results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -282,8 +292,13 @@ def velocity(
                 It takes precedence over any other filter argument.
             times:
                 Times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -304,7 +319,9 @@ def velocity(
             norm=norm,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -316,7 +333,9 @@ def acceleration(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -324,7 +343,12 @@ def acceleration(
         """Extract acceleration results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -338,8 +362,13 @@ def acceleration(
                 It takes precedence over any other filter argument.
             times:
                 Times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -360,7 +389,9 @@ def acceleration(
             norm=norm,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -371,7 +402,9 @@ def stress(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -379,7 +412,12 @@ def stress(
         """Extract elemental nodal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -391,8 +429,13 @@ def stress(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -412,7 +455,9 @@ def stress(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -423,7 +468,9 @@ def stress_elemental(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -431,7 +478,12 @@ def stress_elemental(
         """Extract elemental stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -443,8 +495,13 @@ def stress_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -464,7 +521,9 @@ def stress_elemental(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -475,7 +534,9 @@ def stress_nodal(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -483,7 +544,12 @@ def stress_nodal(
         """Extract nodal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -495,8 +561,13 @@ def stress_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -516,7 +587,9 @@ def stress_nodal(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -527,14 +600,21 @@ def stress_principal(
         components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -545,8 +625,13 @@ def stress_principal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -564,7 +649,9 @@ def stress_principal(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -575,14 +662,21 @@ def stress_principal_elemental(
         components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -593,8 +687,13 @@ def stress_principal_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -612,7 +711,9 @@ def stress_principal_elemental(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -623,7 +724,9 @@ def stress_principal_nodal(
         components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -631,7 +734,12 @@ def stress_principal_nodal(
         """Extract nodal principal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -642,8 +750,13 @@ def stress_principal_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -663,7 +776,9 @@ def stress_principal_nodal(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -673,14 +788,21 @@ def stress_eqv_von_mises(
         self,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -689,8 +811,13 @@ def stress_eqv_von_mises(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -708,7 +835,9 @@ def stress_eqv_von_mises(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -718,14 +847,21 @@ def stress_eqv_von_mises_elemental(
         self,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -734,8 +870,13 @@ def stress_eqv_von_mises_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -753,7 +894,9 @@ def stress_eqv_von_mises_elemental(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -763,7 +906,9 @@ def stress_eqv_von_mises_nodal(
         self,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -771,7 +916,12 @@ def stress_eqv_von_mises_nodal(
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -780,8 +930,13 @@ def stress_eqv_von_mises_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -801,7 +956,9 @@ def stress_eqv_von_mises_nodal(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -812,7 +969,9 @@ def elastic_strain(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -820,7 +979,12 @@ def elastic_strain(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -832,8 +996,13 @@ def elastic_strain(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -853,7 +1022,9 @@ def elastic_strain(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -864,7 +1035,9 @@ def elastic_strain_nodal(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -872,7 +1045,12 @@ def elastic_strain_nodal(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -884,8 +1062,13 @@ def elastic_strain_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -905,7 +1088,9 @@ def elastic_strain_nodal(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -916,7 +1101,9 @@ def elastic_strain_elemental(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -924,7 +1111,12 @@ def elastic_strain_elemental(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -936,8 +1128,13 @@ def elastic_strain_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -957,7 +1154,9 @@ def elastic_strain_elemental(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -968,14 +1167,21 @@ def elastic_strain_principal(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -986,8 +1192,13 @@ def elastic_strain_principal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1005,7 +1216,9 @@ def elastic_strain_principal(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1016,7 +1229,9 @@ def elastic_strain_principal_nodal(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1024,7 +1239,12 @@ def elastic_strain_principal_nodal(
         """Extract nodal principal elastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -1035,8 +1255,13 @@ def elastic_strain_principal_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1056,7 +1281,9 @@ def elastic_strain_principal_nodal(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1067,14 +1294,21 @@ def elastic_strain_principal_elemental(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -1085,8 +1319,13 @@ def elastic_strain_principal_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1104,7 +1343,9 @@ def elastic_strain_principal_elemental(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1114,14 +1355,21 @@ def plastic_state_variable(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1130,8 +1378,13 @@ def plastic_state_variable(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1149,7 +1402,9 @@ def plastic_state_variable(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1159,14 +1414,21 @@ def plastic_state_variable_elemental(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1175,8 +1437,13 @@ def plastic_state_variable_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1194,7 +1461,9 @@ def plastic_state_variable_elemental(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1204,7 +1473,9 @@ def plastic_state_variable_nodal(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1212,7 +1483,12 @@ def plastic_state_variable_nodal(
         """Extract nodal plastic state variable results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1221,8 +1497,13 @@ def plastic_state_variable_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1242,7 +1523,9 @@ def plastic_state_variable_nodal(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1253,7 +1536,9 @@ def plastic_strain(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1261,7 +1546,12 @@ def plastic_strain(
         """Extract elemental nodal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -1273,8 +1563,13 @@ def plastic_strain(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1294,7 +1589,9 @@ def plastic_strain(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1305,7 +1602,9 @@ def plastic_strain_nodal(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1313,7 +1612,12 @@ def plastic_strain_nodal(
         """Extract nodal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -1325,8 +1629,13 @@ def plastic_strain_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1346,7 +1655,9 @@ def plastic_strain_nodal(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1357,7 +1668,9 @@ def plastic_strain_elemental(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1365,7 +1678,12 @@ def plastic_strain_elemental(
         """Extract elemental plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -1377,8 +1695,13 @@ def plastic_strain_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1398,7 +1721,9 @@ def plastic_strain_elemental(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1409,14 +1734,21 @@ def plastic_strain_principal(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -1427,8 +1759,13 @@ def plastic_strain_principal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1446,7 +1783,9 @@ def plastic_strain_principal(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1457,7 +1796,9 @@ def plastic_strain_principal_nodal(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1465,7 +1806,12 @@ def plastic_strain_principal_nodal(
         """Extract nodal principal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -1476,8 +1822,13 @@ def plastic_strain_principal_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1497,7 +1848,9 @@ def plastic_strain_principal_nodal(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1508,14 +1861,21 @@ def plastic_strain_principal_elemental(
         components: Union[str, List[str], int, List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -1526,8 +1886,13 @@ def plastic_strain_principal_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1545,7 +1910,9 @@ def plastic_strain_principal_elemental(
             components=components,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1555,14 +1922,21 @@ def plastic_strain_eqv(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1571,8 +1945,13 @@ def plastic_strain_eqv(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1590,7 +1969,9 @@ def plastic_strain_eqv(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1600,7 +1981,9 @@ def plastic_strain_eqv_nodal(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1608,7 +1991,12 @@ def plastic_strain_eqv_nodal(
         """Extract nodal equivalent plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1617,8 +2005,13 @@ def plastic_strain_eqv_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1638,7 +2031,9 @@ def plastic_strain_eqv_nodal(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1648,14 +2043,21 @@ def plastic_strain_eqv_elemental(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1664,8 +2066,13 @@ def plastic_strain_eqv_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1683,7 +2090,9 @@ def plastic_strain_eqv_elemental(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1695,7 +2104,9 @@ def reaction_force(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1703,7 +2114,12 @@ def reaction_force(
         """Extract reaction force results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -1717,8 +2133,13 @@ def reaction_force(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1739,7 +2160,9 @@ def reaction_force(
             norm=norm,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1749,14 +2172,21 @@ def elemental_volume(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1765,8 +2195,13 @@ def elemental_volume(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1784,7 +2219,9 @@ def elemental_volume(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1794,14 +2231,21 @@ def elemental_mass(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1810,8 +2254,13 @@ def elemental_mass(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1829,7 +2278,9 @@ def elemental_mass(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1839,14 +2290,21 @@ def elemental_heat_generation(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1855,8 +2313,13 @@ def elemental_heat_generation(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1874,7 +2337,9 @@ def elemental_heat_generation(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1884,14 +2349,21 @@ def element_centroids(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1900,8 +2372,13 @@ def element_centroids(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1919,7 +2396,9 @@ def element_centroids(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1929,14 +2408,21 @@ def thickness(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1945,8 +2431,13 @@ def thickness(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1964,7 +2455,9 @@ def thickness(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1974,14 +2467,21 @@ def element_orientations(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -1990,8 +2490,13 @@ def element_orientations(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2009,7 +2514,9 @@ def element_orientations(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2019,14 +2526,21 @@ def element_orientations_elemental(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2035,8 +2549,13 @@ def element_orientations_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2054,7 +2573,9 @@ def element_orientations_elemental(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2064,7 +2585,9 @@ def element_orientations_nodal(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2072,7 +2595,12 @@ def element_orientations_nodal(
         """Extract nodal element orientations results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2081,8 +2609,13 @@ def element_orientations_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2102,7 +2635,9 @@ def element_orientations_nodal(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2112,7 +2647,9 @@ def artificial_hourglass_energy(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2120,7 +2657,12 @@ def artificial_hourglass_energy(
         """Extract artificial hourglass energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2129,8 +2671,13 @@ def artificial_hourglass_energy(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2150,7 +2697,9 @@ def artificial_hourglass_energy(
             components="",
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2160,7 +2709,9 @@ def thermal_dissipation_energy(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2168,7 +2719,12 @@ def thermal_dissipation_energy(
         """Extract thermal dissipation energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2177,8 +2733,13 @@ def thermal_dissipation_energy(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2198,7 +2759,9 @@ def thermal_dissipation_energy(
             components="",
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2208,7 +2771,9 @@ def kinetic_energy(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2216,7 +2781,12 @@ def kinetic_energy(
         """Extract kinetic energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2225,8 +2795,13 @@ def kinetic_energy(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2246,7 +2821,9 @@ def kinetic_energy(
             components="",
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2256,7 +2833,9 @@ def hydrostatic_pressure(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2264,7 +2843,12 @@ def hydrostatic_pressure(
         """Extract hydrostatic pressure element nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2273,8 +2857,13 @@ def hydrostatic_pressure(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2294,7 +2883,9 @@ def hydrostatic_pressure(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2304,7 +2895,9 @@ def hydrostatic_pressure_nodal(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2312,7 +2905,12 @@ def hydrostatic_pressure_nodal(
         """Extract hydrostatic pressure nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2321,8 +2919,13 @@ def hydrostatic_pressure_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2342,7 +2945,9 @@ def hydrostatic_pressure_nodal(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2352,7 +2957,9 @@ def hydrostatic_pressure_elemental(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2360,7 +2967,12 @@ def hydrostatic_pressure_elemental(
         """Extract hydrostatic pressure elemental results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2369,8 +2981,13 @@ def hydrostatic_pressure_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2390,7 +3007,9 @@ def hydrostatic_pressure_elemental(
             components=None,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2400,7 +3019,9 @@ def structural_temperature(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2408,7 +3029,12 @@ def structural_temperature(
         """Extract structural temperature element nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2417,8 +3043,13 @@ def structural_temperature(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2438,7 +3069,9 @@ def structural_temperature(
             components="",
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2448,7 +3081,9 @@ def structural_temperature_nodal(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2456,7 +3091,12 @@ def structural_temperature_nodal(
         """Extract structural temperature nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2465,8 +3105,13 @@ def structural_temperature_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2486,7 +3131,9 @@ def structural_temperature_nodal(
             components="",
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2496,7 +3143,9 @@ def structural_temperature_elemental(
         self,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2504,7 +3153,12 @@ def structural_temperature_elemental(
         """Extract structural temperature elemental results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             selection:
@@ -2513,8 +3167,13 @@ def structural_temperature_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2534,7 +3193,9 @@ def structural_temperature_elemental(
             components="",
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2546,7 +3207,9 @@ def element_nodal_forces(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2554,7 +3217,12 @@ def element_nodal_forces(
         """Extract element nodal forces results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -2568,8 +3236,13 @@ def element_nodal_forces(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2590,7 +3263,9 @@ def element_nodal_forces(
             norm=norm,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2602,7 +3277,9 @@ def element_nodal_forces_nodal(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2610,7 +3287,12 @@ def element_nodal_forces_nodal(
         """Extract element nodal forces nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -2624,8 +3306,13 @@ def element_nodal_forces_nodal(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2646,7 +3333,9 @@ def element_nodal_forces_nodal(
             norm=norm,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2658,14 +3347,21 @@ def element_nodal_forces_elemental(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -2679,8 +3375,13 @@ def element_nodal_forces_elemental(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2699,7 +3400,9 @@ def element_nodal_forces_elemental(
             norm=norm,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2711,7 +3414,9 @@ def nodal_force(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2719,7 +3424,12 @@ def nodal_force(
         """Extract nodal force results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -2733,8 +3443,13 @@ def nodal_force(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2755,7 +3470,9 @@ def nodal_force(
             norm=norm,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2767,7 +3484,9 @@ def nodal_moment(
         norm: bool = False,
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
-        time_step_ids: Union[int, List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        load_steps: Union[int, List[int], None] = None,
+        sub_steps: Union[int, List[int], None] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2775,7 +3494,12 @@ def nodal_moment(
         """Extract nodal moment results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        The `time_step_ids` argument then takes precedence over `times`.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+
+        The `selection` argument overrides any other filtering argument.
+        Then, in order of priority (and from fine to coarse), the time selection argument
+        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
 
         Args:
             components:
@@ -2789,8 +3513,13 @@ def nodal_moment(
                 It takes precedence over any other filter argument.
             times:
                 List of times to get results for.
-            time_steps_ids:
-                List of time steps IDs to get results for.
+            set_ids:
+                List of sets to get results for.
+                A set is defined as a unique combination of {time, load step, sub-step}.
+            load_steps:
+                List of load steps to get results for.
+            sub_steps:
+                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2811,7 +3540,9 @@ def nodal_moment(
             norm=norm,
             selection=selection,
             times=times,
-            time_step_ids=time_step_ids,
+            set_ids=set_ids,
+            load_steps=load_steps,
+            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index 3f7f826eb..63c446172 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -431,7 +431,7 @@ def test_element_nodal_forces_elemental(self, allkindofcomplexity):
 class TestTransientMechanicalSimulation:
     def test_displacement(self, transient_simulation):
         result = transient_simulation.displacement(
-            components=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
+            components=["X"], node_ids=[2, 3, 4], set_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -453,7 +453,7 @@ def test_displacement(self, transient_simulation):
         result = transient_simulation.displacement(
             components=1,
             named_selections=transient_simulation.named_selections[:2],
-            time_step_ids=[2],
+            set_ids=[2],
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -463,7 +463,7 @@ def test_displacement(self, transient_simulation):
 
     def test_velocity(self, transient_simulation):
         result = transient_simulation.velocity(
-            components=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
+            components=["X"], node_ids=[2, 3, 4], set_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -484,7 +484,7 @@ def test_velocity(self, transient_simulation):
 
     def test_acceleration(self, transient_simulation):
         result = transient_simulation.acceleration(
-            components=["X"], node_ids=[2, 3, 4], time_step_ids=[2]
+            components=["X"], node_ids=[2, 3, 4], set_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -504,7 +504,7 @@ def test_acceleration(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress(self, transient_simulation):
-        result = transient_simulation.stress(components=1, time_step_ids=[2])
+        result = transient_simulation.stress(components=1, set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -519,7 +519,7 @@ def test_stress(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_elemental(self, transient_simulation):
-        result = transient_simulation.stress_elemental(components=1, time_step_ids=[2])
+        result = transient_simulation.stress_elemental(components=1, set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -534,7 +534,7 @@ def test_stress_elemental(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_nodal(self, transient_simulation):
-        result = transient_simulation.stress_nodal(components=1, time_step_ids=[2])
+        result = transient_simulation.stress_nodal(components=1, set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -549,7 +549,7 @@ def test_stress_nodal(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_principal(self, transient_simulation):
-        result = transient_simulation.stress_principal(components=1, time_step_ids=[2])
+        result = transient_simulation.stress_principal(components=1, set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -564,9 +564,7 @@ def test_stress_principal(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_principal_nodal(self, transient_simulation):
-        result = transient_simulation.stress_principal_nodal(
-            components=2, time_step_ids=[2]
-        )
+        result = transient_simulation.stress_principal_nodal(components=2, set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -582,7 +580,7 @@ def test_stress_principal_nodal(self, transient_simulation):
 
     def test_stress_principal_elemental(self, transient_simulation):
         result = transient_simulation.stress_principal_elemental(
-            components=3, time_step_ids=[2]
+            components=3, set_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -598,7 +596,7 @@ def test_stress_principal_elemental(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_eqv_von_mises(self, transient_simulation):
-        result = transient_simulation.stress_eqv_von_mises(time_step_ids=[2])
+        result = transient_simulation.stress_eqv_von_mises(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -613,7 +611,7 @@ def test_stress_eqv_von_mises(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_eqv_von_mises_elemental(self, transient_simulation):
-        result = transient_simulation.stress_eqv_von_mises_elemental(time_step_ids=[2])
+        result = transient_simulation.stress_eqv_von_mises_elemental(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -628,7 +626,7 @@ def test_stress_eqv_von_mises_elemental(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_stress_eqv_von_mises_nodal(self, transient_simulation):
-        result = transient_simulation.stress_eqv_von_mises_nodal(time_step_ids=[2])
+        result = transient_simulation.stress_eqv_von_mises_nodal(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -643,7 +641,7 @@ def test_stress_eqv_von_mises_nodal(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_elastic_strain(self, transient_simulation):
-        result = transient_simulation.elastic_strain(components=1, time_step_ids=[2])
+        result = transient_simulation.elastic_strain(components=1, set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -659,7 +657,7 @@ def test_elastic_strain(self, transient_simulation):
 
     def test_elastic_strain_elemental(self, transient_simulation):
         result = transient_simulation.elastic_strain_elemental(
-            components=1, time_step_ids=[2]
+            components=1, set_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -675,9 +673,7 @@ def test_elastic_strain_elemental(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_elastic_strain_nodal(self, transient_simulation):
-        result = transient_simulation.elastic_strain_nodal(
-            components=1, time_step_ids=[2]
-        )
+        result = transient_simulation.elastic_strain_nodal(components=1, set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -693,7 +689,7 @@ def test_elastic_strain_nodal(self, transient_simulation):
 
     def test_elastic_strain_principal(self, transient_simulation):
         result = transient_simulation.elastic_strain_principal(
-            components=1, time_step_ids=[2]
+            components=1, set_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -710,7 +706,7 @@ def test_elastic_strain_principal(self, transient_simulation):
 
     def test_elastic_strain_principal_nodal(self, transient_simulation):
         result = transient_simulation.elastic_strain_principal_nodal(
-            components=2, time_step_ids=[2]
+            components=2, set_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -727,7 +723,7 @@ def test_elastic_strain_principal_nodal(self, transient_simulation):
 
     def test_elastic_strain_principal_elemental(self, transient_simulation):
         result = transient_simulation.elastic_strain_principal_elemental(
-            components=3, time_step_ids=[2]
+            components=3, set_ids=[2]
         )
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
@@ -747,7 +743,7 @@ def test_reaction_force(self, allkindofcomplexity):
             data_sources=allkindofcomplexity,
             simulation_type=AvailableSimulationTypes.transient_mechanical,
         )
-        result = transient_simulation.reaction_force(time_step_ids=[1])
+        result = transient_simulation.reaction_force(set_ids=[1])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
@@ -757,7 +753,7 @@ def test_reaction_force(self, allkindofcomplexity):
         assert np.allclose(field.data, field_ref.data)
 
     def test_elemental_volume(self, transient_simulation):
-        result = transient_simulation.elemental_volume(time_step_ids=[2])
+        result = transient_simulation.elemental_volume(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -768,7 +764,7 @@ def test_elemental_volume(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_artificial_hourglass_energy(self, transient_simulation):
-        result = transient_simulation.artificial_hourglass_energy(time_step_ids=[2])
+        result = transient_simulation.artificial_hourglass_energy(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -778,7 +774,7 @@ def test_artificial_hourglass_energy(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_thermal_dissipation_energy(self, transient_simulation):
-        result = transient_simulation.thermal_dissipation_energy(time_step_ids=[2])
+        result = transient_simulation.thermal_dissipation_energy(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -788,7 +784,7 @@ def test_thermal_dissipation_energy(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_kinetic_energy(self, transient_simulation):
-        result = transient_simulation.kinetic_energy(time_step_ids=[2])
+        result = transient_simulation.kinetic_energy(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -798,7 +794,7 @@ def test_kinetic_energy(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_structural_temperature(self, transient_simulation):
-        result = transient_simulation.structural_temperature(time_step_ids=[2])
+        result = transient_simulation.structural_temperature(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -808,7 +804,7 @@ def test_structural_temperature(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_structural_temperature_nodal(self, transient_simulation):
-        result = transient_simulation.structural_temperature_nodal(time_step_ids=[2])
+        result = transient_simulation.structural_temperature_nodal(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -819,9 +815,7 @@ def test_structural_temperature_nodal(self, transient_simulation):
         assert np.allclose(field.data, field_ref.data)
 
     def test_structural_temperature_elemental(self, transient_simulation):
-        result = transient_simulation.structural_temperature_elemental(
-            time_step_ids=[2]
-        )
+        result = transient_simulation.structural_temperature_elemental(set_ids=[2])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [2]
         field = result._fc[0]
@@ -836,7 +830,7 @@ def test_element_nodal_forces(self, allkindofcomplexity):
             data_sources=allkindofcomplexity,
             simulation_type=AvailableSimulationTypes.transient_mechanical,
         )
-        result = transient_simulation.element_nodal_forces(time_step_ids=[1])
+        result = transient_simulation.element_nodal_forces(set_ids=[1])
         assert len(result._fc) == 1
         assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
@@ -850,7 +844,7 @@ def test_element_nodal_forces_nodal(self, allkindofcomplexity):
             data_sources=allkindofcomplexity,
             simulation_type=AvailableSimulationTypes.transient_mechanical,
         )
-        result = transient_simulation.element_nodal_forces_nodal(time_step_ids=[1])
+        result = transient_simulation.element_nodal_forces_nodal(set_ids=[1])
         assert len(result._fc) == 3
         assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]
@@ -865,7 +859,7 @@ def test_element_nodal_forces_elemental(self, allkindofcomplexity):
             data_sources=allkindofcomplexity,
             simulation_type=AvailableSimulationTypes.transient_mechanical,
         )
-        result = transient_simulation.element_nodal_forces_elemental(time_step_ids=[1])
+        result = transient_simulation.element_nodal_forces_elemental(set_ids=[1])
         assert len(result._fc) == 3
         assert result._fc.get_time_scoping().ids == [1]
         field = result._fc[0]

From 409869beadba9f638c210a87fc14c51bb7e9afe2 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Tue, 14 Feb 2023 15:33:48 +0100
Subject: [PATCH 26/33] _build_mesh_scoping now returns either a Scoping or an
 operator Output giving a Scoping.

---
 src/ansys/dpf/post/simulation.py | 47 +++++++++++++++-----------------
 1 file changed, 22 insertions(+), 25 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 020232ec9..03377df31 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -351,11 +351,17 @@ def _build_components_from_principal(self, base_name, components):
         return out, columns
 
     @abstractmethod
-    def _build_mesh_scoping(self) -> core.mesh_scoping_factory.Scoping:
+    def _build_mesh_scoping(self) -> Union[core.Scoping, core.outputs.Output, None]:
         """Generate a mesh_scoping from input arguments."""
         pass
 
-    def _build_result_operator(self, name, time_scoping, mesh_scoping, location):
+    def _build_result_operator(
+        self,
+        name: str,
+        time_scoping: core.Scoping,
+        mesh_scoping: Union[core.Scoping, core.outputs.Output],
+        location: core.locations,
+    ) -> core.Operator:
         op = self._model.operator(name=name)
         # Set the time_scoping if necessary
         if time_scoping:
@@ -386,7 +392,7 @@ def _build_mesh_scoping(
         elements=None,
         named_selections=None,
         location=core.locations.nodal,
-    ) -> Union[core.mesh_scoping_factory.Scoping, None]:
+    ) -> Union[core.Scoping, core.outputs.Output, None]:
         if (nodes is not None or elements is not None) and named_selections is not None:
             raise ValueError(
                 "nodes/elements and named_selection are mutually exclusive"
@@ -399,15 +405,16 @@ def _build_mesh_scoping(
                 "selection and nodes/elements/named_selection are mutually exclusive"
             )
 
+        # Build the mesh_scoping
         mesh_scoping = None
         if selection:
-            mesh_scoping = selection.mesh_scoping
+            mesh_scoping = selection.mesh_scoping_output
 
         if named_selections:
             if type(named_selections) == str:
-                mesh_scoping = core.mesh_scoping_factory.named_selection_scoping(
-                    named_selections, server=self._model._server, model=self._model
-                )
+                mesh_scoping_op = self._model.operator("scoping_provider_by_ns")
+                mesh_scoping_op.connect(1, named_selections)
+                mesh_scoping = mesh_scoping_op.outputs.mesh_scoping
             elif type(named_selections) == list:
                 merge_scopings_op = self._model.operator(name="merge::scoping")
                 for pin, named_selection in enumerate(named_selections):
@@ -419,7 +426,7 @@ def _build_mesh_scoping(
                     merge_scopings_op.connect(
                         pin, mesh_scoping_on_ns_op.outputs.mesh_scoping
                     )
-                mesh_scoping = merge_scopings_op.eval()
+                mesh_scoping = merge_scopings_op.outputs.merged_scoping
 
         if nodes:
             mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
@@ -430,23 +437,13 @@ def _build_mesh_scoping(
             mesh_scoping = core.mesh_scoping_factory.elemental_scoping(
                 element_ids=elements, server=self._model._server
             )
-
-        if mesh_scoping is None:
-            return mesh_scoping
-
-        # Transpose location if necessary
-        if (
-            location == core.locations.nodal
-            and mesh_scoping.location != core.locations.nodal
-        ) or (
-            location == core.locations.elemental
-            and mesh_scoping.location != core.locations.elemental
-        ):
-            mesh_scoping = core.operators.scoping.transpose(
-                mesh_scoping=mesh_scoping,
-                meshed_region=self.mesh._meshed_region,
-                inclusive=1,
-            ).eval()
+            # Transpose location if necessary
+            if location == core.locations.nodal:
+                transpose_op = self._model.operator(name="transpose_scoping")
+                transpose_op.connect(0, mesh_scoping)
+                transpose_op.connect(1, self.mesh._meshed_region)
+                transpose_op.connect(2, 0)
+                mesh_scoping = transpose_op.outputs.mesh_scoping_as_scoping
 
         return mesh_scoping
 

From 3e9e062ba5edfd9cece79fed1d061f1b9b6f7c9b Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Tue, 14 Feb 2023 16:33:59 +0100
Subject: [PATCH 27/33] sub_steps is now declared using a tuple for load_steps.
 Priority of arguments is given in the docstrings.

---
 src/ansys/dpf/post/simulation.py              |  104 +-
 .../dpf/post/static_mechanical_simulation.py  |  835 ++++++-------
 .../post/transient_mechanical_simulation.py   | 1083 +++++++++--------
 tests/test_simulation.py                      |    6 +-
 4 files changed, 1083 insertions(+), 945 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 03377df31..a5f8aab66 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -2,7 +2,7 @@
 from abc import ABC, abstractmethod
 from enum import Enum
 import re
-from typing import List, Union
+from typing import List, Tuple, Union
 
 from ansys.dpf.core import DataSources, Model
 from ansys.dpf.core.plotter import DpfPlotter
@@ -388,11 +388,32 @@ def __init__(self, data_sources: core.DataSources, model: core.Model):
     def _build_mesh_scoping(
         self,
         selection=None,
-        nodes=None,
-        elements=None,
         named_selections=None,
+        elements=None,
+        nodes=None,
         location=core.locations.nodal,
     ) -> Union[core.Scoping, core.outputs.Output, None]:
+        """Generate a mesh_scoping from input arguments.
+
+        Only one input is used, by order of priority: selection, named_selection,
+        element_ids, node_ids.
+
+        Args:
+            selection:
+                Selection object to use.
+            named_selections:
+                Named selection to use.
+            elements:
+                Element IDs to use.
+            nodes:
+                Node IDs to use.
+            location:
+                Requested location for the returned Scoping.
+
+        Returns
+        -------
+            Returns a mesh Scoping or an operator Output giving a mesh Scoping.
+        """
         if (nodes is not None or elements is not None) and named_selections is not None:
             raise ValueError(
                 "nodes/elements and named_selection are mutually exclusive"
@@ -428,12 +449,7 @@ def _build_mesh_scoping(
                     )
                 mesh_scoping = merge_scopings_op.outputs.merged_scoping
 
-        if nodes:
-            mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
-                nodes, server=self._model._server
-            )
-
-        if elements:
+        elif elements:
             mesh_scoping = core.mesh_scoping_factory.elemental_scoping(
                 element_ids=elements, server=self._model._server
             )
@@ -445,17 +461,40 @@ def _build_mesh_scoping(
                 transpose_op.connect(2, 0)
                 mesh_scoping = transpose_op.outputs.mesh_scoping_as_scoping
 
+        elif nodes:
+            mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
+                nodes, server=self._model._server
+            )
+
         return mesh_scoping
 
     def _build_time_freq_scoping(
         self,
         selection: Union[Selection, None],
-        times: Union[float, List[float], None],
         set_ids: Union[int, List[int], None],
-        load_steps: Union[int, List[int], None],
-        sub_steps: Union[int, List[int], None],
+        times: Union[float, List[float], None],
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
     ) -> core.time_freq_scoping_factory.Scoping:
-        """Generate a time_freq_scoping from input arguments."""
+        """Generate a time_freq_scoping from input arguments.
+
+        Only one input is used, by order of priority: selection, set_ids, times, load_steps.
+
+        Args:
+            selection:
+                Selection to use (used in priority).
+            set_ids:
+                List of set IDs to use, if no selection is defined.
+            times:
+                Time values to use, if no selection nor set_ids are defined.
+            load_steps:
+                Load step IDs (and sub-step if tuple) to use, if no other is defined.
+
+        Returns
+        -------
+            A Scoping corresponding to the requested input, with time location.
+        """
         # create from selection in priority
         if selection:
             return selection.time_freq_selection._evaluate_on(simulation=self)
@@ -471,34 +510,25 @@ def _build_time_freq_scoping(
             if isinstance(times, float):
                 times = [times]
             raise NotImplementedError
-        # else from sub_steps and load_steps
-        if sub_steps:
-            if isinstance(sub_steps, int):
-                sub_steps = [sub_steps]
-            if isinstance(load_steps, int):
-                load_steps = [load_steps]
-            elif (
-                not load_steps
-                or (isinstance(load_steps, list) and len(load_steps)) != 1
-            ):
-                raise ValueError(
-                    "Argument sub_steps requires argument load_steps to have one value."
-                )
-            # Translate to cumulative indices (set IDs)
-            set_ids = []
-            for sub_step in sub_steps:
-                set_id = (
+        # else from load_steps
+        if load_steps:
+            # If load_steps and sub_steps
+            if len(load_steps) == 2:
+                # Translate to cumulative indices (set IDs)
+                set_ids = []
+                sub_steps = load_steps[1]
+                if not isinstance(sub_steps, list):
+                    sub_steps = [sub_steps]
+                set_id_0 = (
                     self._model.metadata.time_freq_support.get_cumulative_index(
-                        step=load_steps[0] - 1, substep=sub_step
+                        step=load_steps[0] - 1, substep=sub_steps[0]
                     )
                     + 2
                 )
-                set_ids.append(set_id)
-            return core.time_freq_scoping_factory.scoping_by_sets(
-                cumulative_sets=set_ids, server=self._model._server
-            )
-        # else load_steps only
-        if load_steps:
+                set_ids.extend([set_id_0 + i for i in range(len(sub_steps))])
+                return core.time_freq_scoping_factory.scoping_by_sets(
+                    cumulative_sets=set_ids, server=self._model._server
+                )
             if isinstance(load_steps, int):
                 load_steps = [load_steps]
             return core.time_freq_scoping_factory.scoping_by_load_steps(
diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index fdbfab320..e2f689cdf 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -1,5 +1,5 @@
 """Module containing the ``StaticMechanicalSimulation`` class."""
-from typing import List, Union
+from typing import List, Tuple, Union
 import warnings
 
 from ansys.dpf import core
@@ -21,8 +21,9 @@ def _get_result(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -30,8 +31,10 @@ def _get_result(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             base_name:
@@ -54,8 +57,6 @@ def _get_result(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -70,7 +71,7 @@ def _get_result(
         """
         # Build the targeted time scoping
         time_scoping = self._build_time_freq_scoping(
-            selection, times, set_ids, load_steps, sub_steps
+            selection, times, set_ids, load_steps
         )
 
         # Build the targeted mesh scoping
@@ -189,8 +190,9 @@ def displacement(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -198,8 +200,10 @@ def displacement(
         """Extract displacement results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -241,7 +245,6 @@ def displacement(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -253,8 +256,9 @@ def stress(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -262,8 +266,10 @@ def stress(
         """Extract elemental nodal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -279,8 +285,6 @@ def stress(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -302,7 +306,6 @@ def stress(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -314,8 +317,9 @@ def stress_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -323,8 +327,10 @@ def stress_elemental(
         """Extract elemental stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -340,8 +346,6 @@ def stress_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -363,7 +367,6 @@ def stress_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -375,8 +378,9 @@ def stress_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -384,8 +388,10 @@ def stress_nodal(
         """Extract nodal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -401,8 +407,6 @@ def stress_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -424,7 +428,6 @@ def stress_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -444,8 +447,10 @@ def stress_principal(
         """Extract elemental nodal principal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -460,8 +465,6 @@ def stress_principal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -481,7 +484,6 @@ def stress_principal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -501,8 +503,10 @@ def stress_principal_elemental(
         """Extract elemental principal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -517,8 +521,6 @@ def stress_principal_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -538,7 +540,6 @@ def stress_principal_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -559,8 +560,10 @@ def stress_principal_nodal(
         """Extract nodal principal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -575,8 +578,6 @@ def stress_principal_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -598,7 +599,6 @@ def stress_principal_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -617,8 +617,10 @@ def stress_eqv_von_mises(
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -631,8 +633,6 @@ def stress_eqv_von_mises(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -652,7 +652,6 @@ def stress_eqv_von_mises(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -671,8 +670,10 @@ def stress_eqv_von_mises_elemental(
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -685,8 +686,6 @@ def stress_eqv_von_mises_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -706,7 +705,6 @@ def stress_eqv_von_mises_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -726,8 +724,10 @@ def stress_eqv_von_mises_nodal(
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -740,8 +740,6 @@ def stress_eqv_von_mises_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -763,7 +761,6 @@ def stress_eqv_von_mises_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -775,8 +772,9 @@ def elastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -784,8 +782,10 @@ def elastic_strain(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -801,8 +801,6 @@ def elastic_strain(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -824,7 +822,6 @@ def elastic_strain(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -836,8 +833,9 @@ def elastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -845,8 +843,10 @@ def elastic_strain_nodal(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -862,8 +862,6 @@ def elastic_strain_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -885,7 +883,6 @@ def elastic_strain_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -897,8 +894,9 @@ def elastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -906,8 +904,10 @@ def elastic_strain_elemental(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -923,8 +923,6 @@ def elastic_strain_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -946,7 +944,6 @@ def elastic_strain_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -958,16 +955,19 @@ def elastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -982,8 +982,6 @@ def elastic_strain_principal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1003,7 +1001,6 @@ def elastic_strain_principal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1015,8 +1012,9 @@ def elastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1024,8 +1022,10 @@ def elastic_strain_principal_nodal(
         """Extract nodal principal elastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1040,8 +1040,6 @@ def elastic_strain_principal_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1063,7 +1061,6 @@ def elastic_strain_principal_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1075,16 +1072,19 @@ def elastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1099,8 +1099,6 @@ def elastic_strain_principal_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1120,7 +1118,6 @@ def elastic_strain_principal_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1131,16 +1128,19 @@ def plastic_state_variable(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1153,8 +1153,6 @@ def plastic_state_variable(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1174,7 +1172,6 @@ def plastic_state_variable(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1185,16 +1182,19 @@ def plastic_state_variable_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1207,8 +1207,6 @@ def plastic_state_variable_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1228,7 +1226,6 @@ def plastic_state_variable_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1239,8 +1236,9 @@ def plastic_state_variable_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1248,8 +1246,10 @@ def plastic_state_variable_nodal(
         """Extract nodal plastic state variable results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1262,8 +1262,6 @@ def plastic_state_variable_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1285,7 +1283,6 @@ def plastic_state_variable_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1297,8 +1294,9 @@ def plastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1306,8 +1304,10 @@ def plastic_strain(
         """Extract elemental nodal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1323,8 +1323,6 @@ def plastic_strain(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1346,7 +1344,6 @@ def plastic_strain(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1358,8 +1355,9 @@ def plastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1367,8 +1365,10 @@ def plastic_strain_nodal(
         """Extract nodal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1384,8 +1384,6 @@ def plastic_strain_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1407,7 +1405,6 @@ def plastic_strain_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1419,8 +1416,9 @@ def plastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1428,8 +1426,10 @@ def plastic_strain_elemental(
         """Extract elemental plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1445,8 +1445,6 @@ def plastic_strain_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1468,7 +1466,6 @@ def plastic_strain_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1480,16 +1477,19 @@ def plastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1504,8 +1504,6 @@ def plastic_strain_principal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1525,7 +1523,6 @@ def plastic_strain_principal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1537,8 +1534,9 @@ def plastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1546,8 +1544,10 @@ def plastic_strain_principal_nodal(
         """Extract nodal principal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1562,8 +1562,6 @@ def plastic_strain_principal_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1585,7 +1583,6 @@ def plastic_strain_principal_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1597,16 +1594,19 @@ def plastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1621,8 +1621,6 @@ def plastic_strain_principal_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1642,7 +1640,6 @@ def plastic_strain_principal_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1653,16 +1650,19 @@ def plastic_strain_eqv(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1675,8 +1675,6 @@ def plastic_strain_eqv(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1696,7 +1694,6 @@ def plastic_strain_eqv(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1707,8 +1704,9 @@ def plastic_strain_eqv_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1716,8 +1714,10 @@ def plastic_strain_eqv_nodal(
         """Extract nodal equivalent plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1730,8 +1730,6 @@ def plastic_strain_eqv_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1753,7 +1751,6 @@ def plastic_strain_eqv_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1764,16 +1761,19 @@ def plastic_strain_eqv_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1786,8 +1786,6 @@ def plastic_strain_eqv_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1807,7 +1805,6 @@ def plastic_strain_eqv_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1819,8 +1816,9 @@ def creep_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1828,8 +1826,10 @@ def creep_strain(
         """Extract elemental nodal creep strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1845,8 +1845,6 @@ def creep_strain(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1868,7 +1866,6 @@ def creep_strain(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1880,8 +1877,9 @@ def creep_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1889,8 +1887,10 @@ def creep_strain_nodal(
         """Extract nodal creep strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1906,8 +1906,6 @@ def creep_strain_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1929,7 +1927,6 @@ def creep_strain_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1941,8 +1938,9 @@ def creep_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1950,8 +1948,10 @@ def creep_strain_elemental(
         """Extract elemental creep strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1967,8 +1967,6 @@ def creep_strain_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1990,7 +1988,6 @@ def creep_strain_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2002,16 +1999,19 @@ def creep_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal creep strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -2026,8 +2026,6 @@ def creep_strain_principal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2047,7 +2045,6 @@ def creep_strain_principal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2059,8 +2056,9 @@ def creep_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2068,8 +2066,10 @@ def creep_strain_principal_nodal(
         """Extract nodal principal creep strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -2084,8 +2084,6 @@ def creep_strain_principal_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2107,7 +2105,6 @@ def creep_strain_principal_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2119,16 +2116,19 @@ def creep_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal creep strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -2143,8 +2143,6 @@ def creep_strain_principal_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2164,7 +2162,6 @@ def creep_strain_principal_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2175,16 +2172,19 @@ def creep_strain_eqv(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent creep strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2197,8 +2197,6 @@ def creep_strain_eqv(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2218,7 +2216,6 @@ def creep_strain_eqv(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2229,8 +2226,9 @@ def creep_strain_equivalent_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2238,8 +2236,10 @@ def creep_strain_equivalent_nodal(
         """Extract nodal equivalent creep strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2252,8 +2252,6 @@ def creep_strain_equivalent_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2275,7 +2273,6 @@ def creep_strain_equivalent_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2286,16 +2283,19 @@ def creep_strain_equivalent_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent creep strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2308,8 +2308,6 @@ def creep_strain_equivalent_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2329,7 +2327,6 @@ def creep_strain_equivalent_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2342,8 +2339,9 @@ def reaction_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2351,8 +2349,10 @@ def reaction_force(
         """Extract reaction force results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -2370,8 +2370,6 @@ def reaction_force(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2394,7 +2392,6 @@ def reaction_force(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2405,16 +2402,19 @@ def elemental_volume(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2427,8 +2427,6 @@ def elemental_volume(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2448,7 +2446,6 @@ def elemental_volume(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2459,16 +2456,19 @@ def elemental_mass(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2481,8 +2481,6 @@ def elemental_mass(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2502,7 +2500,6 @@ def elemental_mass(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2513,16 +2510,19 @@ def elemental_heat_generation(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2535,8 +2535,6 @@ def elemental_heat_generation(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2556,7 +2554,6 @@ def elemental_heat_generation(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2567,16 +2564,19 @@ def element_centroids(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2589,8 +2589,6 @@ def element_centroids(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2610,7 +2608,6 @@ def element_centroids(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2621,16 +2618,19 @@ def thickness(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2643,8 +2643,6 @@ def thickness(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2664,7 +2662,6 @@ def thickness(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2675,16 +2672,19 @@ def element_orientations(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2697,8 +2697,6 @@ def element_orientations(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2718,7 +2716,6 @@ def element_orientations(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2729,16 +2726,19 @@ def element_orientations_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2751,8 +2751,6 @@ def element_orientations_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2772,7 +2770,6 @@ def element_orientations_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2783,8 +2780,9 @@ def element_orientations_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2792,8 +2790,10 @@ def element_orientations_nodal(
         """Extract nodal element orientations results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2806,8 +2806,6 @@ def element_orientations_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2829,7 +2827,6 @@ def element_orientations_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2840,8 +2837,9 @@ def stiffness_matrix_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2849,8 +2847,10 @@ def stiffness_matrix_energy(
         """Extract stiffness matrix energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2863,8 +2863,6 @@ def stiffness_matrix_energy(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2886,7 +2884,6 @@ def stiffness_matrix_energy(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2897,8 +2894,9 @@ def artificial_hourglass_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2906,8 +2904,10 @@ def artificial_hourglass_energy(
         """Extract artificial hourglass energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2920,8 +2920,6 @@ def artificial_hourglass_energy(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2943,7 +2941,6 @@ def artificial_hourglass_energy(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2954,8 +2951,9 @@ def thermal_dissipation_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2963,8 +2961,10 @@ def thermal_dissipation_energy(
         """Extract thermal dissipation energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2977,8 +2977,6 @@ def thermal_dissipation_energy(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3000,7 +2998,6 @@ def thermal_dissipation_energy(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3011,8 +3008,9 @@ def kinetic_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3020,8 +3018,10 @@ def kinetic_energy(
         """Extract kinetic energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3034,8 +3034,6 @@ def kinetic_energy(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3057,7 +3055,6 @@ def kinetic_energy(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3068,8 +3065,9 @@ def hydrostatic_pressure(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3077,8 +3075,10 @@ def hydrostatic_pressure(
         """Extract hydrostatic pressure element nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3091,8 +3091,6 @@ def hydrostatic_pressure(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3114,7 +3112,6 @@ def hydrostatic_pressure(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3125,8 +3122,9 @@ def hydrostatic_pressure_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3134,8 +3132,10 @@ def hydrostatic_pressure_nodal(
         """Extract hydrostatic pressure nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3148,8 +3148,6 @@ def hydrostatic_pressure_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3171,7 +3169,6 @@ def hydrostatic_pressure_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3182,8 +3179,9 @@ def hydrostatic_pressure_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3191,8 +3189,10 @@ def hydrostatic_pressure_elemental(
         """Extract hydrostatic pressure elemental results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3205,8 +3205,6 @@ def hydrostatic_pressure_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3228,7 +3226,6 @@ def hydrostatic_pressure_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3239,8 +3236,9 @@ def structural_temperature(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3248,8 +3246,10 @@ def structural_temperature(
         """Extract structural temperature element nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3262,8 +3262,6 @@ def structural_temperature(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3285,7 +3283,6 @@ def structural_temperature(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3296,8 +3293,9 @@ def structural_temperature_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3305,8 +3303,10 @@ def structural_temperature_nodal(
         """Extract structural temperature nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3319,8 +3319,6 @@ def structural_temperature_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3342,7 +3340,6 @@ def structural_temperature_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3353,8 +3350,9 @@ def structural_temperature_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3362,8 +3360,10 @@ def structural_temperature_elemental(
         """Extract structural temperature elemental results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3376,8 +3376,6 @@ def structural_temperature_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3399,7 +3397,6 @@ def structural_temperature_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3412,8 +3409,9 @@ def element_nodal_forces(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3421,8 +3419,10 @@ def element_nodal_forces(
         """Extract element nodal forces results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3440,8 +3440,6 @@ def element_nodal_forces(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3464,7 +3462,6 @@ def element_nodal_forces(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3477,8 +3474,9 @@ def element_nodal_forces_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3486,8 +3484,10 @@ def element_nodal_forces_nodal(
         """Extract element nodal forces nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3505,8 +3505,6 @@ def element_nodal_forces_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3529,7 +3527,6 @@ def element_nodal_forces_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3542,16 +3539,19 @@ def element_nodal_forces_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3569,8 +3569,6 @@ def element_nodal_forces_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -3591,7 +3589,6 @@ def element_nodal_forces_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3604,8 +3601,9 @@ def nodal_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3613,8 +3611,10 @@ def nodal_force(
         """Extract nodal force results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3656,7 +3656,6 @@ def nodal_force(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3669,8 +3668,9 @@ def nodal_moment(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3678,8 +3678,10 @@ def nodal_moment(
         """Extract nodal moment results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3721,7 +3723,6 @@ def nodal_moment(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index dbabb6fe3..cda4da1f4 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -1,5 +1,5 @@
 """Module containing the ``TransientMechanicalSimulation`` class."""
-from typing import List, Union
+from typing import List, Tuple, Union
 import warnings
 
 from ansys.dpf import core
@@ -21,8 +21,9 @@ def _get_result(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -30,12 +31,16 @@ def _get_result(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             base_name:
@@ -59,8 +64,6 @@ def _get_result(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -75,7 +78,7 @@ def _get_result(
         """
         # Build the targeted time scoping
         time_scoping = self._build_time_freq_scoping(
-            selection, times, set_ids, load_steps, sub_steps
+            selection, times, set_ids, load_steps
         )
 
         # Build the targeted mesh scoping
@@ -194,8 +197,9 @@ def displacement(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -203,12 +207,16 @@ def displacement(
         """Extract displacement results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -227,8 +235,6 @@ def displacement(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -251,7 +257,6 @@ def displacement(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -264,8 +269,9 @@ def velocity(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -273,12 +279,16 @@ def velocity(
         """Extract velocity results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -297,8 +307,6 @@ def velocity(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -321,7 +329,6 @@ def velocity(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -334,8 +341,9 @@ def acceleration(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -343,12 +351,16 @@ def acceleration(
         """Extract acceleration results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -367,8 +379,6 @@ def acceleration(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -391,7 +401,6 @@ def acceleration(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -403,8 +412,9 @@ def stress(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -412,12 +422,16 @@ def stress(
         """Extract elemental nodal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -434,8 +448,6 @@ def stress(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -457,7 +469,6 @@ def stress(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -469,8 +480,9 @@ def stress_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -478,12 +490,16 @@ def stress_elemental(
         """Extract elemental stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -500,8 +516,6 @@ def stress_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -523,7 +537,6 @@ def stress_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -535,8 +548,9 @@ def stress_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -544,12 +558,16 @@ def stress_nodal(
         """Extract nodal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -566,8 +584,6 @@ def stress_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -589,7 +605,6 @@ def stress_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -601,20 +616,25 @@ def stress_principal(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -630,8 +650,6 @@ def stress_principal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -651,7 +669,6 @@ def stress_principal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -663,20 +680,25 @@ def stress_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -692,8 +714,6 @@ def stress_principal_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -713,7 +733,6 @@ def stress_principal_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -725,8 +744,9 @@ def stress_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -734,12 +754,16 @@ def stress_principal_nodal(
         """Extract nodal principal stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -755,8 +779,6 @@ def stress_principal_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -778,7 +800,6 @@ def stress_principal_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -789,20 +810,25 @@ def stress_eqv_von_mises(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -816,8 +842,6 @@ def stress_eqv_von_mises(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -837,7 +861,6 @@ def stress_eqv_von_mises(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -848,20 +871,25 @@ def stress_eqv_von_mises_elemental(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -875,8 +903,6 @@ def stress_eqv_von_mises_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -896,7 +922,6 @@ def stress_eqv_von_mises_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -907,8 +932,9 @@ def stress_eqv_von_mises_nodal(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -916,12 +942,16 @@ def stress_eqv_von_mises_nodal(
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -935,8 +965,6 @@ def stress_eqv_von_mises_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -958,7 +986,6 @@ def stress_eqv_von_mises_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -970,8 +997,9 @@ def elastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -979,12 +1007,16 @@ def elastic_strain(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1001,8 +1033,6 @@ def elastic_strain(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1024,7 +1054,6 @@ def elastic_strain(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1036,8 +1065,9 @@ def elastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1045,12 +1075,16 @@ def elastic_strain_nodal(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1067,8 +1101,6 @@ def elastic_strain_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1090,7 +1122,6 @@ def elastic_strain_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1102,8 +1133,9 @@ def elastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1111,12 +1143,16 @@ def elastic_strain_elemental(
         """Extract stress results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1133,8 +1169,6 @@ def elastic_strain_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1156,7 +1190,6 @@ def elastic_strain_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1168,20 +1201,25 @@ def elastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1197,8 +1235,6 @@ def elastic_strain_principal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1218,7 +1254,6 @@ def elastic_strain_principal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1230,8 +1265,9 @@ def elastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1239,12 +1275,16 @@ def elastic_strain_principal_nodal(
         """Extract nodal principal elastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1260,8 +1300,6 @@ def elastic_strain_principal_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1283,7 +1321,6 @@ def elastic_strain_principal_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1295,20 +1332,25 @@ def elastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1324,8 +1366,6 @@ def elastic_strain_principal_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1345,7 +1385,6 @@ def elastic_strain_principal_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1356,20 +1395,25 @@ def plastic_state_variable(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1383,8 +1427,6 @@ def plastic_state_variable(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1404,7 +1446,6 @@ def plastic_state_variable(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1415,20 +1456,25 @@ def plastic_state_variable_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1442,8 +1488,6 @@ def plastic_state_variable_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1463,7 +1507,6 @@ def plastic_state_variable_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1474,8 +1517,9 @@ def plastic_state_variable_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1483,12 +1527,16 @@ def plastic_state_variable_nodal(
         """Extract nodal plastic state variable results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1502,8 +1550,6 @@ def plastic_state_variable_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1525,7 +1571,6 @@ def plastic_state_variable_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1537,8 +1582,9 @@ def plastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1546,12 +1592,16 @@ def plastic_strain(
         """Extract elemental nodal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1568,8 +1618,6 @@ def plastic_strain(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1591,7 +1639,6 @@ def plastic_strain(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1603,8 +1650,9 @@ def plastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1612,12 +1660,16 @@ def plastic_strain_nodal(
         """Extract nodal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1634,8 +1686,6 @@ def plastic_strain_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1657,7 +1707,6 @@ def plastic_strain_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1669,8 +1718,9 @@ def plastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1678,12 +1728,16 @@ def plastic_strain_elemental(
         """Extract elemental plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1700,8 +1754,6 @@ def plastic_strain_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1723,7 +1775,6 @@ def plastic_strain_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1735,20 +1786,25 @@ def plastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1764,8 +1820,6 @@ def plastic_strain_principal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1785,7 +1839,6 @@ def plastic_strain_principal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1797,8 +1850,9 @@ def plastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1806,12 +1860,16 @@ def plastic_strain_principal_nodal(
         """Extract nodal principal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1827,8 +1885,6 @@ def plastic_strain_principal_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1850,7 +1906,6 @@ def plastic_strain_principal_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1862,20 +1917,25 @@ def plastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -1891,8 +1951,6 @@ def plastic_strain_principal_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1912,7 +1970,6 @@ def plastic_strain_principal_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1923,20 +1980,25 @@ def plastic_strain_eqv(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -1950,8 +2012,6 @@ def plastic_strain_eqv(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1971,7 +2031,6 @@ def plastic_strain_eqv(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -1982,8 +2041,9 @@ def plastic_strain_eqv_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -1991,12 +2051,16 @@ def plastic_strain_eqv_nodal(
         """Extract nodal equivalent plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2010,8 +2074,6 @@ def plastic_strain_eqv_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2033,7 +2095,6 @@ def plastic_strain_eqv_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2044,20 +2105,25 @@ def plastic_strain_eqv_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2071,8 +2137,6 @@ def plastic_strain_eqv_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2092,7 +2156,6 @@ def plastic_strain_eqv_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2105,8 +2168,9 @@ def reaction_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2114,12 +2178,16 @@ def reaction_force(
         """Extract reaction force results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -2138,8 +2206,6 @@ def reaction_force(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2162,7 +2228,6 @@ def reaction_force(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2173,20 +2238,25 @@ def elemental_volume(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2200,8 +2270,6 @@ def elemental_volume(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2221,7 +2289,6 @@ def elemental_volume(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2232,20 +2299,25 @@ def elemental_mass(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2259,8 +2331,6 @@ def elemental_mass(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2280,7 +2350,6 @@ def elemental_mass(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2291,20 +2360,25 @@ def elemental_heat_generation(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2318,8 +2392,6 @@ def elemental_heat_generation(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2339,7 +2411,6 @@ def elemental_heat_generation(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2350,20 +2421,25 @@ def element_centroids(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2377,8 +2453,6 @@ def element_centroids(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2398,7 +2472,6 @@ def element_centroids(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2409,20 +2482,25 @@ def thickness(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2436,8 +2514,6 @@ def thickness(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2457,7 +2533,6 @@ def thickness(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2468,20 +2543,25 @@ def element_orientations(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2495,8 +2575,6 @@ def element_orientations(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2516,7 +2594,6 @@ def element_orientations(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2527,20 +2604,25 @@ def element_orientations_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2554,8 +2636,6 @@ def element_orientations_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2575,7 +2655,6 @@ def element_orientations_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2586,8 +2665,9 @@ def element_orientations_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2595,12 +2675,16 @@ def element_orientations_nodal(
         """Extract nodal element orientations results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2614,8 +2698,6 @@ def element_orientations_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2637,7 +2719,6 @@ def element_orientations_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2648,8 +2729,9 @@ def artificial_hourglass_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2657,12 +2739,16 @@ def artificial_hourglass_energy(
         """Extract artificial hourglass energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2676,8 +2762,6 @@ def artificial_hourglass_energy(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2699,7 +2783,6 @@ def artificial_hourglass_energy(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2710,8 +2793,9 @@ def thermal_dissipation_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2719,12 +2803,16 @@ def thermal_dissipation_energy(
         """Extract thermal dissipation energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2738,8 +2826,6 @@ def thermal_dissipation_energy(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2761,7 +2847,6 @@ def thermal_dissipation_energy(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2772,8 +2857,9 @@ def kinetic_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2781,12 +2867,16 @@ def kinetic_energy(
         """Extract kinetic energy results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2800,8 +2890,6 @@ def kinetic_energy(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2823,7 +2911,6 @@ def kinetic_energy(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2834,8 +2921,9 @@ def hydrostatic_pressure(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2843,12 +2931,16 @@ def hydrostatic_pressure(
         """Extract hydrostatic pressure element nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2862,8 +2954,6 @@ def hydrostatic_pressure(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2885,7 +2975,6 @@ def hydrostatic_pressure(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2896,8 +2985,9 @@ def hydrostatic_pressure_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2905,12 +2995,16 @@ def hydrostatic_pressure_nodal(
         """Extract hydrostatic pressure nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2924,8 +3018,6 @@ def hydrostatic_pressure_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2947,7 +3039,6 @@ def hydrostatic_pressure_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -2958,8 +3049,9 @@ def hydrostatic_pressure_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -2967,12 +3059,16 @@ def hydrostatic_pressure_elemental(
         """Extract hydrostatic pressure elemental results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -2986,8 +3082,6 @@ def hydrostatic_pressure_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -3009,7 +3103,6 @@ def hydrostatic_pressure_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3020,8 +3113,9 @@ def structural_temperature(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3029,12 +3123,16 @@ def structural_temperature(
         """Extract structural temperature element nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3048,8 +3146,6 @@ def structural_temperature(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -3071,7 +3167,6 @@ def structural_temperature(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3082,8 +3177,9 @@ def structural_temperature_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3091,12 +3187,16 @@ def structural_temperature_nodal(
         """Extract structural temperature nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3110,8 +3210,6 @@ def structural_temperature_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -3133,7 +3231,6 @@ def structural_temperature_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3144,8 +3241,9 @@ def structural_temperature_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3153,12 +3251,16 @@ def structural_temperature_elemental(
         """Extract structural temperature elemental results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             selection:
@@ -3172,8 +3274,6 @@ def structural_temperature_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -3195,7 +3295,6 @@ def structural_temperature_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3208,8 +3307,9 @@ def element_nodal_forces(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3217,12 +3317,16 @@ def element_nodal_forces(
         """Extract element nodal forces results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3241,8 +3345,6 @@ def element_nodal_forces(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -3265,7 +3367,6 @@ def element_nodal_forces(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3278,8 +3379,9 @@ def element_nodal_forces_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3287,12 +3389,16 @@ def element_nodal_forces_nodal(
         """Extract element nodal forces nodal results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3311,8 +3417,6 @@ def element_nodal_forces_nodal(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -3335,7 +3439,6 @@ def element_nodal_forces_nodal(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3348,20 +3451,25 @@ def element_nodal_forces_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3380,8 +3488,6 @@ def element_nodal_forces_elemental(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -3402,7 +3508,6 @@ def element_nodal_forces_elemental(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3415,8 +3520,9 @@ def nodal_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3424,12 +3530,16 @@ def nodal_force(
         """Extract nodal force results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3448,8 +3558,6 @@ def nodal_force(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3472,7 +3580,6 @@ def nodal_force(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
@@ -3485,8 +3592,9 @@ def nodal_moment(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
-        load_steps: Union[int, List[int], None] = None,
-        sub_steps: Union[int, List[int], None] = None,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
@@ -3494,12 +3602,16 @@ def nodal_moment(
         """Extract nodal moment results from the simulation.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), the time selection argument
-        taken into account is: `set_ids`, `times`, `sub_steps`, and `load_steps`.
+        Then, in order of priority (and from fine to coarse), only one time selection argument
+        is taken into account: `set_ids`, then `times`, and then `load_steps`.
+        In the same manner, only one mesh entity argument is taken into account:
+        `named_selections`, then `element_ids`, and then `node_ids`.
 
         Args:
             components:
@@ -3518,8 +3630,6 @@ def nodal_moment(
                 A set is defined as a unique combination of {time, load step, sub-step}.
             load_steps:
                 List of load steps to get results for.
-            sub_steps:
-                List of sub-steps to get results for. Requires load_steps to be defined.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3542,7 +3652,6 @@ def nodal_moment(
             times=times,
             set_ids=set_ids,
             load_steps=load_steps,
-            sub_steps=sub_steps,
             node_ids=node_ids,
             element_ids=element_ids,
             named_selections=named_selections,
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index 63c446172..fc6ee9876 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -95,8 +95,7 @@ def test_displacement(self, static_simulation):
         displacement_y = static_simulation.displacement(
             components=["2"],
             named_selections=static_simulation.named_selections[0],
-            load_steps=[1],
-            sub_steps=[1],
+            load_steps=(1, 1),
         )
         assert len(displacement_y._fc) == 1
         assert displacement_y._fc.get_time_scoping().ids == [1]
@@ -116,8 +115,7 @@ def test_displacement(self, static_simulation):
         displacement_z = static_simulation.displacement(
             components="Z",
             named_selections=static_simulation.named_selections[0],
-            load_steps=1,
-            sub_steps=1,
+            load_steps=(1, 1),
         )
         assert len(displacement_z._fc) == 1
         assert displacement_z._fc.get_time_scoping().ids == [1]

From 6c8762dc862cf92d5b678bc1726128d18a5bcde5 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Tue, 14 Feb 2023 16:42:17 +0100
Subject: [PATCH 28/33] sub_steps is now declared using a tuple for load_steps.
 Priority of arguments is given in the docstrings.

---
 src/ansys/dpf/post/static_mechanical_simulation.py  | 13 ++++++++-----
 .../dpf/post/transient_mechanical_simulation.py     | 13 ++++++++-----
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index e2f689cdf..f110d573c 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -71,15 +71,18 @@ def _get_result(
         """
         # Build the targeted time scoping
         time_scoping = self._build_time_freq_scoping(
-            selection, times, set_ids, load_steps
+            selection=selection,
+            set_ids=set_ids,
+            times=times,
+            load_steps=load_steps,
         )
 
         # Build the targeted mesh scoping
         mesh_scoping = self._build_mesh_scoping(
-            selection,
-            node_ids,
-            element_ids,
-            named_selections,
+            selection=selection,
+            nodes=node_ids,
+            elements=element_ids,
+            named_selections=named_selections,
             location=location,
         )
 
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index cda4da1f4..66ada8fe2 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -78,15 +78,18 @@ def _get_result(
         """
         # Build the targeted time scoping
         time_scoping = self._build_time_freq_scoping(
-            selection, times, set_ids, load_steps
+            selection=selection,
+            set_ids=set_ids,
+            times=times,
+            load_steps=load_steps,
         )
 
         # Build the targeted mesh scoping
         mesh_scoping = self._build_mesh_scoping(
-            selection,
-            node_ids,
-            element_ids,
-            named_selections,
+            selection=selection,
+            nodes=node_ids,
+            elements=element_ids,
+            named_selections=named_selections,
             location=location,
         )
 

From 98a032bdf724f37f272db2136e9636745233ddfd Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Tue, 14 Feb 2023 17:15:01 +0100
Subject: [PATCH 29/33] Force mutual exclusivity of timefreq arguments, as well
 as of mesh scoping arguments

---
 src/ansys/dpf/post/simulation.py              |  45 +-
 .../dpf/post/static_mechanical_simulation.py  | 500 +++++-------
 .../post/transient_mechanical_simulation.py   | 760 ++++--------------
 tests/test_simulation.py                      |   6 +
 4 files changed, 386 insertions(+), 925 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index a5f8aab66..46c5a597a 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -389,8 +389,8 @@ def _build_mesh_scoping(
         self,
         selection=None,
         named_selections=None,
-        elements=None,
-        nodes=None,
+        element_ids=None,
+        node_ids=None,
         location=core.locations.nodal,
     ) -> Union[core.Scoping, core.outputs.Output, None]:
         """Generate a mesh_scoping from input arguments.
@@ -403,9 +403,9 @@ def _build_mesh_scoping(
                 Selection object to use.
             named_selections:
                 Named selection to use.
-            elements:
+            element_ids:
                 Element IDs to use.
-            nodes:
+            node_ids:
                 Node IDs to use.
             location:
                 Requested location for the returned Scoping.
@@ -414,16 +414,16 @@ def _build_mesh_scoping(
         -------
             Returns a mesh Scoping or an operator Output giving a mesh Scoping.
         """
-        if (nodes is not None or elements is not None) and named_selections is not None:
-            raise ValueError(
-                "nodes/elements and named_selection are mutually exclusive"
-            )
-
-        if selection is not None and (
-            nodes is not None or named_selections is not None or elements is not None
-        ):
+        tot = (
+            (node_ids is not None)
+            + (element_ids is not None)
+            + (named_selections is not None)
+            + (selection is not None)
+        )
+        if tot > 1:
             raise ValueError(
-                "selection and nodes/elements/named_selection are mutually exclusive"
+                "Arguments selection, named_selections, element_ids, "
+                "and node_ids are mutually exclusive"
             )
 
         # Build the mesh_scoping
@@ -449,9 +449,9 @@ def _build_mesh_scoping(
                     )
                 mesh_scoping = merge_scopings_op.outputs.merged_scoping
 
-        elif elements:
+        elif element_ids:
             mesh_scoping = core.mesh_scoping_factory.elemental_scoping(
-                element_ids=elements, server=self._model._server
+                element_ids=element_ids, server=self._model._server
             )
             # Transpose location if necessary
             if location == core.locations.nodal:
@@ -461,9 +461,9 @@ def _build_mesh_scoping(
                 transpose_op.connect(2, 0)
                 mesh_scoping = transpose_op.outputs.mesh_scoping_as_scoping
 
-        elif nodes:
+        elif node_ids:
             mesh_scoping = core.mesh_scoping_factory.nodal_scoping(
-                nodes, server=self._model._server
+                node_ids, server=self._model._server
             )
 
         return mesh_scoping
@@ -495,6 +495,17 @@ def _build_time_freq_scoping(
         -------
             A Scoping corresponding to the requested input, with time location.
         """
+        tot = (
+            (set_ids is not None)
+            + (times is not None)
+            + (load_steps is not None)
+            + (selection is not None)
+        )
+        if tot > 1:
+            raise ValueError(
+                "Arguments selection, named_selections, element_ids, "
+                "and node_ids are mutually exclusive"
+            )
         # create from selection in priority
         if selection:
             return selection.time_freq_selection._evaluate_on(simulation=self)
diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index f110d573c..ab3fa22f1 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -30,11 +30,9 @@ def _get_result(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             base_name:
@@ -80,8 +78,8 @@ def _get_result(
         # Build the targeted mesh scoping
         mesh_scoping = self._build_mesh_scoping(
             selection=selection,
-            nodes=node_ids,
-            elements=element_ids,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selections=named_selections,
             location=location,
         )
@@ -202,11 +200,9 @@ def displacement(
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -268,11 +264,9 @@ def stress(
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -329,11 +323,9 @@ def stress_elemental(
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -390,11 +382,9 @@ def stress_nodal(
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -449,11 +439,9 @@ def stress_principal(
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -505,11 +493,9 @@ def stress_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -562,11 +548,9 @@ def stress_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -619,11 +603,9 @@ def stress_eqv_von_mises(
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -672,11 +654,9 @@ def stress_eqv_von_mises_elemental(
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -726,11 +706,9 @@ def stress_eqv_von_mises_nodal(
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -784,11 +762,9 @@ def elastic_strain(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -845,11 +821,9 @@ def elastic_strain_nodal(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -906,11 +880,9 @@ def elastic_strain_elemental(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -966,11 +938,9 @@ def elastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1024,11 +994,9 @@ def elastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1083,11 +1051,9 @@ def elastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1139,11 +1105,9 @@ def plastic_state_variable(
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1193,11 +1157,9 @@ def plastic_state_variable_elemental(
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1248,11 +1210,9 @@ def plastic_state_variable_nodal(
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1306,11 +1266,9 @@ def plastic_strain(
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1367,11 +1325,9 @@ def plastic_strain_nodal(
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1428,11 +1384,9 @@ def plastic_strain_elemental(
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1488,11 +1442,9 @@ def plastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1546,11 +1498,9 @@ def plastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1605,11 +1555,9 @@ def plastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1661,11 +1609,9 @@ def plastic_strain_eqv(
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1716,11 +1662,9 @@ def plastic_strain_eqv_nodal(
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1772,11 +1716,9 @@ def plastic_strain_eqv_elemental(
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1828,11 +1770,9 @@ def creep_strain(
     ) -> DataObject:
         """Extract elemental nodal creep strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1889,11 +1829,9 @@ def creep_strain_nodal(
     ) -> DataObject:
         """Extract nodal creep strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1950,11 +1888,9 @@ def creep_strain_elemental(
     ) -> DataObject:
         """Extract elemental creep strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -2010,11 +1946,9 @@ def creep_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal creep strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -2068,11 +2002,9 @@ def creep_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal creep strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -2127,11 +2059,9 @@ def creep_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal creep strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -2183,11 +2113,9 @@ def creep_strain_eqv(
     ) -> DataObject:
         """Extract elemental nodal equivalent creep strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2238,11 +2166,9 @@ def creep_strain_equivalent_nodal(
     ) -> DataObject:
         """Extract nodal equivalent creep strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2294,11 +2220,9 @@ def creep_strain_equivalent_elemental(
     ) -> DataObject:
         """Extract elemental equivalent creep strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2351,11 +2275,9 @@ def reaction_force(
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -2413,11 +2335,9 @@ def elemental_volume(
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2467,11 +2387,9 @@ def elemental_mass(
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2521,11 +2439,9 @@ def elemental_heat_generation(
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2575,11 +2491,9 @@ def element_centroids(
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2629,11 +2543,9 @@ def thickness(
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2683,11 +2595,9 @@ def element_orientations(
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2737,11 +2647,9 @@ def element_orientations_elemental(
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2792,11 +2700,9 @@ def element_orientations_nodal(
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2849,11 +2755,9 @@ def stiffness_matrix_energy(
     ) -> DataObject:
         """Extract stiffness matrix energy results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2906,11 +2810,9 @@ def artificial_hourglass_energy(
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2963,11 +2865,9 @@ def thermal_dissipation_energy(
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3020,11 +2920,9 @@ def kinetic_energy(
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3077,11 +2975,9 @@ def hydrostatic_pressure(
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3134,11 +3030,9 @@ def hydrostatic_pressure_nodal(
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3191,11 +3085,9 @@ def hydrostatic_pressure_elemental(
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3248,11 +3140,9 @@ def structural_temperature(
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3305,11 +3195,9 @@ def structural_temperature_nodal(
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3362,11 +3250,9 @@ def structural_temperature_elemental(
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3421,11 +3307,9 @@ def element_nodal_forces(
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -3486,11 +3370,9 @@ def element_nodal_forces_nodal(
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -3550,11 +3432,9 @@ def element_nodal_forces_elemental(
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -3613,11 +3493,9 @@ def nodal_force(
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -3680,11 +3558,9 @@ def nodal_moment(
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index 66ada8fe2..bccb94a03 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -30,17 +30,9 @@ def _get_result(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             base_name:
@@ -87,8 +79,8 @@ def _get_result(
         # Build the targeted mesh scoping
         mesh_scoping = self._build_mesh_scoping(
             selection=selection,
-            nodes=node_ids,
-            elements=element_ids,
+            node_ids=node_ids,
+            element_ids=element_ids,
             named_selections=named_selections,
             location=location,
         )
@@ -209,17 +201,9 @@ def displacement(
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -281,17 +265,9 @@ def velocity(
     ) -> DataObject:
         """Extract velocity results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -353,17 +329,9 @@ def acceleration(
     ) -> DataObject:
         """Extract acceleration results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -424,17 +392,9 @@ def stress(
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -492,17 +452,9 @@ def stress_elemental(
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -560,17 +512,9 @@ def stress_nodal(
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -627,17 +571,9 @@ def stress_principal(
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -691,17 +627,9 @@ def stress_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -756,17 +684,9 @@ def stress_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -821,17 +741,9 @@ def stress_eqv_von_mises(
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -882,17 +794,9 @@ def stress_eqv_von_mises_elemental(
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -944,17 +848,9 @@ def stress_eqv_von_mises_nodal(
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1009,17 +905,9 @@ def elastic_strain(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1077,17 +965,9 @@ def elastic_strain_nodal(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1145,17 +1025,9 @@ def elastic_strain_elemental(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1212,17 +1084,9 @@ def elastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1277,17 +1141,9 @@ def elastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1343,17 +1199,9 @@ def elastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1406,17 +1254,9 @@ def plastic_state_variable(
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1467,17 +1307,9 @@ def plastic_state_variable_elemental(
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1529,17 +1361,9 @@ def plastic_state_variable_nodal(
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -1594,17 +1418,9 @@ def plastic_strain(
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1662,17 +1478,9 @@ def plastic_strain_nodal(
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1730,17 +1538,9 @@ def plastic_strain_elemental(
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1797,17 +1597,9 @@ def plastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1862,17 +1654,9 @@ def plastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1928,17 +1712,9 @@ def plastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -1991,17 +1767,9 @@ def plastic_strain_eqv(
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2053,17 +1821,9 @@ def plastic_strain_eqv_nodal(
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2116,17 +1876,9 @@ def plastic_strain_eqv_elemental(
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2180,17 +1932,9 @@ def reaction_force(
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -2249,17 +1993,9 @@ def elemental_volume(
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2310,17 +2046,9 @@ def elemental_mass(
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2371,17 +2099,9 @@ def elemental_heat_generation(
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2432,17 +2152,9 @@ def element_centroids(
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2493,17 +2205,9 @@ def thickness(
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2554,17 +2258,9 @@ def element_orientations(
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2615,17 +2311,9 @@ def element_orientations_elemental(
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2677,17 +2365,9 @@ def element_orientations_nodal(
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2741,17 +2421,9 @@ def artificial_hourglass_energy(
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2805,17 +2477,9 @@ def thermal_dissipation_energy(
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2869,17 +2533,9 @@ def kinetic_energy(
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2933,17 +2589,9 @@ def hydrostatic_pressure(
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -2997,17 +2645,9 @@ def hydrostatic_pressure_nodal(
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3061,17 +2701,9 @@ def hydrostatic_pressure_elemental(
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3125,17 +2757,9 @@ def structural_temperature(
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3189,17 +2813,9 @@ def structural_temperature_nodal(
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3253,17 +2869,9 @@ def structural_temperature_elemental(
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             selection:
@@ -3319,17 +2927,9 @@ def element_nodal_forces(
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -3391,17 +2991,9 @@ def element_nodal_forces_nodal(
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -3462,17 +3054,9 @@ def element_nodal_forces_elemental(
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -3532,17 +3116,9 @@ def nodal_force(
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
@@ -3604,17 +3180,9 @@ def nodal_moment(
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
-
-        The `selection` argument overrides any other filtering argument.
-        Then, in order of priority (and from fine to coarse), only one time selection argument
-        is taken into account: `set_ids`, then `times`, and then `load_steps`.
-        In the same manner, only one mesh entity argument is taken into account:
-        `named_selections`, then `element_ids`, and then `node_ids`.
+        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        exclusive.
 
         Args:
             components:
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index fc6ee9876..b8eaf51d2 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -75,6 +75,12 @@ def test_warning_empty(self, static_simulation):
                 components=1, node_ids=[1001, 1002, 1003]
             )
 
+    def test_raise_mutually_exclusive(self, static_simulation):
+        with pytest.raises(ValueError, match="exclusive"):
+            _ = static_simulation.displacement(node_ids=[42], element_ids=[1])
+        with pytest.raises(ValueError, match="exclusive"):
+            _ = static_simulation.displacement(load_steps=[1], set_ids=[1])
+
     def test_displacement(self, static_simulation):
         displacement_x = static_simulation.displacement(
             components=["X"], node_ids=[42, 43, 44], set_ids=[1]

From 8b538359128f848daef94dd783e64e5d384d292a Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Wed, 15 Feb 2023 11:11:10 +0100
Subject: [PATCH 30/33] Add an "all_sets" argument which is set to True means
 all sets will be extracted.

---
 src/ansys/dpf/post/simulation.py              |  21 +-
 .../dpf/post/static_mechanical_simulation.py  | 708 +++++++++++++-----
 .../post/transient_mechanical_simulation.py   | 590 +++++++++++----
 tests/test_simulation.py                      |  13 +-
 4 files changed, 966 insertions(+), 366 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 46c5a597a..0d359a24d 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -476,10 +476,12 @@ def _build_time_freq_scoping(
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
+        all_sets: bool = False,
     ) -> core.time_freq_scoping_factory.Scoping:
         """Generate a time_freq_scoping from input arguments.
 
-        Only one input is used, by order of priority: selection, set_ids, times, load_steps.
+        Only one input is used, by order of priority:
+        all_sets, selection, set_ids, times, load_steps.
 
         Args:
             selection:
@@ -490,6 +492,8 @@ def _build_time_freq_scoping(
                 Time values to use, if no selection nor set_ids are defined.
             load_steps:
                 Load step IDs (and sub-step if tuple) to use, if no other is defined.
+            all_sets:
+                Whether to force extraction of all sets.
 
         Returns
         -------
@@ -497,16 +501,19 @@ def _build_time_freq_scoping(
         """
         tot = (
             (set_ids is not None)
+            + (all_sets is True)
             + (times is not None)
             + (load_steps is not None)
             + (selection is not None)
         )
         if tot > 1:
             raise ValueError(
-                "Arguments selection, named_selections, element_ids, "
-                "and node_ids are mutually exclusive"
+                "Arguments all_sets, selection, set_ids, times, "
+                "and load_steps are mutually exclusive."
             )
-        # create from selection in priority
+        if all_sets:
+            return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
+        # create from selection
         if selection:
             return selection.time_freq_selection._evaluate_on(simulation=self)
         # else from set_ids
@@ -545,8 +552,10 @@ def _build_time_freq_scoping(
             return core.time_freq_scoping_factory.scoping_by_load_steps(
                 load_steps=load_steps, server=self._model._server
             )
-        # Otherwise, no argument was given, create a time_freq_scoping of the whole results
-        return core.time_freq_scoping_factory.scoping_on_all_time_freqs(self._model)
+        # Otherwise, no argument was given, create a time_freq_scoping of the last set only
+        return core.time_freq_scoping_factory.scoping_by_set(
+            cumulative_set=self.time_freq_support.n_sets, server=self._model._server
+        )
 
 
 class ModalMechanicalSimulation(MechanicalSimulation):
diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index ab3fa22f1..1ee31dfa6 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -21,6 +21,7 @@ def _get_result(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -30,7 +31,8 @@ def _get_result(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -53,6 +55,8 @@ def _get_result(
             set_ids:
                 List of sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
                 List of load steps to get results for.
             node_ids:
@@ -73,6 +77,7 @@ def _get_result(
             set_ids=set_ids,
             times=times,
             load_steps=load_steps,
+            all_sets=all_sets,
         )
 
         # Build the targeted mesh scoping
@@ -191,6 +196,7 @@ def displacement(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -200,7 +206,8 @@ def displacement(
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -218,6 +225,8 @@ def displacement(
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
             sub_steps:
@@ -243,6 +252,7 @@ def displacement(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -255,6 +265,7 @@ def stress(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -264,7 +275,8 @@ def stress(
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -278,10 +290,12 @@ def stress(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -302,6 +316,7 @@ def stress(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -314,6 +329,7 @@ def stress_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -323,7 +339,8 @@ def stress_elemental(
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -337,10 +354,12 @@ def stress_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -361,6 +380,7 @@ def stress_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -373,6 +393,7 @@ def stress_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -382,7 +403,8 @@ def stress_nodal(
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -396,10 +418,12 @@ def stress_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -420,6 +444,7 @@ def stress_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -431,15 +456,18 @@ def stress_principal(
         components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -452,10 +480,12 @@ def stress_principal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -474,6 +504,7 @@ def stress_principal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -485,15 +516,18 @@ def stress_principal_elemental(
         components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -506,10 +540,12 @@ def stress_principal_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -528,6 +564,7 @@ def stress_principal_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -539,16 +576,19 @@ def stress_principal_nodal(
         components: Union[List[str], List[int], None] = None,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -561,10 +601,12 @@ def stress_principal_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -585,6 +627,7 @@ def stress_principal_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -595,15 +638,18 @@ def stress_eqv_von_mises(
         self,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -614,10 +660,12 @@ def stress_eqv_von_mises(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -636,6 +684,7 @@ def stress_eqv_von_mises(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -646,15 +695,18 @@ def stress_eqv_von_mises_elemental(
         self,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -665,10 +717,12 @@ def stress_eqv_von_mises_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -687,6 +741,7 @@ def stress_eqv_von_mises_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -697,16 +752,19 @@ def stress_eqv_von_mises_nodal(
         self,
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
-        set_ids: Union[List[int], None] = None,
-        load_steps: Union[List[int], None] = None,
-        sub_steps: Union[List[int], None] = None,
+        set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
+        load_steps: Union[
+            int, List[int], Tuple[int, Union[int, List[int]]], None
+        ] = None,
         node_ids: Union[List[int], None] = None,
         element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -717,10 +775,12 @@ def stress_eqv_von_mises_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -741,6 +801,7 @@ def stress_eqv_von_mises_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -753,6 +814,7 @@ def elastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -762,7 +824,8 @@ def elastic_strain(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -776,10 +839,12 @@ def elastic_strain(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -800,6 +865,7 @@ def elastic_strain(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -812,6 +878,7 @@ def elastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -821,7 +888,8 @@ def elastic_strain_nodal(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -835,10 +903,12 @@ def elastic_strain_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -859,6 +929,7 @@ def elastic_strain_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -871,6 +942,7 @@ def elastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -880,7 +952,8 @@ def elastic_strain_elemental(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -894,10 +967,12 @@ def elastic_strain_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -918,6 +993,7 @@ def elastic_strain_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -930,6 +1006,7 @@ def elastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -938,7 +1015,8 @@ def elastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -951,10 +1029,12 @@ def elastic_strain_principal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -973,6 +1053,7 @@ def elastic_strain_principal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -985,6 +1066,7 @@ def elastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -994,7 +1076,8 @@ def elastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1007,10 +1090,12 @@ def elastic_strain_principal_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1031,6 +1116,7 @@ def elastic_strain_principal_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1043,6 +1129,7 @@ def elastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1051,7 +1138,8 @@ def elastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1064,10 +1152,12 @@ def elastic_strain_principal_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1086,6 +1176,7 @@ def elastic_strain_principal_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1097,6 +1188,7 @@ def plastic_state_variable(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1105,7 +1197,8 @@ def plastic_state_variable(
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1116,10 +1209,12 @@ def plastic_state_variable(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1138,6 +1233,7 @@ def plastic_state_variable(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1149,6 +1245,7 @@ def plastic_state_variable_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1157,7 +1254,8 @@ def plastic_state_variable_elemental(
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1168,10 +1266,12 @@ def plastic_state_variable_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1190,6 +1290,7 @@ def plastic_state_variable_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1201,6 +1302,7 @@ def plastic_state_variable_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1210,7 +1312,8 @@ def plastic_state_variable_nodal(
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1221,10 +1324,12 @@ def plastic_state_variable_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1245,6 +1350,7 @@ def plastic_state_variable_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1257,6 +1363,7 @@ def plastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1266,7 +1373,8 @@ def plastic_strain(
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1280,10 +1388,12 @@ def plastic_strain(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1304,6 +1414,7 @@ def plastic_strain(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1316,6 +1427,7 @@ def plastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1325,7 +1437,8 @@ def plastic_strain_nodal(
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1339,10 +1452,12 @@ def plastic_strain_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1363,6 +1478,7 @@ def plastic_strain_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1375,6 +1491,7 @@ def plastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1384,7 +1501,8 @@ def plastic_strain_elemental(
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1398,10 +1516,12 @@ def plastic_strain_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1422,6 +1542,7 @@ def plastic_strain_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1434,6 +1555,7 @@ def plastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1442,7 +1564,8 @@ def plastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1455,10 +1578,12 @@ def plastic_strain_principal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1477,6 +1602,7 @@ def plastic_strain_principal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1489,6 +1615,7 @@ def plastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1498,7 +1625,8 @@ def plastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1511,10 +1639,12 @@ def plastic_strain_principal_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1535,6 +1665,7 @@ def plastic_strain_principal_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1547,6 +1678,7 @@ def plastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1555,7 +1687,8 @@ def plastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1568,10 +1701,12 @@ def plastic_strain_principal_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1590,6 +1725,7 @@ def plastic_strain_principal_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1601,6 +1737,7 @@ def plastic_strain_eqv(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1609,7 +1746,8 @@ def plastic_strain_eqv(
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1620,10 +1758,12 @@ def plastic_strain_eqv(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1642,6 +1782,7 @@ def plastic_strain_eqv(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1653,6 +1794,7 @@ def plastic_strain_eqv_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1662,7 +1804,8 @@ def plastic_strain_eqv_nodal(
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1673,10 +1816,12 @@ def plastic_strain_eqv_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1697,6 +1842,7 @@ def plastic_strain_eqv_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1708,6 +1854,7 @@ def plastic_strain_eqv_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1716,7 +1863,8 @@ def plastic_strain_eqv_elemental(
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1727,10 +1875,12 @@ def plastic_strain_eqv_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1749,6 +1899,7 @@ def plastic_strain_eqv_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1761,6 +1912,7 @@ def creep_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1770,7 +1922,8 @@ def creep_strain(
     ) -> DataObject:
         """Extract elemental nodal creep strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1784,10 +1937,12 @@ def creep_strain(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1808,6 +1963,7 @@ def creep_strain(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1820,6 +1976,7 @@ def creep_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1829,7 +1986,8 @@ def creep_strain_nodal(
     ) -> DataObject:
         """Extract nodal creep strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1843,10 +2001,12 @@ def creep_strain_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1867,6 +2027,7 @@ def creep_strain_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1879,6 +2040,7 @@ def creep_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1888,7 +2050,8 @@ def creep_strain_elemental(
     ) -> DataObject:
         """Extract elemental creep strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1902,10 +2065,12 @@ def creep_strain_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -1926,6 +2091,7 @@ def creep_strain_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1938,6 +2104,7 @@ def creep_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1946,7 +2113,8 @@ def creep_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal creep strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1959,10 +2127,12 @@ def creep_strain_principal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -1981,6 +2151,7 @@ def creep_strain_principal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1993,6 +2164,7 @@ def creep_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2002,7 +2174,8 @@ def creep_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal creep strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2015,10 +2188,12 @@ def creep_strain_principal_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2039,6 +2214,7 @@ def creep_strain_principal_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2051,6 +2227,7 @@ def creep_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2059,7 +2236,8 @@ def creep_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal creep strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2072,10 +2250,12 @@ def creep_strain_principal_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2094,6 +2274,7 @@ def creep_strain_principal_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2105,6 +2286,7 @@ def creep_strain_eqv(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2113,7 +2295,8 @@ def creep_strain_eqv(
     ) -> DataObject:
         """Extract elemental nodal equivalent creep strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2124,10 +2307,12 @@ def creep_strain_eqv(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2146,6 +2331,7 @@ def creep_strain_eqv(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2157,6 +2343,7 @@ def creep_strain_equivalent_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2166,7 +2353,8 @@ def creep_strain_equivalent_nodal(
     ) -> DataObject:
         """Extract nodal equivalent creep strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2177,10 +2365,12 @@ def creep_strain_equivalent_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2201,6 +2391,7 @@ def creep_strain_equivalent_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2212,6 +2403,7 @@ def creep_strain_equivalent_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2220,7 +2412,8 @@ def creep_strain_equivalent_elemental(
     ) -> DataObject:
         """Extract elemental equivalent creep strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2231,10 +2424,12 @@ def creep_strain_equivalent_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2253,6 +2448,7 @@ def creep_strain_equivalent_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2266,6 +2462,7 @@ def reaction_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2275,7 +2472,8 @@ def reaction_force(
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2291,10 +2489,12 @@ def reaction_force(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2316,6 +2516,7 @@ def reaction_force(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2327,6 +2528,7 @@ def elemental_volume(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2335,7 +2537,8 @@ def elemental_volume(
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2346,10 +2549,12 @@ def elemental_volume(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2368,6 +2573,7 @@ def elemental_volume(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2379,6 +2585,7 @@ def elemental_mass(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2387,7 +2594,8 @@ def elemental_mass(
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2398,10 +2606,12 @@ def elemental_mass(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2420,6 +2630,7 @@ def elemental_mass(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2431,6 +2642,7 @@ def elemental_heat_generation(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2439,7 +2651,8 @@ def elemental_heat_generation(
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2450,10 +2663,12 @@ def elemental_heat_generation(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2472,6 +2687,7 @@ def elemental_heat_generation(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2483,6 +2699,7 @@ def element_centroids(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2491,7 +2708,8 @@ def element_centroids(
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2502,10 +2720,12 @@ def element_centroids(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2524,6 +2744,7 @@ def element_centroids(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2535,6 +2756,7 @@ def thickness(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2543,7 +2765,8 @@ def thickness(
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2554,10 +2777,12 @@ def thickness(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2576,6 +2801,7 @@ def thickness(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2587,6 +2813,7 @@ def element_orientations(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2595,7 +2822,8 @@ def element_orientations(
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2606,10 +2834,12 @@ def element_orientations(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2628,6 +2858,7 @@ def element_orientations(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2639,6 +2870,7 @@ def element_orientations_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2647,7 +2879,8 @@ def element_orientations_elemental(
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2658,10 +2891,12 @@ def element_orientations_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -2680,6 +2915,7 @@ def element_orientations_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2691,6 +2927,7 @@ def element_orientations_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2700,7 +2937,8 @@ def element_orientations_nodal(
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2711,10 +2949,12 @@ def element_orientations_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2735,6 +2975,7 @@ def element_orientations_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2746,6 +2987,7 @@ def stiffness_matrix_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2755,7 +2997,8 @@ def stiffness_matrix_energy(
     ) -> DataObject:
         """Extract stiffness matrix energy results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2766,10 +3009,12 @@ def stiffness_matrix_energy(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2790,6 +3035,7 @@ def stiffness_matrix_energy(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2801,6 +3047,7 @@ def artificial_hourglass_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2810,7 +3057,8 @@ def artificial_hourglass_energy(
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2821,10 +3069,12 @@ def artificial_hourglass_energy(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2845,6 +3095,7 @@ def artificial_hourglass_energy(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2856,6 +3107,7 @@ def thermal_dissipation_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2865,7 +3117,8 @@ def thermal_dissipation_energy(
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2876,10 +3129,12 @@ def thermal_dissipation_energy(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2900,6 +3155,7 @@ def thermal_dissipation_energy(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2911,6 +3167,7 @@ def kinetic_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2920,7 +3177,8 @@ def kinetic_energy(
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2931,10 +3189,12 @@ def kinetic_energy(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -2955,6 +3215,7 @@ def kinetic_energy(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2966,6 +3227,7 @@ def hydrostatic_pressure(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2975,7 +3237,8 @@ def hydrostatic_pressure(
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2986,10 +3249,12 @@ def hydrostatic_pressure(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3010,6 +3275,7 @@ def hydrostatic_pressure(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3021,6 +3287,7 @@ def hydrostatic_pressure_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3030,7 +3297,8 @@ def hydrostatic_pressure_nodal(
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3041,10 +3309,12 @@ def hydrostatic_pressure_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3065,6 +3335,7 @@ def hydrostatic_pressure_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3076,6 +3347,7 @@ def hydrostatic_pressure_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3085,7 +3357,8 @@ def hydrostatic_pressure_elemental(
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3096,10 +3369,12 @@ def hydrostatic_pressure_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3120,6 +3395,7 @@ def hydrostatic_pressure_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3131,6 +3407,7 @@ def structural_temperature(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3140,7 +3417,8 @@ def structural_temperature(
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3151,10 +3429,12 @@ def structural_temperature(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3175,6 +3455,7 @@ def structural_temperature(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3186,6 +3467,7 @@ def structural_temperature_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3195,7 +3477,8 @@ def structural_temperature_nodal(
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3206,10 +3489,12 @@ def structural_temperature_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3230,6 +3515,7 @@ def structural_temperature_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3241,6 +3527,7 @@ def structural_temperature_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3250,7 +3537,8 @@ def structural_temperature_elemental(
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3261,10 +3549,12 @@ def structural_temperature_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3285,6 +3575,7 @@ def structural_temperature_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3298,6 +3589,7 @@ def element_nodal_forces(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3307,7 +3599,8 @@ def element_nodal_forces(
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3323,10 +3616,12 @@ def element_nodal_forces(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3348,6 +3643,7 @@ def element_nodal_forces(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3361,6 +3657,7 @@ def element_nodal_forces_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3370,7 +3667,8 @@ def element_nodal_forces_nodal(
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3386,10 +3684,12 @@ def element_nodal_forces_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3411,6 +3711,7 @@ def element_nodal_forces_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3424,6 +3725,7 @@ def element_nodal_forces_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3432,7 +3734,8 @@ def element_nodal_forces_elemental(
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3448,10 +3751,12 @@ def element_nodal_forces_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selection:
@@ -3471,6 +3776,7 @@ def element_nodal_forces_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -3484,6 +3790,7 @@ def nodal_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3493,7 +3800,8 @@ def nodal_force(
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3511,6 +3819,8 @@ def nodal_force(
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
             sub_steps:
@@ -3536,6 +3846,7 @@ def nodal_force(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3549,6 +3860,7 @@ def nodal_moment(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3558,7 +3870,8 @@ def nodal_moment(
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3576,6 +3889,8 @@ def nodal_moment(
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
             sub_steps:
@@ -3601,6 +3916,7 @@ def nodal_moment(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index bccb94a03..ccf3d6873 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -21,6 +21,7 @@ def _get_result(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -30,7 +31,8 @@ def _get_result(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -54,6 +56,8 @@ def _get_result(
             set_ids:
                 List of sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
                 List of load steps to get results for.
             node_ids:
@@ -74,6 +78,7 @@ def _get_result(
             set_ids=set_ids,
             times=times,
             load_steps=load_steps,
+            all_sets=all_sets,
         )
 
         # Build the targeted mesh scoping
@@ -192,6 +197,7 @@ def displacement(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -201,7 +207,8 @@ def displacement(
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -218,10 +225,12 @@ def displacement(
             times:
                 Times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -243,6 +252,7 @@ def displacement(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -256,6 +266,7 @@ def velocity(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -265,7 +276,8 @@ def velocity(
     ) -> DataObject:
         """Extract velocity results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -282,10 +294,12 @@ def velocity(
             times:
                 Times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -307,6 +321,7 @@ def velocity(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -320,6 +335,7 @@ def acceleration(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -329,7 +345,8 @@ def acceleration(
     ) -> DataObject:
         """Extract acceleration results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -346,10 +363,12 @@ def acceleration(
             times:
                 Times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -371,6 +390,7 @@ def acceleration(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -383,6 +403,7 @@ def stress(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -392,7 +413,8 @@ def stress(
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -407,10 +429,12 @@ def stress(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -431,6 +455,7 @@ def stress(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -443,6 +468,7 @@ def stress_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -452,7 +478,8 @@ def stress_elemental(
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -467,10 +494,12 @@ def stress_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -491,6 +520,7 @@ def stress_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -503,6 +533,7 @@ def stress_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -512,7 +543,8 @@ def stress_nodal(
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -527,10 +559,12 @@ def stress_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -551,6 +585,7 @@ def stress_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -563,6 +598,7 @@ def stress_principal(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -571,7 +607,8 @@ def stress_principal(
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -585,10 +622,12 @@ def stress_principal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -607,6 +646,7 @@ def stress_principal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -619,6 +659,7 @@ def stress_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -627,7 +668,8 @@ def stress_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -641,10 +683,12 @@ def stress_principal_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -663,6 +707,7 @@ def stress_principal_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -675,6 +720,7 @@ def stress_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -684,7 +730,8 @@ def stress_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -698,10 +745,12 @@ def stress_principal_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -722,6 +771,7 @@ def stress_principal_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -733,6 +783,7 @@ def stress_eqv_von_mises(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -741,7 +792,8 @@ def stress_eqv_von_mises(
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -753,10 +805,12 @@ def stress_eqv_von_mises(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -775,6 +829,7 @@ def stress_eqv_von_mises(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -786,6 +841,7 @@ def stress_eqv_von_mises_elemental(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -794,7 +850,8 @@ def stress_eqv_von_mises_elemental(
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -806,10 +863,12 @@ def stress_eqv_von_mises_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -828,6 +887,7 @@ def stress_eqv_von_mises_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -839,6 +899,7 @@ def stress_eqv_von_mises_nodal(
         selection: Union[Selection, None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -848,7 +909,8 @@ def stress_eqv_von_mises_nodal(
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -860,10 +922,12 @@ def stress_eqv_von_mises_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -884,6 +948,7 @@ def stress_eqv_von_mises_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -896,6 +961,7 @@ def elastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -905,7 +971,8 @@ def elastic_strain(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -920,10 +987,12 @@ def elastic_strain(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -944,6 +1013,7 @@ def elastic_strain(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -956,6 +1026,7 @@ def elastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -965,7 +1036,8 @@ def elastic_strain_nodal(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -980,10 +1052,12 @@ def elastic_strain_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1004,6 +1078,7 @@ def elastic_strain_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1016,6 +1091,7 @@ def elastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1025,7 +1101,8 @@ def elastic_strain_elemental(
     ) -> DataObject:
         """Extract stress results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1040,10 +1117,12 @@ def elastic_strain_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1064,6 +1143,7 @@ def elastic_strain_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1076,6 +1156,7 @@ def elastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1084,7 +1165,8 @@ def elastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1098,10 +1180,12 @@ def elastic_strain_principal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1120,6 +1204,7 @@ def elastic_strain_principal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1132,6 +1217,7 @@ def elastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1141,7 +1227,8 @@ def elastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1155,10 +1242,12 @@ def elastic_strain_principal_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1179,6 +1268,7 @@ def elastic_strain_principal_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1191,6 +1281,7 @@ def elastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1199,7 +1290,8 @@ def elastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1213,10 +1305,12 @@ def elastic_strain_principal_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1235,6 +1329,7 @@ def elastic_strain_principal_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1246,6 +1341,7 @@ def plastic_state_variable(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1254,7 +1350,8 @@ def plastic_state_variable(
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1266,10 +1363,12 @@ def plastic_state_variable(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1288,6 +1387,7 @@ def plastic_state_variable(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1299,6 +1399,7 @@ def plastic_state_variable_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1307,7 +1408,8 @@ def plastic_state_variable_elemental(
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1319,10 +1421,12 @@ def plastic_state_variable_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1341,6 +1445,7 @@ def plastic_state_variable_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1352,6 +1457,7 @@ def plastic_state_variable_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1361,7 +1467,8 @@ def plastic_state_variable_nodal(
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1373,10 +1480,12 @@ def plastic_state_variable_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1397,6 +1506,7 @@ def plastic_state_variable_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1409,6 +1519,7 @@ def plastic_strain(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1418,7 +1529,8 @@ def plastic_strain(
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1433,10 +1545,12 @@ def plastic_strain(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1457,6 +1571,7 @@ def plastic_strain(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1469,6 +1584,7 @@ def plastic_strain_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1478,7 +1594,8 @@ def plastic_strain_nodal(
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1493,10 +1610,12 @@ def plastic_strain_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1517,6 +1636,7 @@ def plastic_strain_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1529,6 +1649,7 @@ def plastic_strain_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1538,7 +1659,8 @@ def plastic_strain_elemental(
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1553,10 +1675,12 @@ def plastic_strain_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1577,6 +1701,7 @@ def plastic_strain_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1589,6 +1714,7 @@ def plastic_strain_principal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1597,7 +1723,8 @@ def plastic_strain_principal(
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1611,10 +1738,12 @@ def plastic_strain_principal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1633,6 +1762,7 @@ def plastic_strain_principal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1645,6 +1775,7 @@ def plastic_strain_principal_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1654,7 +1785,8 @@ def plastic_strain_principal_nodal(
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1668,10 +1800,12 @@ def plastic_strain_principal_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1692,6 +1826,7 @@ def plastic_strain_principal_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1704,6 +1839,7 @@ def plastic_strain_principal_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1712,7 +1848,8 @@ def plastic_strain_principal_elemental(
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1726,10 +1863,12 @@ def plastic_strain_principal_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1748,6 +1887,7 @@ def plastic_strain_principal_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1759,6 +1899,7 @@ def plastic_strain_eqv(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1767,7 +1908,8 @@ def plastic_strain_eqv(
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1779,10 +1921,12 @@ def plastic_strain_eqv(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1801,6 +1945,7 @@ def plastic_strain_eqv(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1812,6 +1957,7 @@ def plastic_strain_eqv_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1821,7 +1967,8 @@ def plastic_strain_eqv_nodal(
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1833,10 +1980,12 @@ def plastic_strain_eqv_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1857,6 +2006,7 @@ def plastic_strain_eqv_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1868,6 +2018,7 @@ def plastic_strain_eqv_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1876,7 +2027,8 @@ def plastic_strain_eqv_elemental(
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1888,10 +2040,12 @@ def plastic_strain_eqv_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -1910,6 +2064,7 @@ def plastic_strain_eqv_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -1923,6 +2078,7 @@ def reaction_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1932,7 +2088,8 @@ def reaction_force(
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -1949,10 +2106,12 @@ def reaction_force(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -1974,6 +2133,7 @@ def reaction_force(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -1985,6 +2145,7 @@ def elemental_volume(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -1993,7 +2154,8 @@ def elemental_volume(
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2005,10 +2167,12 @@ def elemental_volume(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2027,6 +2191,7 @@ def elemental_volume(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2038,6 +2203,7 @@ def elemental_mass(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2046,7 +2212,8 @@ def elemental_mass(
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2058,10 +2225,12 @@ def elemental_mass(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2080,6 +2249,7 @@ def elemental_mass(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2091,6 +2261,7 @@ def elemental_heat_generation(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2099,7 +2270,8 @@ def elemental_heat_generation(
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2111,10 +2283,12 @@ def elemental_heat_generation(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2133,6 +2307,7 @@ def elemental_heat_generation(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2144,6 +2319,7 @@ def element_centroids(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2152,7 +2328,8 @@ def element_centroids(
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2164,10 +2341,12 @@ def element_centroids(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2186,6 +2365,7 @@ def element_centroids(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2197,6 +2377,7 @@ def thickness(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2205,7 +2386,8 @@ def thickness(
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2217,10 +2399,12 @@ def thickness(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2239,6 +2423,7 @@ def thickness(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2250,6 +2435,7 @@ def element_orientations(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2258,7 +2444,8 @@ def element_orientations(
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2270,10 +2457,12 @@ def element_orientations(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2292,6 +2481,7 @@ def element_orientations(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2303,6 +2493,7 @@ def element_orientations_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2311,7 +2502,8 @@ def element_orientations_elemental(
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2323,10 +2515,12 @@ def element_orientations_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -2345,6 +2539,7 @@ def element_orientations_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -2356,6 +2551,7 @@ def element_orientations_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2365,7 +2561,8 @@ def element_orientations_nodal(
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2377,10 +2574,12 @@ def element_orientations_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2401,6 +2600,7 @@ def element_orientations_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2412,6 +2612,7 @@ def artificial_hourglass_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2421,7 +2622,8 @@ def artificial_hourglass_energy(
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2433,10 +2635,12 @@ def artificial_hourglass_energy(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2457,6 +2661,7 @@ def artificial_hourglass_energy(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2468,6 +2673,7 @@ def thermal_dissipation_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2477,7 +2683,8 @@ def thermal_dissipation_energy(
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2489,10 +2696,12 @@ def thermal_dissipation_energy(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2513,6 +2722,7 @@ def thermal_dissipation_energy(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2524,6 +2734,7 @@ def kinetic_energy(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2533,7 +2744,8 @@ def kinetic_energy(
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2545,10 +2757,12 @@ def kinetic_energy(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2569,6 +2783,7 @@ def kinetic_energy(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2580,6 +2795,7 @@ def hydrostatic_pressure(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2589,7 +2805,8 @@ def hydrostatic_pressure(
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2601,10 +2818,12 @@ def hydrostatic_pressure(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2625,6 +2844,7 @@ def hydrostatic_pressure(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2636,6 +2856,7 @@ def hydrostatic_pressure_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2645,7 +2866,8 @@ def hydrostatic_pressure_nodal(
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2657,10 +2879,12 @@ def hydrostatic_pressure_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2681,6 +2905,7 @@ def hydrostatic_pressure_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2692,6 +2917,7 @@ def hydrostatic_pressure_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2701,7 +2927,8 @@ def hydrostatic_pressure_elemental(
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2713,10 +2940,12 @@ def hydrostatic_pressure_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2737,6 +2966,7 @@ def hydrostatic_pressure_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2748,6 +2978,7 @@ def structural_temperature(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2757,7 +2988,8 @@ def structural_temperature(
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2769,10 +3001,12 @@ def structural_temperature(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2793,6 +3027,7 @@ def structural_temperature(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2804,6 +3039,7 @@ def structural_temperature_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2813,7 +3049,8 @@ def structural_temperature_nodal(
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2825,10 +3062,12 @@ def structural_temperature_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2849,6 +3088,7 @@ def structural_temperature_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2860,6 +3100,7 @@ def structural_temperature_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2869,7 +3110,8 @@ def structural_temperature_elemental(
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2881,10 +3123,12 @@ def structural_temperature_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2905,6 +3149,7 @@ def structural_temperature_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2918,6 +3163,7 @@ def element_nodal_forces(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2927,7 +3173,8 @@ def element_nodal_forces(
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -2944,10 +3191,12 @@ def element_nodal_forces(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -2969,6 +3218,7 @@ def element_nodal_forces(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -2982,6 +3232,7 @@ def element_nodal_forces_nodal(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -2991,7 +3242,8 @@ def element_nodal_forces_nodal(
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3008,10 +3260,12 @@ def element_nodal_forces_nodal(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             elements:
@@ -3033,6 +3287,7 @@ def element_nodal_forces_nodal(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3046,6 +3301,7 @@ def element_nodal_forces_elemental(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3054,7 +3310,8 @@ def element_nodal_forces_elemental(
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3071,10 +3328,12 @@ def element_nodal_forces_elemental(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             elements:
                 List of elements to get results for.
             named_selections:
@@ -3094,6 +3353,7 @@ def element_nodal_forces_elemental(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=None,
             element_ids=element_ids,
@@ -3107,6 +3367,7 @@ def nodal_force(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3116,7 +3377,8 @@ def nodal_force(
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3133,10 +3395,12 @@ def nodal_force(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3158,6 +3422,7 @@ def nodal_force(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
@@ -3171,6 +3436,7 @@ def nodal_moment(
         selection: Union[Selection, None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
+        all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
@@ -3180,7 +3446,8 @@ def nodal_moment(
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
-        Arguments `selection`, `set_ids`, `times`, and `load_steps` are mutually exclusive.
+        Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
+        exclusive.
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
 
@@ -3197,10 +3464,12 @@ def nodal_moment(
             times:
                 List of times to get results for.
             set_ids:
-                List of sets to get results for.
+                Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
+            all_sets:
+                Whether to get results for all sets.
             load_steps:
-                List of load steps to get results for.
+                Load steps to get results for.
             node_ids:
                 List of IDs of nodes to get results for.
             element_ids:
@@ -3222,6 +3491,7 @@ def nodal_moment(
             selection=selection,
             times=times,
             set_ids=set_ids,
+            all_sets=all_sets,
             load_steps=load_steps,
             node_ids=node_ids,
             element_ids=element_ids,
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index b8eaf51d2..a439b3c1a 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -83,7 +83,7 @@ def test_raise_mutually_exclusive(self, static_simulation):
 
     def test_displacement(self, static_simulation):
         displacement_x = static_simulation.displacement(
-            components=["X"], node_ids=[42, 43, 44], set_ids=[1]
+            components=["X"], node_ids=[42, 43, 44]
         )
         assert len(displacement_x._fc) == 1
         assert displacement_x._fc.get_time_scoping().ids == [1]
@@ -435,14 +435,19 @@ def test_element_nodal_forces_elemental(self, allkindofcomplexity):
 class TestTransientMechanicalSimulation:
     def test_displacement(self, transient_simulation):
         result = transient_simulation.displacement(
-            components=["X"], node_ids=[2, 3, 4], set_ids=[2]
+            components=["X"],
+            node_ids=[2, 3, 4],
+            all_sets=True,
         )
+        assert len(result._fc) == 20
+        assert len(result._fc.get_time_scoping().ids) == 20
+        result = transient_simulation.displacement(components=["X"], node_ids=[2, 3, 4])
         assert len(result._fc) == 1
-        assert result._fc.get_time_scoping().ids == [2]
+        assert result._fc.get_time_scoping().ids == [20]
         field = result._fc[0]
         op = transient_simulation._model.operator("UX")
         time_scoping = core.time_freq_scoping_factory.scoping_by_set(
-            2, server=transient_simulation._model._server
+            20, server=transient_simulation._model._server
         )
         op.connect(0, time_scoping)
         mesh_scoping = core.mesh_scoping_factory.nodal_scoping(

From 36a9b2c2143c1312abddd7b538cf9e5e58b11bf9 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Wed, 15 Feb 2023 11:15:05 +0100
Subject: [PATCH 31/33] Improve docstrings to explain extraction defaults in
 case of no argument given.

---
 .../dpf/post/static_mechanical_simulation.py  | 186 ++++++++++++++++++
 .../post/transient_mechanical_simulation.py   | 162 +++++++++++++++
 2 files changed, 348 insertions(+)

diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index 1ee31dfa6..2a2291d82 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -33,8 +33,11 @@ def _get_result(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             base_name:
@@ -208,8 +211,11 @@ def displacement(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -277,8 +283,11 @@ def stress(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -341,8 +350,11 @@ def stress_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -405,8 +417,11 @@ def stress_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -468,8 +483,11 @@ def stress_principal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -528,8 +546,11 @@ def stress_principal_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -589,8 +610,11 @@ def stress_principal_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -650,8 +674,11 @@ def stress_eqv_von_mises(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -707,8 +734,11 @@ def stress_eqv_von_mises_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -765,8 +795,11 @@ def stress_eqv_von_mises_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -826,8 +859,11 @@ def elastic_strain(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -890,8 +926,11 @@ def elastic_strain_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -954,8 +993,11 @@ def elastic_strain_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1017,8 +1059,11 @@ def elastic_strain_principal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1078,8 +1123,11 @@ def elastic_strain_principal_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1140,8 +1188,11 @@ def elastic_strain_principal_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1199,8 +1250,11 @@ def plastic_state_variable(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1256,8 +1310,11 @@ def plastic_state_variable_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1314,8 +1371,11 @@ def plastic_state_variable_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1375,8 +1435,11 @@ def plastic_strain(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1439,8 +1502,11 @@ def plastic_strain_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1503,8 +1569,11 @@ def plastic_strain_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1566,8 +1635,11 @@ def plastic_strain_principal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1627,8 +1699,11 @@ def plastic_strain_principal_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1689,8 +1764,11 @@ def plastic_strain_principal_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1748,8 +1826,11 @@ def plastic_strain_eqv(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1806,8 +1887,11 @@ def plastic_strain_eqv_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1865,8 +1949,11 @@ def plastic_strain_eqv_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1924,8 +2011,11 @@ def creep_strain(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1988,8 +2078,11 @@ def creep_strain_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -2052,8 +2145,11 @@ def creep_strain_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -2115,8 +2211,11 @@ def creep_strain_principal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -2176,8 +2275,11 @@ def creep_strain_principal_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -2238,8 +2340,11 @@ def creep_strain_principal_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -2297,8 +2402,11 @@ def creep_strain_eqv(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2355,8 +2463,11 @@ def creep_strain_equivalent_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2414,8 +2525,11 @@ def creep_strain_equivalent_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2474,8 +2588,11 @@ def reaction_force(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -2539,8 +2656,11 @@ def elemental_volume(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2596,8 +2716,11 @@ def elemental_mass(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2653,8 +2776,11 @@ def elemental_heat_generation(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2710,8 +2836,11 @@ def element_centroids(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2767,8 +2896,11 @@ def thickness(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2824,8 +2956,11 @@ def element_orientations(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2881,8 +3016,11 @@ def element_orientations_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2939,8 +3077,11 @@ def element_orientations_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2999,8 +3140,11 @@ def stiffness_matrix_energy(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3059,8 +3203,11 @@ def artificial_hourglass_energy(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3119,8 +3266,11 @@ def thermal_dissipation_energy(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3179,8 +3329,11 @@ def kinetic_energy(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3239,8 +3392,11 @@ def hydrostatic_pressure(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3299,8 +3455,11 @@ def hydrostatic_pressure_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3359,8 +3518,11 @@ def hydrostatic_pressure_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3419,8 +3581,11 @@ def structural_temperature(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3479,8 +3644,11 @@ def structural_temperature_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3539,8 +3707,11 @@ def structural_temperature_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3601,8 +3772,11 @@ def element_nodal_forces(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -3669,8 +3843,11 @@ def element_nodal_forces_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -3736,8 +3913,11 @@ def element_nodal_forces_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -3802,8 +3982,11 @@ def nodal_force(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -3872,8 +4055,11 @@ def nodal_moment(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index ccf3d6873..49584bd9b 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -33,8 +33,11 @@ def _get_result(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             base_name:
@@ -209,8 +212,11 @@ def displacement(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -278,8 +284,11 @@ def velocity(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -347,8 +356,11 @@ def acceleration(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -415,8 +427,11 @@ def stress(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -480,8 +495,11 @@ def stress_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -545,8 +563,11 @@ def stress_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -609,8 +630,11 @@ def stress_principal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -670,8 +694,11 @@ def stress_principal_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -732,8 +759,11 @@ def stress_principal_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -794,8 +824,11 @@ def stress_eqv_von_mises(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -852,8 +885,11 @@ def stress_eqv_von_mises_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -911,8 +947,11 @@ def stress_eqv_von_mises_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -973,8 +1012,11 @@ def elastic_strain(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1038,8 +1080,11 @@ def elastic_strain_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1103,8 +1148,11 @@ def elastic_strain_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1167,8 +1215,11 @@ def elastic_strain_principal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1229,8 +1280,11 @@ def elastic_strain_principal_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1292,8 +1346,11 @@ def elastic_strain_principal_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1352,8 +1409,11 @@ def plastic_state_variable(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1410,8 +1470,11 @@ def plastic_state_variable_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1469,8 +1532,11 @@ def plastic_state_variable_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1531,8 +1597,11 @@ def plastic_strain(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1596,8 +1665,11 @@ def plastic_strain_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1661,8 +1733,11 @@ def plastic_strain_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1725,8 +1800,11 @@ def plastic_strain_principal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1787,8 +1865,11 @@ def plastic_strain_principal_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1850,8 +1931,11 @@ def plastic_strain_principal_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -1910,8 +1994,11 @@ def plastic_strain_eqv(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -1969,8 +2056,11 @@ def plastic_strain_eqv_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2029,8 +2119,11 @@ def plastic_strain_eqv_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2090,8 +2183,11 @@ def reaction_force(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -2156,8 +2252,11 @@ def elemental_volume(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2214,8 +2313,11 @@ def elemental_mass(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2272,8 +2374,11 @@ def elemental_heat_generation(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2330,8 +2435,11 @@ def element_centroids(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2388,8 +2496,11 @@ def thickness(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2446,8 +2557,11 @@ def element_orientations(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2504,8 +2618,11 @@ def element_orientations_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2563,8 +2680,11 @@ def element_orientations_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2624,8 +2744,11 @@ def artificial_hourglass_energy(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2685,8 +2808,11 @@ def thermal_dissipation_energy(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2746,8 +2872,11 @@ def kinetic_energy(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2807,8 +2936,11 @@ def hydrostatic_pressure(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2868,8 +3000,11 @@ def hydrostatic_pressure_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2929,8 +3064,11 @@ def hydrostatic_pressure_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -2990,8 +3128,11 @@ def structural_temperature(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3051,8 +3192,11 @@ def structural_temperature_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3112,8 +3256,11 @@ def structural_temperature_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             selection:
@@ -3175,8 +3322,11 @@ def element_nodal_forces(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -3244,8 +3394,11 @@ def element_nodal_forces_nodal(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -3312,8 +3465,11 @@ def element_nodal_forces_elemental(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -3379,8 +3535,11 @@ def nodal_force(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:
@@ -3448,8 +3607,11 @@ def nodal_moment(
 
         Arguments `selection`, `set_ids`, `all_sets`, `times`, and `load_steps` are mutually
         exclusive.
+        If none of the above is given, only the last result will be returned.
+
         Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
         exclusive.
+        If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
             components:

From cb8d763c6e61d73664f9b65f0877cf3d3e5b5e56 Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Wed, 15 Feb 2023 14:33:53 +0100
Subject: [PATCH 32/33] Add implementation for "times" input.

---
 src/ansys/dpf/post/simulation.py | 62 +++++++++++++++++++++++++++++---
 tests/test_simulation.py         | 41 +++++++++++++++++++++
 2 files changed, 98 insertions(+), 5 deletions(-)

diff --git a/src/ansys/dpf/post/simulation.py b/src/ansys/dpf/post/simulation.py
index 0d359a24d..4fff3eb1b 100644
--- a/src/ansys/dpf/post/simulation.py
+++ b/src/ansys/dpf/post/simulation.py
@@ -6,6 +6,7 @@
 
 from ansys.dpf.core import DataSources, Model
 from ansys.dpf.core.plotter import DpfPlotter
+import numpy as np
 
 from ansys.dpf import core
 from ansys.dpf.post.mesh import Mesh
@@ -53,6 +54,11 @@ def __init__(self, data_sources: DataSources, model: Model):
         self._active_selection = None
         self._named_selections = None
         self._mesh = None
+        self._units = {
+            "time/frequency": self.time_freq_support.time_frequencies.unit,
+            "distance": self._model.metadata.meshed_region.unit,
+        }
+        self._time_freq_precision = None
 
     @property
     def results(self) -> List[str]:
@@ -262,11 +268,26 @@ def _time_frequencies(self):
         """Description of the temporal/frequency analysis of the model."""
         return self._model.metadata.time_freq_support
 
+    @property
+    def _get_time_freq_precision(self):
+        """Computes a precision for times/frequencies requests based on the underlying support."""
+        if self._time_freq_precision is None:
+            available_values = self.time_freq_support.time_frequencies.data
+            diff = np.diff(available_values, prepend=available_values[0] - 1.0)
+            minimum = np.min(diff)
+            self._time_freq_precision = minimum / 20.0
+        return self._time_freq_precision
+
     @property
     def time_freq_support(self):
         """Description of the temporal/frequency analysis of the model."""
         return self._time_frequencies
 
+    @property
+    def units(self):
+        """Returns the current time/frequency and distance units used."""
+        return self._units
+
     def __str__(self):
         """Get the string representation of this class."""
         txt = (
@@ -517,19 +538,50 @@ def _build_time_freq_scoping(
         if selection:
             return selection.time_freq_selection._evaluate_on(simulation=self)
         # else from set_ids
-        if set_ids:
+        if set_ids is not None:
             if isinstance(set_ids, int):
                 set_ids = [set_ids]
             return core.time_freq_scoping_factory.scoping_by_sets(
                 cumulative_sets=set_ids, server=self._model._server
             )
         # else from times
-        if times:
-            if isinstance(times, float):
+        if times is not None:
+            # Check input
+            if isinstance(times, list):
+                if any([not (type(t) in [float, int]) for t in times]):
+                    raise ValueError("Argument times must contain numeric values only.")
+            elif isinstance(times, float) or isinstance(times, int):
                 times = [times]
-            raise NotImplementedError
+            else:
+                raise TypeError("Argument times must be a number or a list of numbers.")
+
+            # Get the set_ids for available time values matching the requested time values.
+            available_times = self.time_freq_support.time_frequencies.data
+            precision = self._get_time_freq_precision
+            available_times_to_extract_set_ids = []
+            last_extracted_index = -1
+            len_available = len(available_times)
+            for t in times:
+                found = False
+                i = last_extracted_index + 1
+                while not found and i < len_available:
+                    if abs(float(t) - available_times[i]) < precision:
+                        last_extracted_index = i
+                        available_times_to_extract_set_ids.append(i + 1)
+                        found = True
+                    i += 1
+                if not found:
+                    raise ValueError(
+                        f"Could not find time={t}{self.units['time/frequency']} "
+                        f"in the simulation."
+                    )
+            return core.time_freq_scoping_factory.scoping_by_sets(
+                cumulative_sets=available_times_to_extract_set_ids,
+                server=self._model._server,
+            )
+
         # else from load_steps
-        if load_steps:
+        if load_steps is not None:
             # If load_steps and sub_steps
             if len(load_steps) == 2:
                 # Translate to cumulative indices (set IDs)
diff --git a/tests/test_simulation.py b/tests/test_simulation.py
index a439b3c1a..323bae296 100644
--- a/tests/test_simulation.py
+++ b/tests/test_simulation.py
@@ -69,6 +69,20 @@ def test_simulation_plot(static_simulation):
 
 
 class TestStaticMechanicalSimulation:
+    def test_times_argument(self, static_simulation):
+        _ = static_simulation.displacement(times=1)
+        _ = static_simulation.displacement(times=1.0)
+        _ = static_simulation.displacement(times=[1])
+        _ = static_simulation.displacement(times=[1.0])
+        with pytest.raises(
+            ValueError, match="Argument times must contain numeric values only."
+        ):
+            _ = static_simulation.displacement(times=[0.0, 1, "test"])
+        with pytest.raises(
+            TypeError, match="Argument times must be a number or a list of numbers."
+        ):
+            _ = static_simulation.displacement(times="test")
+
     def test_warning_empty(self, static_simulation):
         with pytest.warns(expected_warning=UserWarning, match="empty"):
             _ = static_simulation.displacement(
@@ -433,6 +447,33 @@ def test_element_nodal_forces_elemental(self, allkindofcomplexity):
 
 
 class TestTransientMechanicalSimulation:
+    def test_times_argument(self, transient_simulation, static_simulation):
+        with pytest.raises(
+            ValueError, match="Could not find time=0.0s in the simulation."
+        ):
+            _ = transient_simulation.displacement(times=0.0)
+
+        # Get reference field at t=0.15s
+        op = transient_simulation._model.operator("UX")
+        time_scoping = core.time_freq_scoping_factory.scoping_by_set(
+            15, server=transient_simulation._model._server
+        )
+        op.connect(0, time_scoping)
+        field_ref = op.eval()[0]
+        # Test for times= exact float
+        result = transient_simulation.displacement(components=["X"], times=0.15)
+        field = result._fc[0]
+        assert np.allclose(field.data, field_ref.data)
+        # Test for times= near float
+        result = transient_simulation.displacement(components=["X"], times=0.1496)
+        field = result._fc[0]
+        assert np.allclose(field.data, field_ref.data)
+        # Test for times= just not near float
+        with pytest.raises(
+            ValueError, match="Could not find time=0.1495s in the simulation."
+        ):
+            _ = transient_simulation.displacement(components=["X"], times=0.1495)
+
     def test_displacement(self, transient_simulation):
         result = transient_simulation.displacement(
             components=["X"],

From 81dc80655f8a5b3629a3373bcd36b11fa1fa882e Mon Sep 17 00:00:00 2001
From: "paul.profizi" <paul.profizi@ansys.com>
Date: Wed, 15 Feb 2023 17:53:18 +0100
Subject: [PATCH 33/33] Reorder and fix all result methods signatures and
 docstrings.

---
 .../dpf/post/static_mechanical_simulation.py  | 1459 ++++++++---------
 .../post/transient_mechanical_simulation.py   | 1267 +++++++-------
 2 files changed, 1288 insertions(+), 1438 deletions(-)

diff --git a/src/ansys/dpf/post/static_mechanical_simulation.py b/src/ansys/dpf/post/static_mechanical_simulation.py
index 2a2291d82..1550f0b5f 100644
--- a/src/ansys/dpf/post/static_mechanical_simulation.py
+++ b/src/ansys/dpf/post/static_mechanical_simulation.py
@@ -194,18 +194,18 @@ def _get_result(
 
     def displacement(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
@@ -218,16 +218,17 @@ def displacement(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements whose nodes to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                Times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -235,14 +236,11 @@ def displacement(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            sub_steps:
-                Sub-steps to get results for. Requires load_steps to be defined.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements whose nodes to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -267,17 +265,16 @@ def displacement(
 
     def stress(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
@@ -285,19 +282,18 @@ def stress(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -305,12 +301,11 @@ def stress(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -327,24 +322,23 @@ def stress(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def stress_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
@@ -352,19 +346,18 @@ def stress_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -372,12 +365,11 @@ def stress_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -394,24 +386,24 @@ def stress_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def stress_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
@@ -424,14 +416,15 @@ def stress_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -439,12 +432,11 @@ def stress_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -468,16 +460,16 @@ def stress_nodal(
 
     def stress_principal(
         self,
-        components: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
+        components: Union[List[str], List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
@@ -485,18 +477,17 @@ def stress_principal(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -504,10 +495,11 @@ def stress_principal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -531,16 +523,16 @@ def stress_principal(
 
     def stress_principal_elemental(
         self,
-        components: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
+        components: Union[List[str], List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
@@ -548,18 +540,17 @@ def stress_principal_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -567,10 +558,11 @@ def stress_principal_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -594,17 +586,17 @@ def stress_principal_elemental(
 
     def stress_principal_nodal(
         self,
-        components: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
+        components: Union[List[str], List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
@@ -617,13 +609,14 @@ def stress_principal_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -631,12 +624,11 @@ def stress_principal_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -660,15 +652,15 @@ def stress_principal_nodal(
 
     def stress_eqv_von_mises(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
@@ -676,16 +668,15 @@ def stress_eqv_von_mises(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -693,10 +684,11 @@ def stress_eqv_von_mises(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -720,15 +712,15 @@ def stress_eqv_von_mises(
 
     def stress_eqv_von_mises_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
@@ -736,16 +728,15 @@ def stress_eqv_von_mises_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -753,10 +744,11 @@ def stress_eqv_von_mises_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -780,16 +772,16 @@ def stress_eqv_von_mises_elemental(
 
     def stress_eqv_von_mises_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
@@ -802,9 +794,10 @@ def stress_eqv_von_mises_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -814,12 +807,11 @@ def stress_eqv_von_mises_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -843,17 +835,16 @@ def stress_eqv_von_mises_nodal(
 
     def elastic_strain(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -861,19 +852,18 @@ def elastic_strain(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -881,12 +871,11 @@ def elastic_strain(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -903,24 +892,24 @@ def elastic_strain(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def elastic_strain_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -933,14 +922,15 @@ def elastic_strain_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -948,12 +938,11 @@ def elastic_strain_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -977,17 +966,16 @@ def elastic_strain_nodal(
 
     def elastic_strain_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -995,19 +983,18 @@ def elastic_strain_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1015,12 +1002,11 @@ def elastic_strain_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1037,23 +1023,23 @@ def elastic_strain_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def elastic_strain_principal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
@@ -1061,18 +1047,17 @@ def elastic_strain_principal(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1080,10 +1065,11 @@ def elastic_strain_principal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1107,17 +1093,17 @@ def elastic_strain_principal(
 
     def elastic_strain_principal_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
@@ -1130,13 +1116,14 @@ def elastic_strain_principal_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1144,12 +1131,11 @@ def elastic_strain_principal_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1173,16 +1159,16 @@ def elastic_strain_principal_nodal(
 
     def elastic_strain_principal_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
@@ -1190,18 +1176,17 @@ def elastic_strain_principal_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1209,10 +1194,11 @@ def elastic_strain_principal_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1236,15 +1222,15 @@ def elastic_strain_principal_elemental(
 
     def plastic_state_variable(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
@@ -1252,16 +1238,15 @@ def plastic_state_variable(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1269,10 +1254,11 @@ def plastic_state_variable(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1296,15 +1282,15 @@ def plastic_state_variable(
 
     def plastic_state_variable_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
@@ -1312,16 +1298,15 @@ def plastic_state_variable_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1329,10 +1314,11 @@ def plastic_state_variable_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1356,16 +1342,16 @@ def plastic_state_variable_elemental(
 
     def plastic_state_variable_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
@@ -1378,9 +1364,10 @@ def plastic_state_variable_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -1390,12 +1377,11 @@ def plastic_state_variable_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1419,17 +1405,16 @@ def plastic_state_variable_nodal(
 
     def plastic_strain(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
@@ -1437,19 +1422,18 @@ def plastic_strain(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1457,12 +1441,11 @@ def plastic_strain(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1479,24 +1462,24 @@ def plastic_strain(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def plastic_strain_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
@@ -1509,14 +1492,15 @@ def plastic_strain_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1524,12 +1508,11 @@ def plastic_strain_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1553,17 +1536,16 @@ def plastic_strain_nodal(
 
     def plastic_strain_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
@@ -1571,19 +1553,18 @@ def plastic_strain_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1591,12 +1572,11 @@ def plastic_strain_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1613,23 +1593,23 @@ def plastic_strain_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def plastic_strain_principal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
@@ -1637,18 +1617,17 @@ def plastic_strain_principal(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1656,10 +1635,11 @@ def plastic_strain_principal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1683,17 +1663,17 @@ def plastic_strain_principal(
 
     def plastic_strain_principal_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
@@ -1706,13 +1686,14 @@ def plastic_strain_principal_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1720,12 +1701,11 @@ def plastic_strain_principal_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1749,16 +1729,16 @@ def plastic_strain_principal_nodal(
 
     def plastic_strain_principal_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
@@ -1766,18 +1746,17 @@ def plastic_strain_principal_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1785,10 +1764,11 @@ def plastic_strain_principal_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1812,15 +1792,15 @@ def plastic_strain_principal_elemental(
 
     def plastic_strain_eqv(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
@@ -1828,16 +1808,15 @@ def plastic_strain_eqv(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1845,10 +1824,11 @@ def plastic_strain_eqv(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1872,16 +1852,16 @@ def plastic_strain_eqv(
 
     def plastic_strain_eqv_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
@@ -1894,9 +1874,10 @@ def plastic_strain_eqv_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -1906,12 +1887,11 @@ def plastic_strain_eqv_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1935,15 +1915,15 @@ def plastic_strain_eqv_nodal(
 
     def plastic_strain_eqv_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
@@ -1951,16 +1931,15 @@ def plastic_strain_eqv_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1968,10 +1947,11 @@ def plastic_strain_eqv_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1995,17 +1975,16 @@ def plastic_strain_eqv_elemental(
 
     def creep_strain(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal creep strain results from the simulation.
 
@@ -2013,19 +1992,18 @@ def creep_strain(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2033,12 +2011,11 @@ def creep_strain(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2055,24 +2032,24 @@ def creep_strain(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def creep_strain_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal creep strain results from the simulation.
 
@@ -2085,14 +2062,15 @@ def creep_strain_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2100,12 +2078,11 @@ def creep_strain_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2129,17 +2106,16 @@ def creep_strain_nodal(
 
     def creep_strain_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental creep strain results from the simulation.
 
@@ -2147,19 +2123,18 @@ def creep_strain_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2167,12 +2142,11 @@ def creep_strain_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2189,23 +2163,23 @@ def creep_strain_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def creep_strain_principal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal creep strain results from the simulation.
 
@@ -2213,18 +2187,17 @@ def creep_strain_principal(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2232,10 +2205,11 @@ def creep_strain_principal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2259,17 +2233,17 @@ def creep_strain_principal(
 
     def creep_strain_principal_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal principal creep strain results from the simulation.
 
@@ -2282,13 +2256,14 @@ def creep_strain_principal_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2296,12 +2271,11 @@ def creep_strain_principal_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2325,16 +2299,16 @@ def creep_strain_principal_nodal(
 
     def creep_strain_principal_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental principal creep strain results from the simulation.
 
@@ -2342,18 +2316,17 @@ def creep_strain_principal_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2361,10 +2334,11 @@ def creep_strain_principal_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2388,15 +2362,15 @@ def creep_strain_principal_elemental(
 
     def creep_strain_eqv(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent creep strain results from the simulation.
 
@@ -2404,16 +2378,15 @@ def creep_strain_eqv(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2421,10 +2394,11 @@ def creep_strain_eqv(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2448,16 +2422,16 @@ def creep_strain_eqv(
 
     def creep_strain_equivalent_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent creep strain results from the simulation.
 
@@ -2470,9 +2444,10 @@ def creep_strain_equivalent_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -2482,12 +2457,11 @@ def creep_strain_equivalent_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2511,15 +2485,15 @@ def creep_strain_equivalent_nodal(
 
     def creep_strain_equivalent_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent creep strain results from the simulation.
 
@@ -2527,16 +2501,15 @@ def creep_strain_equivalent_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2544,10 +2517,11 @@ def creep_strain_equivalent_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2571,18 +2545,18 @@ def creep_strain_equivalent_elemental(
 
     def reaction_force(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
@@ -2595,16 +2569,17 @@ def reaction_force(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2612,12 +2587,11 @@ def reaction_force(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2642,15 +2616,15 @@ def reaction_force(
 
     def elemental_volume(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
@@ -2658,16 +2632,15 @@ def elemental_volume(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2675,10 +2648,11 @@ def elemental_volume(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2702,15 +2676,15 @@ def elemental_volume(
 
     def elemental_mass(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
@@ -2718,16 +2692,15 @@ def elemental_mass(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2735,10 +2708,11 @@ def elemental_mass(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2762,15 +2736,15 @@ def elemental_mass(
 
     def elemental_heat_generation(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
@@ -2778,16 +2752,15 @@ def elemental_heat_generation(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2795,10 +2768,11 @@ def elemental_heat_generation(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2822,15 +2796,15 @@ def elemental_heat_generation(
 
     def element_centroids(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
@@ -2838,16 +2812,15 @@ def element_centroids(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2855,10 +2828,11 @@ def element_centroids(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2882,15 +2856,15 @@ def element_centroids(
 
     def thickness(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
@@ -2898,16 +2872,15 @@ def thickness(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2915,10 +2888,11 @@ def thickness(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2942,15 +2916,15 @@ def thickness(
 
     def element_orientations(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
@@ -2958,16 +2932,15 @@ def element_orientations(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2975,10 +2948,11 @@ def element_orientations(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3002,15 +2976,15 @@ def element_orientations(
 
     def element_orientations_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
@@ -3018,16 +2992,15 @@ def element_orientations_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3035,10 +3008,11 @@ def element_orientations_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3062,16 +3036,16 @@ def element_orientations_elemental(
 
     def element_orientations_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
@@ -3084,9 +3058,10 @@ def element_orientations_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3096,12 +3071,11 @@ def element_orientations_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3125,16 +3099,15 @@ def element_orientations_nodal(
 
     def stiffness_matrix_energy(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract stiffness matrix energy results from the simulation.
 
@@ -3142,14 +3115,13 @@ def stiffness_matrix_energy(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3159,12 +3131,11 @@ def stiffness_matrix_energy(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3181,23 +3152,22 @@ def stiffness_matrix_energy(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def artificial_hourglass_energy(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
@@ -3205,14 +3175,13 @@ def artificial_hourglass_energy(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3222,12 +3191,11 @@ def artificial_hourglass_energy(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3244,23 +3212,22 @@ def artificial_hourglass_energy(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def thermal_dissipation_energy(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
@@ -3268,14 +3235,13 @@ def thermal_dissipation_energy(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3285,12 +3251,11 @@ def thermal_dissipation_energy(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3307,23 +3272,22 @@ def thermal_dissipation_energy(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def kinetic_energy(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
@@ -3331,14 +3295,13 @@ def kinetic_energy(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3348,12 +3311,11 @@ def kinetic_energy(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3370,23 +3332,22 @@ def kinetic_energy(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def hydrostatic_pressure(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
@@ -3394,14 +3355,13 @@ def hydrostatic_pressure(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3411,12 +3371,11 @@ def hydrostatic_pressure(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3433,23 +3392,23 @@ def hydrostatic_pressure(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def hydrostatic_pressure_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
@@ -3462,9 +3421,10 @@ def hydrostatic_pressure_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3474,12 +3434,11 @@ def hydrostatic_pressure_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3503,16 +3462,15 @@ def hydrostatic_pressure_nodal(
 
     def hydrostatic_pressure_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
@@ -3520,14 +3478,13 @@ def hydrostatic_pressure_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3537,12 +3494,11 @@ def hydrostatic_pressure_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3559,23 +3515,22 @@ def hydrostatic_pressure_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def structural_temperature(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
@@ -3583,14 +3538,13 @@ def structural_temperature(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3600,12 +3554,11 @@ def structural_temperature(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3622,23 +3575,23 @@ def structural_temperature(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def structural_temperature_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
@@ -3651,9 +3604,10 @@ def structural_temperature_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3663,12 +3617,11 @@ def structural_temperature_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3692,16 +3645,15 @@ def structural_temperature_nodal(
 
     def structural_temperature_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
@@ -3709,14 +3661,13 @@ def structural_temperature_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
                 List of times to get results for.
             set_ids:
@@ -3726,12 +3677,11 @@ def structural_temperature_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3748,25 +3698,24 @@ def structural_temperature_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def element_nodal_forces(
         self,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
@@ -3774,21 +3723,20 @@ def element_nodal_forces(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3796,12 +3744,11 @@ def element_nodal_forces(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3819,25 +3766,25 @@ def element_nodal_forces(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def element_nodal_forces_nodal(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
@@ -3850,16 +3797,17 @@ def element_nodal_forces_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3867,12 +3815,11 @@ def element_nodal_forces_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3897,17 +3844,17 @@ def element_nodal_forces_nodal(
 
     def element_nodal_forces_elemental(
         self,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
@@ -3915,21 +3862,20 @@ def element_nodal_forces_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3937,10 +3883,11 @@ def element_nodal_forces_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
-            named_selection:
-                Named selection to get results for.
+            named_selections:
+                Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3965,18 +3912,18 @@ def element_nodal_forces_elemental(
 
     def nodal_force(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
@@ -3989,16 +3936,17 @@ def nodal_force(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements whose nodes to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                Times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -4006,14 +3954,11 @@ def nodal_force(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            sub_steps:
-                Sub-steps to get results for. Requires load_steps to be defined.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements whose nodes to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -4038,18 +3983,18 @@ def nodal_force(
 
     def nodal_moment(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
@@ -4062,16 +4007,17 @@ def nodal_moment(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements whose nodes to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-            times:
-                Times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -4079,14 +4025,11 @@ def nodal_moment(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            sub_steps:
-                Sub-steps to get results for. Requires load_steps to be defined.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of elements whose nodes to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
diff --git a/src/ansys/dpf/post/transient_mechanical_simulation.py b/src/ansys/dpf/post/transient_mechanical_simulation.py
index 49584bd9b..1931db0cb 100644
--- a/src/ansys/dpf/post/transient_mechanical_simulation.py
+++ b/src/ansys/dpf/post/transient_mechanical_simulation.py
@@ -195,18 +195,18 @@ def _get_result(
 
     def displacement(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract displacement results from the simulation.
 
@@ -219,17 +219,17 @@ def displacement(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements whose nodes to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                Times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -237,12 +237,11 @@ def displacement(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of element whose nodes to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -267,18 +266,18 @@ def displacement(
 
     def velocity(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract velocity results from the simulation.
 
@@ -291,17 +290,17 @@ def velocity(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements whose nodes to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                Times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -309,12 +308,11 @@ def velocity(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of element whose nodes to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -339,18 +337,18 @@ def velocity(
 
     def acceleration(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract acceleration results from the simulation.
 
@@ -363,17 +361,17 @@ def acceleration(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements whose nodes to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                Times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -381,12 +379,11 @@ def acceleration(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of element whose nodes to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -411,17 +408,16 @@ def acceleration(
 
     def stress(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal stress results from the simulation.
 
@@ -429,20 +425,20 @@ def stress(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -450,12 +446,11 @@ def stress(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -472,24 +467,23 @@ def stress(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def stress_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental stress results from the simulation.
 
@@ -497,20 +491,18 @@ def stress_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -518,12 +510,11 @@ def stress_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -540,24 +531,24 @@ def stress_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def stress_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal stress results from the simulation.
 
@@ -570,15 +561,15 @@ def stress_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -586,12 +577,11 @@ def stress_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -615,16 +605,16 @@ def stress_nodal(
 
     def stress_principal(
         self,
-        components: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
+        components: Union[List[str], List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal stress results from the simulation.
 
@@ -632,19 +622,17 @@ def stress_principal(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -652,10 +640,11 @@ def stress_principal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -679,16 +668,16 @@ def stress_principal(
 
     def stress_principal_elemental(
         self,
-        components: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
+        components: Union[List[str], List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental principal stress results from the simulation.
 
@@ -696,19 +685,17 @@ def stress_principal_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -716,10 +703,11 @@ def stress_principal_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -743,17 +731,17 @@ def stress_principal_elemental(
 
     def stress_principal_nodal(
         self,
-        components: Union[List[str], List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
+        components: Union[List[str], List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal principal stress results from the simulation.
 
@@ -766,14 +754,14 @@ def stress_principal_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs pf elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -781,12 +769,11 @@ def stress_principal_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -810,15 +797,15 @@ def stress_principal_nodal(
 
     def stress_eqv_von_mises(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent Von Mises stress results from the simulation.
 
@@ -826,17 +813,15 @@ def stress_eqv_von_mises(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -844,10 +829,11 @@ def stress_eqv_von_mises(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -871,15 +857,15 @@ def stress_eqv_von_mises(
 
     def stress_eqv_von_mises_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent Von Mises stress results from the simulation.
 
@@ -887,17 +873,15 @@ def stress_eqv_von_mises_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -905,10 +889,11 @@ def stress_eqv_von_mises_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -932,16 +917,16 @@ def stress_eqv_von_mises_elemental(
 
     def stress_eqv_von_mises_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent Von Mises stress results from the simulation.
 
@@ -954,12 +939,12 @@ def stress_eqv_von_mises_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -967,12 +952,11 @@ def stress_eqv_von_mises_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -996,17 +980,16 @@ def stress_eqv_von_mises_nodal(
 
     def elastic_strain(
         self,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -1014,20 +997,18 @@ def elastic_strain(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1035,12 +1016,11 @@ def elastic_strain(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1057,24 +1037,24 @@ def elastic_strain(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def elastic_strain_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -1087,15 +1067,15 @@ def elastic_strain_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1103,12 +1083,11 @@ def elastic_strain_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1132,17 +1111,16 @@ def elastic_strain_nodal(
 
     def elastic_strain_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract stress results from the simulation.
 
@@ -1150,20 +1128,18 @@ def elastic_strain_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1171,12 +1147,11 @@ def elastic_strain_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1193,23 +1168,23 @@ def elastic_strain_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def elastic_strain_principal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal elastic strain results from the simulation.
 
@@ -1217,19 +1192,17 @@ def elastic_strain_principal(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1237,10 +1210,11 @@ def elastic_strain_principal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1264,17 +1238,17 @@ def elastic_strain_principal(
 
     def elastic_strain_principal_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal principal elastic strain results from the simulation.
 
@@ -1287,14 +1261,14 @@ def elastic_strain_principal_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs pf elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1302,12 +1276,11 @@ def elastic_strain_principal_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1331,16 +1304,16 @@ def elastic_strain_principal_nodal(
 
     def elastic_strain_principal_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental principal elastic strain results from the simulation.
 
@@ -1348,19 +1321,17 @@ def elastic_strain_principal_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1368,10 +1339,11 @@ def elastic_strain_principal_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1395,15 +1367,15 @@ def elastic_strain_principal_elemental(
 
     def plastic_state_variable(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic state variable results from the simulation.
 
@@ -1411,17 +1383,15 @@ def plastic_state_variable(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1429,10 +1399,11 @@ def plastic_state_variable(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1456,15 +1427,15 @@ def plastic_state_variable(
 
     def plastic_state_variable_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental plastic state variable results from the simulation.
 
@@ -1472,17 +1443,15 @@ def plastic_state_variable_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1490,10 +1459,11 @@ def plastic_state_variable_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1517,16 +1487,16 @@ def plastic_state_variable_elemental(
 
     def plastic_state_variable_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal plastic state variable results from the simulation.
 
@@ -1539,12 +1509,12 @@ def plastic_state_variable_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1552,12 +1522,11 @@ def plastic_state_variable_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1581,17 +1550,16 @@ def plastic_state_variable_nodal(
 
     def plastic_strain(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal plastic strain results from the simulation.
 
@@ -1599,20 +1567,18 @@ def plastic_strain(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1620,12 +1586,11 @@ def plastic_strain(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1642,24 +1607,24 @@ def plastic_strain(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def plastic_strain_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal plastic strain results from the simulation.
 
@@ -1672,15 +1637,15 @@ def plastic_strain_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1688,12 +1653,11 @@ def plastic_strain_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1717,17 +1681,16 @@ def plastic_strain_nodal(
 
     def plastic_strain_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental plastic strain results from the simulation.
 
@@ -1735,20 +1698,18 @@ def plastic_strain_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z", "XX", "XY",
                 "XZ", and their respective equivalents 1, 2, 3, 4, 5, 6.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1756,12 +1717,11 @@ def plastic_strain_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1778,23 +1738,23 @@ def plastic_strain_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def plastic_strain_principal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal principal plastic strain results from the simulation.
 
@@ -1802,19 +1762,17 @@ def plastic_strain_principal(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1822,10 +1780,11 @@ def plastic_strain_principal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1849,17 +1808,17 @@ def plastic_strain_principal(
 
     def plastic_strain_principal_nodal(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal principal plastic strain results from the simulation.
 
@@ -1872,14 +1831,14 @@ def plastic_strain_principal_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs pf elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1887,12 +1846,11 @@ def plastic_strain_principal_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1916,16 +1874,16 @@ def plastic_strain_principal_nodal(
 
     def plastic_strain_principal_elemental(
         self,
-        components: Union[str, List[str], int, List[int], None] = None,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
+        components: Union[str, List[str], int, List[int], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental principal plastic strain results from the simulation.
 
@@ -1933,19 +1891,17 @@ def plastic_strain_principal_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are: 1, 2, and 3.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -1953,10 +1909,11 @@ def plastic_strain_principal_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -1980,15 +1937,15 @@ def plastic_strain_principal_elemental(
 
     def plastic_strain_eqv(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal equivalent plastic strain results from the simulation.
 
@@ -1996,17 +1953,15 @@ def plastic_strain_eqv(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2014,10 +1969,11 @@ def plastic_strain_eqv(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2041,16 +1997,16 @@ def plastic_strain_eqv(
 
     def plastic_strain_eqv_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal equivalent plastic strain results from the simulation.
 
@@ -2063,12 +2019,12 @@ def plastic_strain_eqv_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2076,12 +2032,11 @@ def plastic_strain_eqv_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2105,15 +2060,15 @@ def plastic_strain_eqv_nodal(
 
     def plastic_strain_eqv_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental equivalent plastic strain results from the simulation.
 
@@ -2121,17 +2076,15 @@ def plastic_strain_eqv_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2139,10 +2092,11 @@ def plastic_strain_eqv_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2166,18 +2120,18 @@ def plastic_strain_eqv_elemental(
 
     def reaction_force(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract reaction force results from the simulation.
 
@@ -2190,17 +2144,17 @@ def reaction_force(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2208,12 +2162,11 @@ def reaction_force(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2238,15 +2191,15 @@ def reaction_force(
 
     def elemental_volume(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental volume results from the simulation.
 
@@ -2254,17 +2207,15 @@ def elemental_volume(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2272,10 +2223,11 @@ def elemental_volume(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2299,15 +2251,15 @@ def elemental_volume(
 
     def elemental_mass(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental mass results from the simulation.
 
@@ -2315,17 +2267,15 @@ def elemental_mass(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2333,10 +2283,11 @@ def elemental_mass(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2360,15 +2311,15 @@ def elemental_mass(
 
     def elemental_heat_generation(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental heat generation results from the simulation.
 
@@ -2376,17 +2327,15 @@ def elemental_heat_generation(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2394,10 +2343,11 @@ def elemental_heat_generation(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2421,15 +2371,15 @@ def elemental_heat_generation(
 
     def element_centroids(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element centroids results from the simulation.
 
@@ -2437,17 +2387,15 @@ def element_centroids(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2455,10 +2403,11 @@ def element_centroids(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2482,15 +2431,15 @@ def element_centroids(
 
     def thickness(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element thickness results from the simulation.
 
@@ -2498,17 +2447,15 @@ def thickness(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2516,10 +2463,11 @@ def thickness(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2543,15 +2491,15 @@ def thickness(
 
     def element_orientations(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental nodal element orientations results from the simulation.
 
@@ -2559,17 +2507,15 @@ def element_orientations(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2577,10 +2523,11 @@ def element_orientations(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2604,15 +2551,15 @@ def element_orientations(
 
     def element_orientations_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract elemental element orientations results from the simulation.
 
@@ -2620,17 +2567,15 @@ def element_orientations_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2638,10 +2583,11 @@ def element_orientations_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2665,16 +2611,16 @@ def element_orientations_elemental(
 
     def element_orientations_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal element orientations results from the simulation.
 
@@ -2687,12 +2633,12 @@ def element_orientations_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2700,14 +2646,13 @@ def element_orientations_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
-
-        Returns
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
+
+        Returns
         -------
             Returns a :class:`ansys.dpf.post.data_object.DataObject` instance.
 
@@ -2729,16 +2674,15 @@ def element_orientations_nodal(
 
     def artificial_hourglass_energy(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract artificial hourglass energy results from the simulation.
 
@@ -2746,17 +2690,15 @@ def artificial_hourglass_energy(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2764,12 +2706,11 @@ def artificial_hourglass_energy(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2786,23 +2727,22 @@ def artificial_hourglass_energy(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def thermal_dissipation_energy(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract thermal dissipation energy results from the simulation.
 
@@ -2810,17 +2750,15 @@ def thermal_dissipation_energy(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2828,12 +2766,11 @@ def thermal_dissipation_energy(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2850,23 +2787,22 @@ def thermal_dissipation_energy(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def kinetic_energy(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract kinetic energy results from the simulation.
 
@@ -2874,17 +2810,15 @@ def kinetic_energy(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2892,12 +2826,11 @@ def kinetic_energy(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2914,23 +2847,22 @@ def kinetic_energy(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def hydrostatic_pressure(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure element nodal results from the simulation.
 
@@ -2938,17 +2870,15 @@ def hydrostatic_pressure(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -2956,12 +2886,11 @@ def hydrostatic_pressure(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -2978,23 +2907,23 @@ def hydrostatic_pressure(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def hydrostatic_pressure_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure nodal results from the simulation.
 
@@ -3007,12 +2936,12 @@ def hydrostatic_pressure_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3020,12 +2949,11 @@ def hydrostatic_pressure_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3049,16 +2977,15 @@ def hydrostatic_pressure_nodal(
 
     def hydrostatic_pressure_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract hydrostatic pressure elemental results from the simulation.
 
@@ -3066,17 +2993,15 @@ def hydrostatic_pressure_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3084,12 +3009,11 @@ def hydrostatic_pressure_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3106,23 +3030,22 @@ def hydrostatic_pressure_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def structural_temperature(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract structural temperature element nodal results from the simulation.
 
@@ -3130,17 +3053,15 @@ def structural_temperature(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3148,12 +3069,11 @@ def structural_temperature(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3170,23 +3090,23 @@ def structural_temperature(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def structural_temperature_nodal(
         self,
-        selection: Union[Selection, None] = None,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract structural temperature nodal results from the simulation.
 
@@ -3199,12 +3119,12 @@ def structural_temperature_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3212,12 +3132,11 @@ def structural_temperature_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3241,16 +3160,15 @@ def structural_temperature_nodal(
 
     def structural_temperature_elemental(
         self,
-        selection: Union[Selection, None] = None,
+        element_ids: Union[List[int], None] = None,
         times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract structural temperature elemental results from the simulation.
 
@@ -3258,17 +3176,15 @@ def structural_temperature_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
+            element_ids:
+                List of IDs of elements to get results for.
             times:
-                List of times to get results for.
+                List of time values to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3276,12 +3192,11 @@ def structural_temperature_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3298,25 +3213,24 @@ def structural_temperature_elemental(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def element_nodal_forces(
         self,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element nodal forces results from the simulation.
 
@@ -3324,22 +3238,20 @@ def element_nodal_forces(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3347,12 +3259,11 @@ def element_nodal_forces(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3370,25 +3281,25 @@ def element_nodal_forces(
             set_ids=set_ids,
             all_sets=all_sets,
             load_steps=load_steps,
-            node_ids=node_ids,
+            node_ids=None,
             element_ids=element_ids,
             named_selections=named_selections,
         )
 
     def element_nodal_forces_nodal(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element nodal forces nodal results from the simulation.
 
@@ -3401,17 +3312,17 @@ def element_nodal_forces_nodal(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3419,12 +3330,11 @@ def element_nodal_forces_nodal(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3449,17 +3359,17 @@ def element_nodal_forces_nodal(
 
     def element_nodal_forces_elemental(
         self,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract element nodal forces elemental results from the simulation.
 
@@ -3467,22 +3377,20 @@ def element_nodal_forces_elemental(
         exclusive.
         If none of the above is given, only the last result will be returned.
 
-        Arguments `selection`, `named_selections`, `element_ids`, and `node_ids` are mutually
+        Arguments `selection`, `named_selections`, and `element_ids` are mutually
         exclusive.
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            element_ids:
+                List of IDs of elements to get results for.
+            times:
+                List of time values to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3490,10 +3398,11 @@ def element_nodal_forces_elemental(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            elements:
-                List of elements to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3518,18 +3427,18 @@ def element_nodal_forces_elemental(
 
     def nodal_force(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal force results from the simulation.
 
@@ -3542,17 +3451,17 @@ def nodal_force(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            times:
+                List of time values to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3560,12 +3469,11 @@ def nodal_force(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of element whose nodes to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------
@@ -3590,18 +3498,18 @@ def nodal_force(
 
     def nodal_moment(
         self,
+        node_ids: Union[List[int], None] = None,
+        element_ids: Union[List[int], None] = None,
+        times: Union[float, List[float], None] = None,
         components: Union[str, List[str], int, List[int], None] = None,
         norm: bool = False,
-        selection: Union[Selection, None] = None,
-        times: Union[float, List[float], None] = None,
         set_ids: Union[int, List[int], None] = None,
         all_sets: bool = False,
         load_steps: Union[
             int, List[int], Tuple[int, Union[int, List[int]]], None
         ] = None,
-        node_ids: Union[List[int], None] = None,
-        element_ids: Union[List[int], None] = None,
         named_selections: Union[List[str], str, None] = None,
+        selection: Union[Selection, None] = None,
     ) -> DataObject:
         """Extract nodal moment results from the simulation.
 
@@ -3614,17 +3522,17 @@ def nodal_moment(
         If none of the above is given, results will be extracted for the whole mesh.
 
         Args:
+            node_ids:
+                List of IDs of nodes to get results for.
+            times:
+                List of time values to get results for.
+            element_ids:
+                List of IDs of elements to get results for.
             components:
                 Components to get results for. Available components are "X", "Y", "Z",
                 and their respective equivalents 1, 2, 3.
             norm:
                 Whether to return the norm of the results.
-            selection:
-                Selection to get results for.
-                A Selection defines both spatial and time-like criteria for filtering.
-                It takes precedence over any other filter argument.
-            times:
-                List of times to get results for.
             set_ids:
                 Sets to get results for.
                 A set is defined as a unique combination of {time, load step, sub-step}.
@@ -3632,12 +3540,11 @@ def nodal_moment(
                 Whether to get results for all sets.
             load_steps:
                 Load steps to get results for.
-            node_ids:
-                List of IDs of nodes to get results for.
-            element_ids:
-                List of IDs of element whose nodes to get results for.
             named_selections:
                 Named selection or list of named selections to get results for.
+            selection:
+                Selection to get results for.
+                A Selection defines both spatial and time-like criteria for filtering.
 
         Returns
         -------