| | | 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 6b6353dcd7e32f1ff73e4f03bfcb91b71c6c0afd..8b46757133c1a49b444957cc1abd5a459d4d6573 100644
GIT binary patch
delta 3251335
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 |