| | | threshold (precision) as a double, default value is 1e-7. If both pin1 and pin2 are provided, choose the min r-vectors
diff --git a/src/ansys/dpf/core/operators/compression/__init__.py b/src/ansys/dpf/core/operators/compression/__init__.py
index d666415b18..311125f858 100644
--- a/src/ansys/dpf/core/operators/compression/__init__.py
+++ b/src/ansys/dpf/core/operators/compression/__init__.py
@@ -1,4 +1,6 @@
from .apply_svd import apply_svd
from .apply_zfp import apply_zfp
from .kmeans_clustering import kmeans_clustering
+from .quantization import quantization
+from .quantization_fc import quantization_fc
from .zfp_decompress import zfp_decompress
diff --git a/src/ansys/dpf/core/operators/compression/quantization.py b/src/ansys/dpf/core/operators/compression/quantization.py
new file mode 100644
index 0000000000..8a696aa452
--- /dev/null
+++ b/src/ansys/dpf/core/operators/compression/quantization.py
@@ -0,0 +1,242 @@
+"""
+quantization
+
+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 quantization(Operator):
+ r"""Applies scaling to precision to all the values from field input, then
+ rounding to the unit.
+
+
+ Parameters
+ ----------
+ input_field: Field
+ Input field
+ threshold: float
+ Threshold (precision) desired.
+
+ Returns
+ -------
+ output_field: Field
+ Scaled and rounded field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.compression.quantization()
+
+ >>> # Make input connections
+ >>> my_input_field = dpf.Field()
+ >>> op.inputs.input_field.connect(my_input_field)
+ >>> my_threshold = float()
+ >>> op.inputs.threshold.connect(my_threshold)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.compression.quantization(
+ ... input_field=my_input_field,
+ ... threshold=my_threshold,
+ ... )
+
+ >>> # Get output data
+ >>> result_output_field = op.outputs.output_field()
+ """
+
+ def __init__(self, input_field=None, threshold=None, config=None, server=None):
+ super().__init__(name="quantization", config=config, server=server)
+ self._inputs = InputsQuantization(self)
+ self._outputs = OutputsQuantization(self)
+ if input_field is not None:
+ self.inputs.input_field.connect(input_field)
+ if threshold is not None:
+ self.inputs.threshold.connect(threshold)
+
+ @staticmethod
+ def _spec() -> Specification:
+ description = r"""Applies scaling to precision to all the values from field input, then
+rounding to the unit.
+"""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="input_field",
+ type_names=["field"],
+ optional=False,
+ document=r"""Input field""",
+ ),
+ 1: PinSpecification(
+ name="threshold",
+ type_names=["double"],
+ optional=False,
+ document=r"""Threshold (precision) desired.""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="output_field",
+ type_names=["field"],
+ optional=False,
+ document=r"""Scaled and rounded field""",
+ ),
+ },
+ )
+ 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="quantization", server=server)
+
+ @property
+ def inputs(self) -> InputsQuantization:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsQuantization.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsQuantization:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsQuantization.
+ """
+ return super().outputs
+
+
+class InputsQuantization(_Inputs):
+ """Intermediate class used to connect user inputs to
+ quantization operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization()
+ >>> my_input_field = dpf.Field()
+ >>> op.inputs.input_field.connect(my_input_field)
+ >>> my_threshold = float()
+ >>> op.inputs.threshold.connect(my_threshold)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(quantization._spec().inputs, op)
+ self._input_field = Input(quantization._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._input_field)
+ self._threshold = Input(quantization._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._threshold)
+
+ @property
+ def input_field(self) -> Input:
+ r"""Allows to connect input_field input to the operator.
+
+ Input field
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization()
+ >>> op.inputs.input_field.connect(my_input_field)
+ >>> # or
+ >>> op.inputs.input_field(my_input_field)
+ """
+ return self._input_field
+
+ @property
+ def threshold(self) -> Input:
+ r"""Allows to connect threshold input to the operator.
+
+ Threshold (precision) desired.
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization()
+ >>> op.inputs.threshold.connect(my_threshold)
+ >>> # or
+ >>> op.inputs.threshold(my_threshold)
+ """
+ return self._threshold
+
+
+class OutputsQuantization(_Outputs):
+ """Intermediate class used to get outputs from
+ quantization operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_output_field = op.outputs.output_field()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(quantization._spec().outputs, op)
+ self._output_field = Output(quantization._spec().output_pin(0), 0, op)
+ self._outputs.append(self._output_field)
+
+ @property
+ def output_field(self) -> Output:
+ r"""Allows to get output_field output of the operator
+
+ Scaled and rounded field
+
+ Returns
+ -------
+ output:
+ An Output instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization()
+ >>> # Get the output from op.outputs. ...
+ >>> result_output_field = op.outputs.output_field()
+ """
+ return self._output_field
diff --git a/src/ansys/dpf/core/operators/compression/quantization_fc.py b/src/ansys/dpf/core/operators/compression/quantization_fc.py
new file mode 100644
index 0000000000..8416485d39
--- /dev/null
+++ b/src/ansys/dpf/core/operators/compression/quantization_fc.py
@@ -0,0 +1,242 @@
+"""
+quantization_fc
+
+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 quantization_fc(Operator):
+ r"""Applies scaling to precision to all the values from fields container
+ input, then rounding to the unit.
+
+
+ Parameters
+ ----------
+ input_fc: FieldsContainer
+ Input fields container
+ threshold: float or Field or FieldsContainer
+ Threshold (precision) desired.
+
+ Returns
+ -------
+ output_fc: FieldsContainer
+ Scaled and rounded fields container
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.compression.quantization_fc()
+
+ >>> # Make input connections
+ >>> my_input_fc = dpf.FieldsContainer()
+ >>> op.inputs.input_fc.connect(my_input_fc)
+ >>> my_threshold = float()
+ >>> op.inputs.threshold.connect(my_threshold)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.compression.quantization_fc(
+ ... input_fc=my_input_fc,
+ ... threshold=my_threshold,
+ ... )
+
+ >>> # Get output data
+ >>> result_output_fc = op.outputs.output_fc()
+ """
+
+ def __init__(self, input_fc=None, threshold=None, config=None, server=None):
+ super().__init__(name="quantization_fc", config=config, server=server)
+ self._inputs = InputsQuantizationFc(self)
+ self._outputs = OutputsQuantizationFc(self)
+ if input_fc is not None:
+ self.inputs.input_fc.connect(input_fc)
+ if threshold is not None:
+ self.inputs.threshold.connect(threshold)
+
+ @staticmethod
+ def _spec() -> Specification:
+ description = r"""Applies scaling to precision to all the values from fields container
+input, then rounding to the unit.
+"""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="input_fc",
+ type_names=["fields_container"],
+ optional=False,
+ document=r"""Input fields container""",
+ ),
+ 1: PinSpecification(
+ name="threshold",
+ type_names=["double", "field", "fields_container"],
+ optional=False,
+ document=r"""Threshold (precision) desired.""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="output_fc",
+ type_names=["fields_container"],
+ optional=False,
+ document=r"""Scaled and rounded fields container""",
+ ),
+ },
+ )
+ 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="quantization_fc", server=server)
+
+ @property
+ def inputs(self) -> InputsQuantizationFc:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsQuantizationFc.
+ """
+ return super().inputs
+
+ @property
+ def outputs(self) -> OutputsQuantizationFc:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsQuantizationFc.
+ """
+ return super().outputs
+
+
+class InputsQuantizationFc(_Inputs):
+ """Intermediate class used to connect user inputs to
+ quantization_fc operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization_fc()
+ >>> my_input_fc = dpf.FieldsContainer()
+ >>> op.inputs.input_fc.connect(my_input_fc)
+ >>> my_threshold = float()
+ >>> op.inputs.threshold.connect(my_threshold)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(quantization_fc._spec().inputs, op)
+ self._input_fc = Input(quantization_fc._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._input_fc)
+ self._threshold = Input(quantization_fc._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._threshold)
+
+ @property
+ def input_fc(self) -> Input:
+ r"""Allows to connect input_fc input to the operator.
+
+ Input fields container
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization_fc()
+ >>> op.inputs.input_fc.connect(my_input_fc)
+ >>> # or
+ >>> op.inputs.input_fc(my_input_fc)
+ """
+ return self._input_fc
+
+ @property
+ def threshold(self) -> Input:
+ r"""Allows to connect threshold input to the operator.
+
+ Threshold (precision) desired.
+
+ Returns
+ -------
+ input:
+ An Input instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization_fc()
+ >>> op.inputs.threshold.connect(my_threshold)
+ >>> # or
+ >>> op.inputs.threshold(my_threshold)
+ """
+ return self._threshold
+
+
+class OutputsQuantizationFc(_Outputs):
+ """Intermediate class used to get outputs from
+ quantization_fc operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization_fc()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_output_fc = op.outputs.output_fc()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(quantization_fc._spec().outputs, op)
+ self._output_fc = Output(quantization_fc._spec().output_pin(0), 0, op)
+ self._outputs.append(self._output_fc)
+
+ @property
+ def output_fc(self) -> Output:
+ r"""Allows to get output_fc output of the operator
+
+ Scaled and rounded fields container
+
+ Returns
+ -------
+ output:
+ An Output instance for this pin.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.compression.quantization_fc()
+ >>> # Get the output from op.outputs. ...
+ >>> result_output_fc = op.outputs.output_fc()
+ """
+ return self._output_fc
diff --git a/src/ansys/dpf/core/operators/result/__init__.py b/src/ansys/dpf/core/operators/result/__init__.py
index 92d81acb06..f6bcf1423e 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 0000000000..344ba7de7c
--- /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 0000000000..19902c751d
--- /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 0000000000..24ca35d131
--- /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 0000000000..c550092a04
--- /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 0000000000..b9ee330473
--- /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 0000000000..b701ec80de
--- /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 0000000000..ba172d5cc0
--- /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 0000000000..b663774b90
--- /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 0000000000..3b65c398c9
--- /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 0000000000..a921d5d798
--- /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 0000000000..c6fe946435
--- /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 0000000000..92f1a39564
--- /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 fd82c035d5..9249413b18 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 122d55637be56a38684351b7b559cedb5ac16fe3..dfb113770cd8e9f78f7279b7f0eaefb2ce981f2f 100644
GIT binary patch
delta 4789951
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 |