| | | result file path container, used if no streams are set
diff --git a/src/ansys/dpf/core/operators/result/__init__.py b/src/ansys/dpf/core/operators/result/__init__.py
index 0c78f968687..f5fb0468fe6 100644
--- a/src/ansys/dpf/core/operators/result/__init__.py
+++ b/src/ansys/dpf/core/operators/result/__init__.py
@@ -214,6 +214,18 @@
from .nmisc import nmisc
from .nodal_force import nodal_force
from .nodal_moment import nodal_moment
+from .nodal_rotational_acceleration import nodal_rotational_acceleration
+from .nodal_rotational_acceleration_X import nodal_rotational_acceleration_X
+from .nodal_rotational_acceleration_Y import nodal_rotational_acceleration_Y
+from .nodal_rotational_acceleration_Z import nodal_rotational_acceleration_Z
+from .nodal_rotational_velocity import nodal_rotational_velocity
+from .nodal_rotational_velocity_X import nodal_rotational_velocity_X
+from .nodal_rotational_velocity_Y import nodal_rotational_velocity_Y
+from .nodal_rotational_velocity_Z import nodal_rotational_velocity_Z
+from .nodal_rotations import nodal_rotations
+from .nodal_rotations_X import nodal_rotations_X
+from .nodal_rotations_Y import nodal_rotations_Y
+from .nodal_rotations_Z import nodal_rotations_Z
from .nodal_to_global import nodal_to_global
from .normal_contact_force import normal_contact_force
from .normal_contact_moment import normal_contact_moment
diff --git a/src/ansys/dpf/core/operators/result/nodal_rotational_acceleration.py b/src/ansys/dpf/core/operators/result/nodal_rotational_acceleration.py
new file mode 100644
index 00000000000..344ba7de7c6
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotational_acceleration.py
@@ -0,0 +1,463 @@
+"""
+nodal_rotational_acceleration
+
+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 nodal_rotational_acceleration(Operator):
+ r"""Read/compute nodal rotational acceleration 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.nodal_rotational_acceleration()
+
+ >>> # 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.nodal_rotational_acceleration(
+ ... 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="DMG", config=config, server=server)
+ self._inputs = InputsNodalRotationalAcceleration(self)
+ self._outputs = OutputsNodalRotationalAcceleration(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 nodal rotational acceleration 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="DMG", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationalAcceleration:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationalAcceleration.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationalAcceleration:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationalAcceleration.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationalAcceleration(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotational_acceleration operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_acceleration()
+ >>> 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__(nodal_rotational_acceleration._spec().inputs, op)
+ self._time_scoping = Input(
+ nodal_rotational_acceleration._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ nodal_rotational_acceleration._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotational_acceleration._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotational_acceleration._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ nodal_rotational_acceleration._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotational_acceleration._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(
+ nodal_rotational_acceleration._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.nodal_rotational_acceleration()
+ >>> 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.nodal_rotational_acceleration()
+ >>> 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.nodal_rotational_acceleration()
+ >>> 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.nodal_rotational_acceleration()
+ >>> 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.nodal_rotational_acceleration()
+ >>> 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.nodal_rotational_acceleration()
+ >>> 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.nodal_rotational_acceleration()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+
+class OutputsNodalRotationalAcceleration(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotational_acceleration operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_acceleration()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotational_acceleration._spec().outputs, op)
+ self._fields_container = Output(
+ nodal_rotational_acceleration._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.nodal_rotational_acceleration()
+ >>> # 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/nodal_rotational_acceleration_X.py b/src/ansys/dpf/core/operators/result/nodal_rotational_acceleration_X.py
new file mode 100644
index 00000000000..19902c751da
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotational_acceleration_X.py
@@ -0,0 +1,504 @@
+"""
+nodal_rotational_acceleration_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 nodal_rotational_acceleration_X(Operator):
+ r"""Read/compute nodal rotational acceleration 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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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="DMGX", config=config, server=server)
+ self._inputs = InputsNodalRotationalAccelerationX(self)
+ self._outputs = OutputsNodalRotationalAccelerationX(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 nodal rotational acceleration 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="DMGX", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationalAccelerationX:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationalAccelerationX.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationalAccelerationX:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationalAccelerationX.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationalAccelerationX(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotational_acceleration_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_acceleration_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__(nodal_rotational_acceleration_X._spec().inputs, op)
+ self._time_scoping = Input(
+ nodal_rotational_acceleration_X._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ nodal_rotational_acceleration_X._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotational_acceleration_X._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotational_acceleration_X._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ nodal_rotational_acceleration_X._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotational_acceleration_X._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(
+ nodal_rotational_acceleration_X._spec().input_pin(7), 7, op, -1
+ )
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(
+ nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_X()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodalRotationalAccelerationX(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotational_acceleration_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_acceleration_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotational_acceleration_X._spec().outputs, op)
+ self._fields_container = Output(
+ nodal_rotational_acceleration_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.nodal_rotational_acceleration_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/nodal_rotational_acceleration_Y.py b/src/ansys/dpf/core/operators/result/nodal_rotational_acceleration_Y.py
new file mode 100644
index 00000000000..24ca35d131f
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotational_acceleration_Y.py
@@ -0,0 +1,504 @@
+"""
+nodal_rotational_acceleration_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 nodal_rotational_acceleration_Y(Operator):
+ r"""Read/compute nodal rotational acceleration 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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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="DMGY", config=config, server=server)
+ self._inputs = InputsNodalRotationalAccelerationY(self)
+ self._outputs = OutputsNodalRotationalAccelerationY(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 nodal rotational acceleration 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="DMGY", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationalAccelerationY:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationalAccelerationY.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationalAccelerationY:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationalAccelerationY.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationalAccelerationY(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotational_acceleration_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_acceleration_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__(nodal_rotational_acceleration_Y._spec().inputs, op)
+ self._time_scoping = Input(
+ nodal_rotational_acceleration_Y._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ nodal_rotational_acceleration_Y._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotational_acceleration_Y._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotational_acceleration_Y._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ nodal_rotational_acceleration_Y._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotational_acceleration_Y._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(
+ nodal_rotational_acceleration_Y._spec().input_pin(7), 7, op, -1
+ )
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(
+ nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_Y()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodalRotationalAccelerationY(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotational_acceleration_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_acceleration_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotational_acceleration_Y._spec().outputs, op)
+ self._fields_container = Output(
+ nodal_rotational_acceleration_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.nodal_rotational_acceleration_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/nodal_rotational_acceleration_Z.py b/src/ansys/dpf/core/operators/result/nodal_rotational_acceleration_Z.py
new file mode 100644
index 00000000000..c550092a042
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotational_acceleration_Z.py
@@ -0,0 +1,504 @@
+"""
+nodal_rotational_acceleration_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 nodal_rotational_acceleration_Z(Operator):
+ r"""Read/compute nodal rotational acceleration 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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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="DMGZ", config=config, server=server)
+ self._inputs = InputsNodalRotationalAccelerationZ(self)
+ self._outputs = OutputsNodalRotationalAccelerationZ(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 nodal rotational acceleration 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="DMGZ", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationalAccelerationZ:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationalAccelerationZ.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationalAccelerationZ:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationalAccelerationZ.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationalAccelerationZ(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotational_acceleration_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_acceleration_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__(nodal_rotational_acceleration_Z._spec().inputs, op)
+ self._time_scoping = Input(
+ nodal_rotational_acceleration_Z._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ nodal_rotational_acceleration_Z._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotational_acceleration_Z._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotational_acceleration_Z._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ nodal_rotational_acceleration_Z._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotational_acceleration_Z._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(
+ nodal_rotational_acceleration_Z._spec().input_pin(7), 7, op, -1
+ )
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(
+ nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_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.nodal_rotational_acceleration_Z()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodalRotationalAccelerationZ(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotational_acceleration_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_acceleration_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotational_acceleration_Z._spec().outputs, op)
+ self._fields_container = Output(
+ nodal_rotational_acceleration_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.nodal_rotational_acceleration_Z()
+ >>> # 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/nodal_rotational_velocity.py b/src/ansys/dpf/core/operators/result/nodal_rotational_velocity.py
new file mode 100644
index 00000000000..b9ee330473c
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotational_velocity.py
@@ -0,0 +1,461 @@
+"""
+nodal_rotational_velocity
+
+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 nodal_rotational_velocity(Operator):
+ r"""Read/compute nodal rotational velocity 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.nodal_rotational_velocity()
+
+ >>> # 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.nodal_rotational_velocity(
+ ... 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="OMG", config=config, server=server)
+ self._inputs = InputsNodalRotationalVelocity(self)
+ self._outputs = OutputsNodalRotationalVelocity(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 nodal rotational velocity 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="OMG", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationalVelocity:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationalVelocity.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationalVelocity:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationalVelocity.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationalVelocity(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotational_velocity operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_velocity()
+ >>> 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__(nodal_rotational_velocity._spec().inputs, op)
+ self._time_scoping = Input(
+ nodal_rotational_velocity._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ nodal_rotational_velocity._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotational_velocity._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotational_velocity._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ nodal_rotational_velocity._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotational_velocity._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(nodal_rotational_velocity._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.nodal_rotational_velocity()
+ >>> 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.nodal_rotational_velocity()
+ >>> 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.nodal_rotational_velocity()
+ >>> 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.nodal_rotational_velocity()
+ >>> 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.nodal_rotational_velocity()
+ >>> 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.nodal_rotational_velocity()
+ >>> 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.nodal_rotational_velocity()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+
+class OutputsNodalRotationalVelocity(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotational_velocity operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_velocity()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotational_velocity._spec().outputs, op)
+ self._fields_container = Output(
+ nodal_rotational_velocity._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.nodal_rotational_velocity()
+ >>> # 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/nodal_rotational_velocity_X.py b/src/ansys/dpf/core/operators/result/nodal_rotational_velocity_X.py
new file mode 100644
index 00000000000..b701ec80de8
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotational_velocity_X.py
@@ -0,0 +1,502 @@
+"""
+nodal_rotational_velocity_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 nodal_rotational_velocity_X(Operator):
+ r"""Read/compute nodal rotational velocity 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.nodal_rotational_velocity_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.nodal_rotational_velocity_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="OMGX", config=config, server=server)
+ self._inputs = InputsNodalRotationalVelocityX(self)
+ self._outputs = OutputsNodalRotationalVelocityX(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 nodal rotational velocity 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="OMGX", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationalVelocityX:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationalVelocityX.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationalVelocityX:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationalVelocityX.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationalVelocityX(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotational_velocity_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_velocity_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__(nodal_rotational_velocity_X._spec().inputs, op)
+ self._time_scoping = Input(
+ nodal_rotational_velocity_X._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ nodal_rotational_velocity_X._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotational_velocity_X._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotational_velocity_X._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ nodal_rotational_velocity_X._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotational_velocity_X._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(nodal_rotational_velocity_X._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(
+ nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_X()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodalRotationalVelocityX(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotational_velocity_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_velocity_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotational_velocity_X._spec().outputs, op)
+ self._fields_container = Output(
+ nodal_rotational_velocity_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.nodal_rotational_velocity_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/nodal_rotational_velocity_Y.py b/src/ansys/dpf/core/operators/result/nodal_rotational_velocity_Y.py
new file mode 100644
index 00000000000..ba172d5cc03
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotational_velocity_Y.py
@@ -0,0 +1,502 @@
+"""
+nodal_rotational_velocity_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 nodal_rotational_velocity_Y(Operator):
+ r"""Read/compute nodal rotational velocity 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.nodal_rotational_velocity_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.nodal_rotational_velocity_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="OMGY", config=config, server=server)
+ self._inputs = InputsNodalRotationalVelocityY(self)
+ self._outputs = OutputsNodalRotationalVelocityY(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 nodal rotational velocity 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="OMGY", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationalVelocityY:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationalVelocityY.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationalVelocityY:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationalVelocityY.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationalVelocityY(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotational_velocity_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_velocity_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__(nodal_rotational_velocity_Y._spec().inputs, op)
+ self._time_scoping = Input(
+ nodal_rotational_velocity_Y._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ nodal_rotational_velocity_Y._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotational_velocity_Y._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotational_velocity_Y._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ nodal_rotational_velocity_Y._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotational_velocity_Y._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(nodal_rotational_velocity_Y._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(
+ nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_Y()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodalRotationalVelocityY(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotational_velocity_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_velocity_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotational_velocity_Y._spec().outputs, op)
+ self._fields_container = Output(
+ nodal_rotational_velocity_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.nodal_rotational_velocity_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/nodal_rotational_velocity_Z.py b/src/ansys/dpf/core/operators/result/nodal_rotational_velocity_Z.py
new file mode 100644
index 00000000000..b663774b909
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotational_velocity_Z.py
@@ -0,0 +1,502 @@
+"""
+nodal_rotational_velocity_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 nodal_rotational_velocity_Z(Operator):
+ r"""Read/compute nodal rotational velocity 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.nodal_rotational_velocity_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.nodal_rotational_velocity_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="OMGZ", config=config, server=server)
+ self._inputs = InputsNodalRotationalVelocityZ(self)
+ self._outputs = OutputsNodalRotationalVelocityZ(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 nodal rotational velocity 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="OMGZ", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationalVelocityZ:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationalVelocityZ.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationalVelocityZ:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationalVelocityZ.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationalVelocityZ(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotational_velocity_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_velocity_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__(nodal_rotational_velocity_Z._spec().inputs, op)
+ self._time_scoping = Input(
+ nodal_rotational_velocity_Z._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ nodal_rotational_velocity_Z._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotational_velocity_Z._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotational_velocity_Z._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ nodal_rotational_velocity_Z._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotational_velocity_Z._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(nodal_rotational_velocity_Z._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(
+ nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_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.nodal_rotational_velocity_Z()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodalRotationalVelocityZ(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotational_velocity_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotational_velocity_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotational_velocity_Z._spec().outputs, op)
+ self._fields_container = Output(
+ nodal_rotational_velocity_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.nodal_rotational_velocity_Z()
+ >>> # 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/nodal_rotations.py b/src/ansys/dpf/core/operators/result/nodal_rotations.py
new file mode 100644
index 00000000000..3b65c398c9f
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotations.py
@@ -0,0 +1,449 @@
+"""
+nodal_rotations
+
+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 nodal_rotations(Operator):
+ r"""Read/compute nodal rotations 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.nodal_rotations()
+
+ >>> # 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.nodal_rotations(
+ ... 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="ROT", config=config, server=server)
+ self._inputs = InputsNodalRotations(self)
+ self._outputs = OutputsNodalRotations(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 nodal rotations 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="ROT", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotations:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotations.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotations:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotations.
+ """
+ return super().outputs
+
+
+class InputsNodalRotations(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotations operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotations()
+ >>> 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__(nodal_rotations._spec().inputs, op)
+ self._time_scoping = Input(nodal_rotations._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(nodal_rotations._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(nodal_rotations._spec().input_pin(2), 2, op, -1)
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(nodal_rotations._spec().input_pin(3), 3, op, -1)
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(nodal_rotations._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotations._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(nodal_rotations._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.nodal_rotations()
+ >>> 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.nodal_rotations()
+ >>> 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.nodal_rotations()
+ >>> 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.nodal_rotations()
+ >>> 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.nodal_rotations()
+ >>> 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.nodal_rotations()
+ >>> 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.nodal_rotations()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+
+class OutputsNodalRotations(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotations operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotations()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotations._spec().outputs, op)
+ self._fields_container = Output(nodal_rotations._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.nodal_rotations()
+ >>> # 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/nodal_rotations_X.py b/src/ansys/dpf/core/operators/result/nodal_rotations_X.py
new file mode 100644
index 00000000000..a921d5d798d
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotations_X.py
@@ -0,0 +1,492 @@
+"""
+nodal_rotations_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 nodal_rotations_X(Operator):
+ r"""Read/compute nodal rotations 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.nodal_rotations_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.nodal_rotations_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="ROTX", config=config, server=server)
+ self._inputs = InputsNodalRotationsX(self)
+ self._outputs = OutputsNodalRotationsX(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 nodal rotations 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="ROTX", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationsX:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationsX.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationsX:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationsX.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationsX(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotations_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotations_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__(nodal_rotations_X._spec().inputs, op)
+ self._time_scoping = Input(nodal_rotations_X._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(nodal_rotations_X._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotations_X._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotations_X._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(nodal_rotations_X._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotations_X._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(nodal_rotations_X._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_X()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodalRotationsX(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotations_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotations_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotations_X._spec().outputs, op)
+ self._fields_container = Output(nodal_rotations_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.nodal_rotations_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/nodal_rotations_Y.py b/src/ansys/dpf/core/operators/result/nodal_rotations_Y.py
new file mode 100644
index 00000000000..c6fe9464356
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotations_Y.py
@@ -0,0 +1,492 @@
+"""
+nodal_rotations_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 nodal_rotations_Y(Operator):
+ r"""Read/compute nodal rotations 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.nodal_rotations_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.nodal_rotations_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="ROTY", config=config, server=server)
+ self._inputs = InputsNodalRotationsY(self)
+ self._outputs = OutputsNodalRotationsY(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 nodal rotations 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="ROTY", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationsY:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationsY.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationsY:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationsY.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationsY(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotations_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotations_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__(nodal_rotations_Y._spec().inputs, op)
+ self._time_scoping = Input(nodal_rotations_Y._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(nodal_rotations_Y._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotations_Y._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotations_Y._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(nodal_rotations_Y._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotations_Y._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(nodal_rotations_Y._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_Y()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodalRotationsY(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotations_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotations_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotations_Y._spec().outputs, op)
+ self._fields_container = Output(nodal_rotations_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.nodal_rotations_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/nodal_rotations_Z.py b/src/ansys/dpf/core/operators/result/nodal_rotations_Z.py
new file mode 100644
index 00000000000..92f1a395640
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/nodal_rotations_Z.py
@@ -0,0 +1,492 @@
+"""
+nodal_rotations_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 nodal_rotations_Z(Operator):
+ r"""Read/compute nodal rotations 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.nodal_rotations_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.nodal_rotations_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="ROTZ", config=config, server=server)
+ self._inputs = InputsNodalRotationsZ(self)
+ self._outputs = OutputsNodalRotationsZ(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 nodal rotations 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="ROTZ", server=server)
+
+ @property
+ def inputs(self) -> InputsNodalRotationsZ:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsNodalRotationsZ.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsNodalRotationsZ:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsNodalRotationsZ.
+ """
+ return super().outputs
+
+
+class InputsNodalRotationsZ(_Inputs):
+ """Intermediate class used to connect user inputs to
+ nodal_rotations_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotations_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__(nodal_rotations_Z._spec().inputs, op)
+ self._time_scoping = Input(nodal_rotations_Z._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(nodal_rotations_Z._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ nodal_rotations_Z._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ nodal_rotations_Z._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(nodal_rotations_Z._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ nodal_rotations_Z._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(nodal_rotations_Z._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._read_cyclic = Input(nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_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.nodal_rotations_Z()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+
+class OutputsNodalRotationsZ(_Outputs):
+ """Intermediate class used to get outputs from
+ nodal_rotations_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.nodal_rotations_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(nodal_rotations_Z._spec().outputs, op)
+ self._fields_container = Output(nodal_rotations_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.nodal_rotations_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 6b6353dcd7e..8b46757133c 100644
Binary files a/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll and b/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll differ
diff --git a/src/ansys/dpf/gatebin/DPFClientAPI.dll b/src/ansys/dpf/gatebin/DPFClientAPI.dll
index 6ad7bf44713..371e673537a 100644
Binary files a/src/ansys/dpf/gatebin/DPFClientAPI.dll and b/src/ansys/dpf/gatebin/DPFClientAPI.dll differ
diff --git a/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so b/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so
index cbb50d1bf74..65d749ce0c0 100644
Binary files a/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so and b/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so differ
diff --git a/src/ansys/dpf/gatebin/libDPFClientAPI.so b/src/ansys/dpf/gatebin/libDPFClientAPI.so
index 5131f92c0b3..1960cfd5f6e 100644
Binary files a/src/ansys/dpf/gatebin/libDPFClientAPI.so and b/src/ansys/dpf/gatebin/libDPFClientAPI.so differ
|