Module containing the HarmonicMechanicalSimulation class.

HarmonicMechanicalSimulation

class ansys.dpf.post.harmonic_mechanical_simulation.HarmonicMechanicalSimulation(result_file: PathLike | str | DataSources, server: BaseServer | None = None)

Provides methods for mechanical harmonic simulations.

displacement(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, norm: bool = False, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract displacement results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements whose nodes to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, and their respective equivalents 1, 2, 3.

• norm (bool, default: False) – Whether to return the norm of the results.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

velocity(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, norm: bool = False, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract velocity results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements whose nodes to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, and their respective equivalents 1, 2, 3.

• norm (bool, default: False) – Whether to return the norm of the results.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

acceleration(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, norm: bool = False, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract acceleration results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements whose nodes to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, and their respective equivalents 1, 2, 3.

• norm (bool, default: False) – Whether to return the norm of the results.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

stress(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, location: locations | str = 'ElementalNodal', expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, “XX”, “XY”, “XZ”, and their respective equivalents 1, 2, 3, 4, 5, 6.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• location (Union[locations, str], default: 'ElementalNodal') – Location to extract results at. Available locations are listed in class:post.locations and are: post.locations.nodal, post.locations.elemental, and post.locations.elemental_nodal. Using the default post.locations.elemental_nodal results in a value for every node at each element. Similarly, using post.locations.elemental gives results with one value for each element, while using post.locations.nodal gives results with one value for each node.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

stress_elemental(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract elemental stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, “XX”, “XY”, “XZ”, and their respective equivalents 1, 2, 3, 4, 5, 6.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

stress_nodal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract nodal stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, “XX”, “XY”, “XZ”, and their respective equivalents 1, 2, 3, 4, 5, 6.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

stress_principal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: List[str] | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, location: locations | str = 'ElementalNodal', expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract principal stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[List[str], List[int]]], default: None) – Components to get results for. Available components are: 1, 2, and 3.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• location (Union[locations, str], default: 'ElementalNodal') – Location to extract results at. Available locations are listed in class:post.locations and are: post.locations.nodal, post.locations.elemental, and post.locations.elemental_nodal. Using the default post.locations.elemental_nodal results in a value for every node at each element. Similarly, using post.locations.elemental gives results with one value for each element, while using post.locations.nodal gives results with one value for each node.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

stress_principal_elemental(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: List[str] | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract elemental principal stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[List[str], List[int]]], default: None) – Components to get results for. Available components are: 1, 2, and 3.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

stress_principal_nodal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: List[str] | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract nodal principal stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs pf elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[List[str], List[int]]], default: None) – Components to get results for. Available components are: 1, 2, and 3.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

stress_eqv_von_mises(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, location: locations | str = 'ElementalNodal', expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract equivalent von Mises stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• location (Union[locations, str], default: 'ElementalNodal') – Location to extract results at. Available locations are listed in class:post.locations and are: post.locations.nodal, post.locations.elemental, and post.locations.elemental_nodal. Using the default post.locations.elemental_nodal results in a value for every node at each element. Similarly, using post.locations.elemental gives results with one value for each element, while using post.locations.nodal gives results with one value for each node.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

stress_eqv_von_mises_elemental(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract elemental equivalent von Mises stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

stress_eqv_von_mises_nodal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract nodal equivalent von Mises stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elastic_strain(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, location: locations | str = 'ElementalNodal', expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, “XX”, “XY”, “XZ”, and their respective equivalents 1, 2, 3, 4, 5, 6.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• location (Union[locations, str], default: 'ElementalNodal') – Location to extract results at. Available locations are listed in class:post.locations and are: post.locations.nodal, post.locations.elemental, and post.locations.elemental_nodal. Using the default post.locations.elemental_nodal results in a value for every node at each element. Similarly, using post.locations.elemental gives results with one value for each element, while using post.locations.nodal gives results with one value for each node.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elastic_strain_nodal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, “XX”, “XY”, “XZ”, and their respective equivalents 1, 2, 3, 4, 5, 6.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elastic_strain_elemental(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract stress results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, “XX”, “XY”, “XZ”, and their respective equivalents 1, 2, 3, 4, 5, 6.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elastic_strain_principal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, location: locations | str = 'ElementalNodal', expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract principal elastic strain results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are: 1, 2, and 3.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• location (Union[locations, str], default: 'ElementalNodal') – Location to extract results at. Available locations are listed in class:post.locations and are: post.locations.nodal, post.locations.elemental, and post.locations.elemental_nodal. Using the default post.locations.elemental_nodal results in a value for every node at each element. Similarly, using post.locations.elemental gives results with one value for each element, while using post.locations.nodal gives results with one value for each node.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elastic_strain_principal_nodal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract nodal principal elastic strain results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs pf elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are: 1, 2, and 3.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elastic_strain_principal_elemental(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract elemental principal elastic strain results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are: 1, 2, and 3.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elastic_strain_eqv_von_mises(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, location: locations | str = 'ElementalNodal', expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract equivalent von Mises elastic strain results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• location (Union[locations, str], default: 'ElementalNodal') – Location to extract results at. Available locations are listed in class:post.locations and are: post.locations.nodal, post.locations.elemental, and post.locations.elemental_nodal. Using the default post.locations.elemental_nodal results in a value for every node at each element. Similarly, using post.locations.elemental gives results with one value for each element, while using post.locations.nodal gives results with one value for each node.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elastic_strain_eqv_von_mises_elemental(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract elemental equivalent von Mises elastic strain results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elastic_strain_eqv_von_mises_nodal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract nodal equivalent von Mises elastic strain results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

reaction_force(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, norm: bool = False, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract reaction force results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, and their respective equivalents 1, 2, 3.

• norm (bool, default: False) – Whether to return the norm of the results.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elemental_volume(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract elemental volume results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

elemental_mass(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract elemental mass results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

element_nodal_forces(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, norm: bool = False, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, location: locations | str = 'ElementalNodal', expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract element nodal forces results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, and their respective equivalents 1, 2, 3.

• norm (bool, default: False) – Whether to return the norm of the results.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• location (Union[locations, str], default: 'ElementalNodal') – Location to extract results at. Available locations are listed in class:post.locations and are: post.locations.nodal, post.locations.elemental, and post.locations.elemental_nodal. Using the default post.locations.elemental_nodal results in a value for every node at each element. Similarly, using post.locations.elemental gives results with one value for each element, while using post.locations.nodal gives results with one value for each node.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

element_nodal_forces_nodal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, norm: bool = False, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract element nodal forces nodal results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, and their respective equivalents 1, 2, 3.

• norm (bool, default: False) – Whether to return the norm of the results.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

element_nodal_forces_elemental(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, norm: bool = False, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract element nodal forces elemental results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, and their respective equivalents 1, 2, 3.

• norm (bool, default: False) – Whether to return the norm of the results.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

nodal_force(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, norm: bool = False, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract nodal force results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, and their respective equivalents 1, 2, 3.

• norm (bool, default: False) – Whether to return the norm of the results.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

nodal_moment(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, components: str | List[str] | int | List[int] | None = None, norm: bool = False, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract nodal moment results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• components (Optional[Union`[:py:class:`str, List[str], int, List[int]]], default: None) – Components to get results for. Available components are “X”, “Y”, “Z”, and their respective equivalents 1, 2, 3.

• norm (bool, default: False) – Whether to return the norm of the results.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

element_centroids(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract element centroids results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

thickness(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract element thickness results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

element_orientations(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, location: locations | str = 'ElementalNodal', expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract element orientations results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• location (Union[locations, str], default: 'ElementalNodal') – Location to extract results at. Available locations are listed in class:post.locations and are: post.locations.nodal, post.locations.elemental, and post.locations.elemental_nodal. Using the default post.locations.elemental_nodal results in a value for every node at each element. Similarly, using post.locations.elemental gives results with one value for each element, while using post.locations.nodal gives results with one value for each node.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

element_orientations_elemental(element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract elemental element orientations results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency will be returned.

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.

Parameters:

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

element_orientations_nodal(node_ids: List[int] | None = None, element_ids: List[int] | None = None, frequencies: float | List[float] | None = None, set_ids: int | List[int] | None = None, all_sets: bool = False, load_steps: int | List[int] | Tuple[int, int | List[int]] | None = None, named_selections: List[str] | str | None = None, selection: Selection | None = None, expand_cyclic: bool | List[int | List[int]] = True, phase_angle_cyclic: float | None = None, external_layer: bool | List[int] = False, skin: bool | List[int] = False)

Extract nodal element orientations results from the simulation.

Arguments selection, set_ids, all_sets, frequencies, and load_steps are mutually exclusive. If none of the above is given, the last frequency 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.

Parameters:

• node_ids (Optional[List[int]], default: None) – List of IDs of nodes to get results for.

• element_ids (Optional[List[int]], default: None) – List of IDs of elements to get results for.

• frequencies (Optional[Union`[:py:class:`float, List[float]]], default: None) – Frequency value or list of frequency values to get results for.

• set_ids (Optional[Union`[:py:class:`int, List[int]]], default: None) – Sets to get results for. A set is defined as a unique combination of {time, load step, sub-step}.

• all_sets (bool, default: False) – Whether to get results for all sets.

• load_steps (Optional[Union`[:py:class:`int, List[int], Tuple[int, Union[int, List[int]]]]], default: None) – Load step number or list of load step numbers to get results for. One can specify sub-steps of a load step with a tuple of format: (load-step, sub-step number or list of sub-step numbers).

• named_selections (Optional[List[str], str]], default: None) – Named selection or list of named selections to get results for.

• selection (Optional[Selection], default: None) – Selection to get results for. A Selection defines both spatial and time-like criteria for filtering.

• expand_cyclic (Union[bool, List[Union[int, List[int]]]], default: True) – For cyclic problems, whether to expand the sectors. Can take a list of sector numbers to select specific sectors to expand (one-based indexing). If the problem is multi-stage, can take a list of lists of sector numbers, ordered by stage.

• phase_angle_cyclic (Optional[float], default: None) – For cyclic problems, phase angle to apply (in degrees).

• external_layer (Union[bool, List[int]], default: False) – Select the external layer (last layer of solid elements under the skin) of the mesh for plotting and data extraction. If a list is passed, the external layer is computed over list of elements.

• skin (Union[bool, List[int]], default: False) – Select the skin (creates new 2D elements connecting the external nodes) of the mesh for plotting and data extraction. If a list is passed, the skin is computed over list of elements (not supported for cyclic symmetry). Getting the skin on more than one result (several time freq sets, split data…) is only supported starting with Ansys 2023R2.

Return type:

Returns a ansys.dpf.post.data_object.DataFrame instance.

property active_selection: Selection | None

Active selection used by default for result queries.

Returns a :object:`ansys.dpf.post.selection.Selection` object.

Examples

>>> from ansys.dpf import post
>>> from ansys.dpf.post import examples
>>> simulation = post.load_simulation(examples.static_rst)
>>> selection = post.selection.Selection()
>>> simulation.active_selection = selection
>>> print(simulation.active_selection) 
<ansys.dpf.post.selection.Selection object at ...>

deactivate_selection()

Deactivate the currently active selection.

Examples

>>> from ansys.dpf import post
>>> from ansys.dpf.post import examples
>>> simulation = post.load_simulation(examples.static_rst)
>>> selection = post.selection.Selection()
>>> simulation.active_selection = selection
>>> print(simulation.active_selection) 
<ansys.dpf.post.selection.Selection object at ...>
>>> simulation.deactivate_selection()
>>> print(simulation.active_selection) 
None

property geometries

List of constructed geometries in the simulation.

Returns a list of geometry objects.

Examples

>>> from ansys.dpf import post
>>> from ansys.dpf.post import examples
>>> simulation = post.load_simulation(examples.static_rst)
>>> print(simulation.geometries) 
[]

property mesh: Mesh

Mesh representation of the model.

Returns a ansys.dpf.post.mesh.Mesh object.

Examples

>>> from ansys.dpf import post
>>> from ansys.dpf.post import examples
>>> simulation = post.load_simulation(examples.static_rst)
>>> print(simulation.mesh) 
    DPF  Mesh:
      81 nodes
      8 elements
      Unit: m
      With solid (3D) elements

property named_selections: List[str]

List of named selections in the simulation.

Returns a list of named selections names.

Examples

>>> from ansys.dpf import post
>>> from ansys.dpf.post import examples
>>> simulation = post.load_simulation(examples.static_rst)
>>> print(simulation.named_selections) 
['_FIXEDSU']

plot(mesh: bool = True, constructed_geometries: bool = True, loads: bool = True, boundary_conditions: bool = True, **kwargs)

General plot of the simulation object.

Plots by default the complete mesh contained in the simulation, as well as a representation of the constructed geometry, the loads, and the boundary conditions currently defined. Each representation can be deactivated with its respective boolean argument.

Parameters:

• mesh (bool, default: True) – Whether to plot the mesh representation.

• constructed_geometries (bool, default: True) – Whether to plot the constructed geometries.

• loads (bool, default: True) – Whether to plot the loads.

• boundary_conditions (bool, default: True) – Whether to plot the boundary conditions.

• **kwargs – Additional keyword arguments for the plotter. More information are available at pyvista.plot().

Returns:

Returns a plotter instance of the active visualization backend.

Examples

>>> from ansys.dpf import post
>>> from ansys.dpf.post import examples
>>> simulation = post.load_simulation(examples.static_rst)
>>> simulation.plot() 

release_streams()

Release the streams to data files if any is active.

property result_info

Return information concerning the available results.

property results: List[AvailableResult]

Available results.

Returns a list of available results.

Examples

>>> from ansys.dpf import post
>>> from ansys.dpf.post import examples
>>> simulation = post.load_simulation(examples.static_rst)
>>> print(simulation.results) 
[...]

property set_ids: List

Returns the list of set IDs available in the simulation.

split_mesh_by_properties(properties: List[elemental_properties] | Dict[elemental_properties, int | List[int]])

Splits the simulation Mesh according to properties and returns it as Meshes.

Parameters:

properties (Union[List[elemental_properties], Dict[elemental_properties, Union[int, List[int]]]]) – Elemental properties to split the global mesh by. Returns all meshes if a list, or returns only meshes for certain elemental property values if a dict with elemental properties labels with associated value or list of values.

Return type:

A Meshes entity with resulting meshes.

Examples

>>> from ansys.dpf import post
>>> from ansys.dpf.post.common import elemental_properties
>>> from ansys.dpf.post import examples
>>> example_path = examples.download_all_kinds_of_complexity()
>>> simulation = post.StaticMechanicalSimulation(example_path)
>>> # Split by elemental properties and get all resulting meshes
>>> meshes_split = simulation.split_mesh_by_properties(
...     properties=[elemental_properties.material,
...                 elemental_properties.element_shape]
... )
>>> # Split by elemental properties and only get meshes for certain property values
>>> # Here: split by material and shape, return only for material 1 and shapes 0 and 1
>>> meshes_filtered = simulation.split_mesh_by_properties(
...     properties={elemental_properties.material: 1,
...                 elemental_properties.element_shape: [0, 1]}
... )

property time_freq_support: TimeFreqSupport

Description of the temporal/frequency analysis of the model.

property units

Returns the current units used.