Computes the strain from a displacement field.
Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported.
Layered elements are not supported.
Thermal strains are not supported.
diff --git a/src/ansys/dpf/core/operators/result/__init__.py b/src/ansys/dpf/core/operators/result/__init__.py
index f7e38698912..90cd25dd985 100644
--- a/src/ansys/dpf/core/operators/result/__init__.py
+++ b/src/ansys/dpf/core/operators/result/__init__.py
@@ -234,6 +234,10 @@
from .nodal_rotational_velocity_Y import nodal_rotational_velocity_Y
from .nodal_rotational_velocity_Z import nodal_rotational_velocity_Z
from .nodal_to_global import nodal_to_global
+from .node_orientations import node_orientations
+from .node_orientations_X import node_orientations_X
+from .node_orientations_Y import node_orientations_Y
+from .node_orientations_Z import node_orientations_Z
from .normal_contact_force import normal_contact_force
from .normal_contact_moment import normal_contact_moment
from .num_surface_status_changes import num_surface_status_changes
diff --git a/src/ansys/dpf/core/operators/result/node_orientations.py b/src/ansys/dpf/core/operators/result/node_orientations.py
new file mode 100644
index 00000000000..35f5c1bf810
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/node_orientations.py
@@ -0,0 +1,453 @@
+"""
+node_orientations
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+from ansys.dpf.core.config import Config
+from ansys.dpf.core.server_types import AnyServerType
+
+
+class node_orientations(Operator):
+ r"""Read/compute node euler angles by calling the readers defined by the
+ datasources.
+
+
+ Parameters
+ ----------
+ time_scoping: Scoping or int or float or Field, optional
+ time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.
+ mesh_scoping: ScopingsContainer or Scoping, optional
+ nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains
+ fields_container: FieldsContainer, optional
+ Fields container already allocated modified inplace
+ streams_container: StreamsContainer, optional
+ result file container allowed to be kept open to cache data
+ data_sources: DataSources
+ result file path container, used if no streams are set
+ bool_rotate_to_global: bool, optional
+ if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.
+ mesh: MeshedRegion or MeshesContainer, optional
+ prevents from reading the mesh in the result files
+
+ Returns
+ -------
+ fields_container: FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.node_orientations()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.node_orientations(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EUL_NOD", config=config, server=server)
+ self._inputs = InputsNodeOrientations(self)
+ self._outputs = OutputsNodeOrientations(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+
+ @staticmethod
+ def _spec() -> Specification:
+ description = r"""Read/compute node euler angles by calling the readers defined by the
+datasources.
+"""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document=r"""time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document=r"""nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document=r"""Fields container already allocated modified inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document=r"""result file container allowed to be kept open to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document=r"""result file path container, used if no streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document=r"""if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document=r"""prevents from reading the mesh in the result files""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document=r"""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server: AnyServerType = None) -> Config:
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server:
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+
+ Returns
+ -------
+ config:
+ A new Config instance equivalent to the default config for this operator.
+ """
+ return Operator.default_config(name="EUL_NOD", server=server)
+
+ @property
+ def inputs(self) -> InputsNodeOrientations:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodeOrientations.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodeOrientations:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodeOrientations.
+ """
+ return super().outputs
+
+
+class InputsNodeOrientations(_Inputs):
+ """Intermediate class used to connect user inputs to
+ node_orientations operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(node_orientations._spec().inputs, op)
+ self._time_scoping = Input(node_orientations._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(node_orientations._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ node_orientations._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ node_orientations._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(node_orientations._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ node_orientations._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(node_orientations._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+
+ @property
+ def time_scoping(self) -> Input:
+ r"""Allows to connect time_scoping input to the operator.
+
+ time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self) -> Input:
+ r"""Allows to connect mesh_scoping input to the operator.
+
+ nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self) -> Input:
+ r"""Allows to connect fields_container input to the operator.
+
+ Fields container already allocated modified inplace
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self) -> Input:
+ r"""Allows to connect streams_container input to the operator.
+
+ result file container allowed to be kept open to cache data
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self) -> Input:
+ r"""Allows to connect data_sources input to the operator.
+
+ result file path container, used if no streams are set
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self) -> Input:
+ r"""Allows to connect bool_rotate_to_global input to the operator.
+
+ if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self) -> Input:
+ r"""Allows to connect mesh input to the operator.
+
+ prevents from reading the mesh in the result files
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+
+class OutputsNodeOrientations(_Outputs):
+ """Intermediate class used to get outputs from
+ node_orientations operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(node_orientations._spec().outputs, op)
+ self._fields_container = Output(node_orientations._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self) -> Output:
+ r"""Allows to get fields_container output of the operator
+
+ Returns
+ -------
+ output:
+ An Output instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations()
+ >>> # Get the output from op.outputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/node_orientations_X.py b/src/ansys/dpf/core/operators/result/node_orientations_X.py
new file mode 100644
index 00000000000..adf62119bd4
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/node_orientations_X.py
@@ -0,0 +1,494 @@
+"""
+node_orientations_X
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+from ansys.dpf.core.config import Config
+from ansys.dpf.core.server_types import AnyServerType
+
+
+class node_orientations_X(Operator):
+ r"""Read/compute node euler angles X component of the vector (1st component)
+ by calling the readers defined by the datasources.
+
+
+ Parameters
+ ----------
+ time_scoping: Scoping or int or float or Field, optional
+ time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.
+ mesh_scoping: ScopingsContainer or Scoping, optional
+ nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains
+ fields_container: FieldsContainer, optional
+ FieldsContainer already allocated modified inplace
+ streams_container: StreamsContainer, optional
+ result file container allowed to be kept open to cache data
+ data_sources: DataSources
+ result file path container, used if no streams are set
+ bool_rotate_to_global: bool, optional
+ if true the field is rotated to global coordinate system (default true)
+ mesh: MeshedRegion or MeshesContainer, optional
+ prevents from reading the mesh in the result files
+ read_cyclic: int, optional
+ if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1)
+
+ Returns
+ -------
+ fields_container: FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.node_orientations_X()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.node_orientations_X(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... read_cyclic=my_read_cyclic,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ read_cyclic=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EUL_NODX", config=config, server=server)
+ self._inputs = InputsNodeOrientationsX(self)
+ self._outputs = OutputsNodeOrientationsX(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+
+ @staticmethod
+ def _spec() -> Specification:
+ description = r"""Read/compute node euler angles X component of the vector (1st component)
+by calling the readers defined by the datasources.
+"""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document=r"""time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document=r"""nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document=r"""FieldsContainer already allocated modified inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document=r"""result file container allowed to be kept open to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document=r"""result file path container, used if no streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document=r"""if true the field is rotated to global coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document=r"""prevents from reading the mesh in the result files""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document=r"""if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document=r"""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server: AnyServerType = None) -> Config:
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server:
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+
+ Returns
+ -------
+ config:
+ A new Config instance equivalent to the default config for this operator.
+ """
+ return Operator.default_config(name="EUL_NODX", server=server)
+
+ @property
+ def inputs(self) -> InputsNodeOrientationsX:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodeOrientationsX.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodeOrientationsX:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodeOrientationsX.
+ """
+ return super().outputs
+
+
+class InputsNodeOrientationsX(_Inputs):
+ """Intermediate class used to connect user inputs to
+ node_orientations_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(node_orientations_X._spec().inputs, op)
+ self._time_scoping = Input(node_orientations_X._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(node_orientations_X._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ node_orientations_X._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ node_orientations_X._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(node_orientations_X._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ node_orientations_X._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(node_orientations_X._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(node_orientations_X._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+
+ @property
+ def time_scoping(self) -> Input:
+ r"""Allows to connect time_scoping input to the operator.
+
+ time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self) -> Input:
+ r"""Allows to connect mesh_scoping input to the operator.
+
+ nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self) -> Input:
+ r"""Allows to connect fields_container input to the operator.
+
+ FieldsContainer already allocated modified inplace
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self) -> Input:
+ r"""Allows to connect streams_container input to the operator.
+
+ result file container allowed to be kept open to cache data
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self) -> Input:
+ r"""Allows to connect data_sources input to the operator.
+
+ result file path container, used if no streams are set
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self) -> Input:
+ r"""Allows to connect bool_rotate_to_global input to the operator.
+
+ if true the field is rotated to global coordinate system (default true)
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self) -> Input:
+ r"""Allows to connect mesh input to the operator.
+
+ prevents from reading the mesh in the result files
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def read_cyclic(self) -> Input:
+ r"""Allows to connect read_cyclic input to the operator.
+
+ if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1)
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodeOrientationsX(_Outputs):
+ """Intermediate class used to get outputs from
+ node_orientations_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(node_orientations_X._spec().outputs, op)
+ self._fields_container = Output(
+ node_orientations_X._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self) -> Output:
+ r"""Allows to get fields_container output of the operator
+
+ Returns
+ -------
+ output:
+ An Output instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_X()
+ >>> # Get the output from op.outputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/node_orientations_Y.py b/src/ansys/dpf/core/operators/result/node_orientations_Y.py
new file mode 100644
index 00000000000..f2485d07199
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/node_orientations_Y.py
@@ -0,0 +1,494 @@
+"""
+node_orientations_Y
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+from ansys.dpf.core.config import Config
+from ansys.dpf.core.server_types import AnyServerType
+
+
+class node_orientations_Y(Operator):
+ r"""Read/compute node euler angles Y component of the vector (2nd component)
+ by calling the readers defined by the datasources.
+
+
+ Parameters
+ ----------
+ time_scoping: Scoping or int or float or Field, optional
+ time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.
+ mesh_scoping: ScopingsContainer or Scoping, optional
+ nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains
+ fields_container: FieldsContainer, optional
+ FieldsContainer already allocated modified inplace
+ streams_container: StreamsContainer, optional
+ result file container allowed to be kept open to cache data
+ data_sources: DataSources
+ result file path container, used if no streams are set
+ bool_rotate_to_global: bool, optional
+ if true the field is rotated to global coordinate system (default true)
+ mesh: MeshedRegion or MeshesContainer, optional
+ prevents from reading the mesh in the result files
+ read_cyclic: int, optional
+ if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1)
+
+ Returns
+ -------
+ fields_container: FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.node_orientations_Y()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.node_orientations_Y(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... read_cyclic=my_read_cyclic,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ read_cyclic=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EUL_NODY", config=config, server=server)
+ self._inputs = InputsNodeOrientationsY(self)
+ self._outputs = OutputsNodeOrientationsY(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+
+ @staticmethod
+ def _spec() -> Specification:
+ description = r"""Read/compute node euler angles Y component of the vector (2nd component)
+by calling the readers defined by the datasources.
+"""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document=r"""time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document=r"""nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document=r"""FieldsContainer already allocated modified inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document=r"""result file container allowed to be kept open to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document=r"""result file path container, used if no streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document=r"""if true the field is rotated to global coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document=r"""prevents from reading the mesh in the result files""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document=r"""if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document=r"""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server: AnyServerType = None) -> Config:
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server:
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+
+ Returns
+ -------
+ config:
+ A new Config instance equivalent to the default config for this operator.
+ """
+ return Operator.default_config(name="EUL_NODY", server=server)
+
+ @property
+ def inputs(self) -> InputsNodeOrientationsY:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodeOrientationsY.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodeOrientationsY:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodeOrientationsY.
+ """
+ return super().outputs
+
+
+class InputsNodeOrientationsY(_Inputs):
+ """Intermediate class used to connect user inputs to
+ node_orientations_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(node_orientations_Y._spec().inputs, op)
+ self._time_scoping = Input(node_orientations_Y._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(node_orientations_Y._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ node_orientations_Y._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ node_orientations_Y._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(node_orientations_Y._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ node_orientations_Y._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(node_orientations_Y._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(node_orientations_Y._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+
+ @property
+ def time_scoping(self) -> Input:
+ r"""Allows to connect time_scoping input to the operator.
+
+ time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self) -> Input:
+ r"""Allows to connect mesh_scoping input to the operator.
+
+ nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self) -> Input:
+ r"""Allows to connect fields_container input to the operator.
+
+ FieldsContainer already allocated modified inplace
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self) -> Input:
+ r"""Allows to connect streams_container input to the operator.
+
+ result file container allowed to be kept open to cache data
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self) -> Input:
+ r"""Allows to connect data_sources input to the operator.
+
+ result file path container, used if no streams are set
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self) -> Input:
+ r"""Allows to connect bool_rotate_to_global input to the operator.
+
+ if true the field is rotated to global coordinate system (default true)
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self) -> Input:
+ r"""Allows to connect mesh input to the operator.
+
+ prevents from reading the mesh in the result files
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def read_cyclic(self) -> Input:
+ r"""Allows to connect read_cyclic input to the operator.
+
+ if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1)
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodeOrientationsY(_Outputs):
+ """Intermediate class used to get outputs from
+ node_orientations_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(node_orientations_Y._spec().outputs, op)
+ self._fields_container = Output(
+ node_orientations_Y._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self) -> Output:
+ r"""Allows to get fields_container output of the operator
+
+ Returns
+ -------
+ output:
+ An Output instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Y()
+ >>> # Get the output from op.outputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/node_orientations_Z.py b/src/ansys/dpf/core/operators/result/node_orientations_Z.py
new file mode 100644
index 00000000000..e345523bfc3
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/node_orientations_Z.py
@@ -0,0 +1,494 @@
+"""
+node_orientations_Z
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+from ansys.dpf.core.config import Config
+from ansys.dpf.core.server_types import AnyServerType
+
+
+class node_orientations_Z(Operator):
+ r"""Read/compute node euler angles Z component of the vector (3rd component)
+ by calling the readers defined by the datasources.
+
+
+ Parameters
+ ----------
+ time_scoping: Scoping or int or float or Field, optional
+ time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.
+ mesh_scoping: ScopingsContainer or Scoping, optional
+ nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains
+ fields_container: FieldsContainer, optional
+ FieldsContainer already allocated modified inplace
+ streams_container: StreamsContainer, optional
+ result file container allowed to be kept open to cache data
+ data_sources: DataSources
+ result file path container, used if no streams are set
+ bool_rotate_to_global: bool, optional
+ if true the field is rotated to global coordinate system (default true)
+ mesh: MeshedRegion or MeshesContainer, optional
+ prevents from reading the mesh in the result files
+ read_cyclic: int, optional
+ if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1)
+
+ Returns
+ -------
+ fields_container: FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.node_orientations_Z()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.node_orientations_Z(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... read_cyclic=my_read_cyclic,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ read_cyclic=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EUL_NODZ", config=config, server=server)
+ self._inputs = InputsNodeOrientationsZ(self)
+ self._outputs = OutputsNodeOrientationsZ(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+
+ @staticmethod
+ def _spec() -> Specification:
+ description = r"""Read/compute node euler angles Z component of the vector (3rd component)
+by calling the readers defined by the datasources.
+"""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document=r"""time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document=r"""nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document=r"""FieldsContainer already allocated modified inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document=r"""result file container allowed to be kept open to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document=r"""result file path container, used if no streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document=r"""if true the field is rotated to global coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document=r"""prevents from reading the mesh in the result files""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document=r"""if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document=r"""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server: AnyServerType = None) -> Config:
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server:
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+
+ Returns
+ -------
+ config:
+ A new Config instance equivalent to the default config for this operator.
+ """
+ return Operator.default_config(name="EUL_NODZ", server=server)
+
+ @property
+ def inputs(self) -> InputsNodeOrientationsZ:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodeOrientationsZ.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodeOrientationsZ:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodeOrientationsZ.
+ """
+ return super().outputs
+
+
+class InputsNodeOrientationsZ(_Inputs):
+ """Intermediate class used to connect user inputs to
+ node_orientations_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(node_orientations_Z._spec().inputs, op)
+ self._time_scoping = Input(node_orientations_Z._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(node_orientations_Z._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ node_orientations_Z._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ node_orientations_Z._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(node_orientations_Z._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ node_orientations_Z._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(node_orientations_Z._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(node_orientations_Z._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+
+ @property
+ def time_scoping(self) -> Input:
+ r"""Allows to connect time_scoping input to the operator.
+
+ time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self) -> Input:
+ r"""Allows to connect mesh_scoping input to the operator.
+
+ nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self) -> Input:
+ r"""Allows to connect fields_container input to the operator.
+
+ FieldsContainer already allocated modified inplace
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self) -> Input:
+ r"""Allows to connect streams_container input to the operator.
+
+ result file container allowed to be kept open to cache data
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self) -> Input:
+ r"""Allows to connect data_sources input to the operator.
+
+ result file path container, used if no streams are set
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self) -> Input:
+ r"""Allows to connect bool_rotate_to_global input to the operator.
+
+ if true the field is rotated to global coordinate system (default true)
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self) -> Input:
+ r"""Allows to connect mesh input to the operator.
+
+ prevents from reading the mesh in the result files
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def read_cyclic(self) -> Input:
+ r"""Allows to connect read_cyclic input to the operator.
+
+ if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1)
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodeOrientationsZ(_Outputs):
+ """Intermediate class used to get outputs from
+ node_orientations_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(node_orientations_Z._spec().outputs, op)
+ self._fields_container = Output(
+ node_orientations_Z._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self) -> Output:
+ r"""Allows to get fields_container output of the operator
+
+ Returns
+ -------
+ output:
+ An Output instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.node_orientations_Z()
+ >>> # Get the output from op.outputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+ return self._fields_container
diff --git a/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll b/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll
index 0d4a92e04a10f6f3c46dcc259e4ac29bcb22c7e1..57677223fd73a8e0de88347fcedbc2eca9cf3e78 100644
GIT binary patch
delta 3981188
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