| | | result file container allowed to be kept open to cache data.
diff --git a/src/ansys/dpf/core/operators/result/__init__.py b/src/ansys/dpf/core/operators/result/__init__.py
index 92d81acb061..f6bcf1423e9 100644
--- a/src/ansys/dpf/core/operators/result/__init__.py
+++ b/src/ansys/dpf/core/operators/result/__init__.py
@@ -218,6 +218,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/core/operators/scoping/adapt_with_scopings_container.py b/src/ansys/dpf/core/operators/scoping/adapt_with_scopings_container.py
index fd82c035d5b..9249413b181 100644
--- a/src/ansys/dpf/core/operators/scoping/adapt_with_scopings_container.py
+++ b/src/ansys/dpf/core/operators/scoping/adapt_with_scopings_container.py
@@ -24,6 +24,8 @@ class adapt_with_scopings_container(Operator):
----------
field_or_fields_container: FieldsContainer or Field
scopings_container: ScopingsContainer
+ keep_empty_fields: bool, optional
+ Default false.
Returns
-------
@@ -41,11 +43,14 @@ class adapt_with_scopings_container(Operator):
>>> op.inputs.field_or_fields_container.connect(my_field_or_fields_container)
>>> my_scopings_container = dpf.ScopingsContainer()
>>> op.inputs.scopings_container.connect(my_scopings_container)
+ >>> my_keep_empty_fields = bool()
+ >>> op.inputs.keep_empty_fields.connect(my_keep_empty_fields)
>>> # Instantiate operator and connect inputs in one line
>>> op = dpf.operators.scoping.adapt_with_scopings_container(
... field_or_fields_container=my_field_or_fields_container,
... scopings_container=my_scopings_container,
+ ... keep_empty_fields=my_keep_empty_fields,
... )
>>> # Get output data
@@ -56,6 +61,7 @@ def __init__(
self,
field_or_fields_container=None,
scopings_container=None,
+ keep_empty_fields=None,
config=None,
server=None,
):
@@ -66,6 +72,8 @@ def __init__(
self.inputs.field_or_fields_container.connect(field_or_fields_container)
if scopings_container is not None:
self.inputs.scopings_container.connect(scopings_container)
+ if keep_empty_fields is not None:
+ self.inputs.keep_empty_fields.connect(keep_empty_fields)
@staticmethod
def _spec() -> Specification:
@@ -87,6 +95,12 @@ def _spec() -> Specification:
optional=False,
document=r"""""",
),
+ 2: PinSpecification(
+ name="keep_empty_fields",
+ type_names=["bool"],
+ optional=True,
+ document=r"""Default false.""",
+ ),
},
map_output_pin_spec={
0: PinSpecification(
@@ -155,6 +169,8 @@ class InputsAdaptWithScopingsContainer(_Inputs):
>>> op.inputs.field_or_fields_container.connect(my_field_or_fields_container)
>>> my_scopings_container = dpf.ScopingsContainer()
>>> op.inputs.scopings_container.connect(my_scopings_container)
+ >>> my_keep_empty_fields = bool()
+ >>> op.inputs.keep_empty_fields.connect(my_keep_empty_fields)
"""
def __init__(self, op: Operator):
@@ -167,6 +183,10 @@ def __init__(self, op: Operator):
adapt_with_scopings_container._spec().input_pin(1), 1, op, -1
)
self._inputs.append(self._scopings_container)
+ self._keep_empty_fields = Input(
+ adapt_with_scopings_container._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._keep_empty_fields)
@property
def field_or_fields_container(self) -> Input:
@@ -206,6 +226,27 @@ def scopings_container(self) -> Input:
"""
return self._scopings_container
+ @property
+ def keep_empty_fields(self) -> Input:
+ r"""Allows to connect keep_empty_fields input to the operator.
+
+ Default false.
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.scoping.adapt_with_scopings_container()
+ >>> op.inputs.keep_empty_fields.connect(my_keep_empty_fields)
+ >>> # or
+ >>> op.inputs.keep_empty_fields(my_keep_empty_fields)
+ """
+ return self._keep_empty_fields
+
class OutputsAdaptWithScopingsContainer(_Outputs):
"""Intermediate class used to get outputs from
diff --git a/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll b/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll
index d2dbc9290f3276be4593215c9172e010cbb91c0b..adf4f2eae46fcdb1e5e6922d673efff15db1972a 100644
GIT binary patch
delta 3091901
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 |