| | | if this pin is set to 0, the A-weighting is computed, 1 the B-weigting is computed and 2 the C-weightings is computed.
diff --git a/src/ansys/dpf/core/operators/result/PL2.py b/src/ansys/dpf/core/operators/result/PL2.py
new file mode 100644
index 00000000000..bf79c342773
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/PL2.py
@@ -0,0 +1,475 @@
+"""
+PL2
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+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
+
+if TYPE_CHECKING:
+ from ansys.dpf.core.data_sources import DataSources
+ from ansys.dpf.core.field import Field
+ from ansys.dpf.core.fields_container import FieldsContainer
+ from ansys.dpf.core.meshed_region import MeshedRegion
+ from ansys.dpf.core.meshes_container import MeshesContainer
+ from ansys.dpf.core.scoping import Scoping
+ from ansys.dpf.core.scopings_container import ScopingsContainer
+ from ansys.dpf.core.streams_container import StreamsContainer
+
+
+class PL2(Operator):
+ r"""Read/compute PL2 by calling the readers defined by the datasources.
+
+
+ Inputs
+ ------
+ 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
+
+ Outputs
+ -------
+ fields_container: FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.PL2()
+
+ >>> # 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.PL2(
+ ... 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()
+ """
+
+ _inputs: InputsPl2
+ _outputs: OutputsPl2
+
+ 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="PL2", config=config, server=server)
+ self._inputs = InputsPl2(self)
+ self._outputs = OutputsPl2(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 PL2 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="PL2", server=server)
+
+ @property
+ def inputs(self) -> InputsPl2:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsPl2.
+ """
+ return self._inputs
+
+ @property
+ def outputs(self) -> OutputsPl2:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsPl2.
+ """
+ return self._outputs
+
+
+class InputsPl2(_Inputs):
+ """Intermediate class used to connect user inputs to
+ PL2 operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.PL2()
+ >>> 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__(PL2._spec().inputs, op)
+ self._time_scoping: Input[Scoping | int | float | Field] = Input(
+ PL2._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping: Input[ScopingsContainer | Scoping] = Input(
+ PL2._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container: Input[FieldsContainer] = Input(
+ PL2._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container: Input[StreamsContainer] = Input(
+ PL2._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources: Input[DataSources] = Input(
+ PL2._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global: Input[bool] = Input(
+ PL2._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh: Input[MeshedRegion | MeshesContainer] = Input(
+ PL2._spec().input_pin(7), 7, op, -1
+ )
+ self._inputs.append(self._mesh)
+
+ @property
+ def time_scoping(self) -> Input[Scoping | int | float | Field]:
+ 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.PL2()
+ >>> 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[ScopingsContainer | Scoping]:
+ 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.PL2()
+ >>> 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[FieldsContainer]:
+ 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.PL2()
+ >>> 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[StreamsContainer]:
+ 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.PL2()
+ >>> 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[DataSources]:
+ 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.PL2()
+ >>> 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[bool]:
+ 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.PL2()
+ >>> 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[MeshedRegion | MeshesContainer]:
+ 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.PL2()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+
+class OutputsPl2(_Outputs):
+ """Intermediate class used to get outputs from
+ PL2 operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.PL2()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(PL2._spec().outputs, op)
+ self._fields_container: Output[FieldsContainer] = Output(
+ PL2._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self) -> Output[FieldsContainer]:
+ 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.PL2()
+ >>> # 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/__init__.py b/src/ansys/dpf/core/operators/result/__init__.py
index 5cae26b6e05..9fb99256413 100644
--- a/src/ansys/dpf/core/operators/result/__init__.py
+++ b/src/ansys/dpf/core/operators/result/__init__.py
@@ -1,9 +1,11 @@
+from .PL2 import PL2
from .acceleration import acceleration
from .acceleration_X import acceleration_X
from .acceleration_Y import acceleration_Y
from .acceleration_Z import acceleration_Z
from .accu_eqv_creep_strain import accu_eqv_creep_strain
from .accu_eqv_plastic_strain import accu_eqv_plastic_strain
+from .acoustic_energy_density import acoustic_energy_density
from .add_rigid_body_motion import add_rigid_body_motion
from .add_rigid_body_motion_fc import add_rigid_body_motion_fc
from .artificial_hourglass_energy import artificial_hourglass_energy
@@ -175,6 +177,7 @@
from .hydrostatic_pressure import hydrostatic_pressure
from .incremental_energy import incremental_energy
from .initial_coordinates import initial_coordinates
+from .input_sound_power import input_sound_power
from .interface_contact_area import interface_contact_area
from .interface_contact_force import interface_contact_force
from .interface_contact_mass import interface_contact_mass
@@ -243,6 +246,7 @@
from .normal_contact_moment import normal_contact_moment
from .num_surface_status_changes import num_surface_status_changes
from .omega import omega
+from .output_sound_power import output_sound_power
from .part_added_mass import part_added_mass
from .part_eroded_internal_energy import part_eroded_internal_energy
from .part_eroded_kinetic_energy import part_eroded_kinetic_energy
diff --git a/src/ansys/dpf/core/operators/result/acoustic_energy_density.py b/src/ansys/dpf/core/operators/result/acoustic_energy_density.py
new file mode 100644
index 00000000000..0590ffa2a23
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/acoustic_energy_density.py
@@ -0,0 +1,475 @@
+"""
+acoustic_energy_density
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+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
+
+if TYPE_CHECKING:
+ from ansys.dpf.core.data_sources import DataSources
+ from ansys.dpf.core.field import Field
+ from ansys.dpf.core.fields_container import FieldsContainer
+ from ansys.dpf.core.meshed_region import MeshedRegion
+ from ansys.dpf.core.meshes_container import MeshesContainer
+ from ansys.dpf.core.scoping import Scoping
+ from ansys.dpf.core.scopings_container import ScopingsContainer
+ from ansys.dpf.core.streams_container import StreamsContainer
+
+
+class acoustic_energy_density(Operator):
+ r"""Read/compute AED by calling the readers defined by the datasources.
+
+
+ Inputs
+ ------
+ 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
+
+ Outputs
+ -------
+ fields_container: FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.acoustic_energy_density()
+
+ >>> # 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.acoustic_energy_density(
+ ... 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()
+ """
+
+ _inputs: InputsAcousticEnergyDensity
+ _outputs: OutputsAcousticEnergyDensity
+
+ 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="AED", config=config, server=server)
+ self._inputs = InputsAcousticEnergyDensity(self)
+ self._outputs = OutputsAcousticEnergyDensity(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 AED 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="AED", server=server)
+
+ @property
+ def inputs(self) -> InputsAcousticEnergyDensity:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsAcousticEnergyDensity.
+ """
+ return self._inputs
+
+ @property
+ def outputs(self) -> OutputsAcousticEnergyDensity:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsAcousticEnergyDensity.
+ """
+ return self._outputs
+
+
+class InputsAcousticEnergyDensity(_Inputs):
+ """Intermediate class used to connect user inputs to
+ acoustic_energy_density operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.acoustic_energy_density()
+ >>> 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__(acoustic_energy_density._spec().inputs, op)
+ self._time_scoping: Input[Scoping | int | float | Field] = Input(
+ acoustic_energy_density._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping: Input[ScopingsContainer | Scoping] = Input(
+ acoustic_energy_density._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container: Input[FieldsContainer] = Input(
+ acoustic_energy_density._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container: Input[StreamsContainer] = Input(
+ acoustic_energy_density._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources: Input[DataSources] = Input(
+ acoustic_energy_density._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global: Input[bool] = Input(
+ acoustic_energy_density._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh: Input[MeshedRegion | MeshesContainer] = Input(
+ acoustic_energy_density._spec().input_pin(7), 7, op, -1
+ )
+ self._inputs.append(self._mesh)
+
+ @property
+ def time_scoping(self) -> Input[Scoping | int | float | Field]:
+ 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.acoustic_energy_density()
+ >>> 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[ScopingsContainer | Scoping]:
+ 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.acoustic_energy_density()
+ >>> 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[FieldsContainer]:
+ 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.acoustic_energy_density()
+ >>> 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[StreamsContainer]:
+ 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.acoustic_energy_density()
+ >>> 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[DataSources]:
+ 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.acoustic_energy_density()
+ >>> 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[bool]:
+ 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.acoustic_energy_density()
+ >>> 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[MeshedRegion | MeshesContainer]:
+ 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.acoustic_energy_density()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+
+class OutputsAcousticEnergyDensity(_Outputs):
+ """Intermediate class used to get outputs from
+ acoustic_energy_density operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.acoustic_energy_density()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(acoustic_energy_density._spec().outputs, op)
+ self._fields_container: Output[FieldsContainer] = Output(
+ acoustic_energy_density._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self) -> Output[FieldsContainer]:
+ 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.acoustic_energy_density()
+ >>> # 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/element_centroids.py b/src/ansys/dpf/core/operators/result/element_centroids.py
index acf673e160f..a5ff0c4d34f 100644
--- a/src/ansys/dpf/core/operators/result/element_centroids.py
+++ b/src/ansys/dpf/core/operators/result/element_centroids.py
@@ -27,7 +27,7 @@
class element_centroids(Operator):
- r"""Read/compute coordinate of the elemental centroids by calling the
+ r"""Read/compute coordinate of the mesh elemental centroids by calling the
readers defined by the datasources.
@@ -125,7 +125,7 @@ def __init__(
@staticmethod
def _spec() -> Specification:
- description = r"""Read/compute coordinate of the elemental centroids by calling the
+ description = r"""Read/compute coordinate of the mesh elemental centroids by calling the
readers defined by the datasources.
"""
spec = Specification(
diff --git a/src/ansys/dpf/core/operators/result/input_sound_power.py b/src/ansys/dpf/core/operators/result/input_sound_power.py
new file mode 100644
index 00000000000..31aac9c7d38
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/input_sound_power.py
@@ -0,0 +1,475 @@
+"""
+input_sound_power
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+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
+
+if TYPE_CHECKING:
+ from ansys.dpf.core.data_sources import DataSources
+ from ansys.dpf.core.field import Field
+ from ansys.dpf.core.fields_container import FieldsContainer
+ from ansys.dpf.core.meshed_region import MeshedRegion
+ from ansys.dpf.core.meshes_container import MeshesContainer
+ from ansys.dpf.core.scoping import Scoping
+ from ansys.dpf.core.scopings_container import ScopingsContainer
+ from ansys.dpf.core.streams_container import StreamsContainer
+
+
+class input_sound_power(Operator):
+ r"""Read/compute PINC by calling the readers defined by the datasources.
+
+
+ Inputs
+ ------
+ 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
+
+ Outputs
+ -------
+ fields_container: FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.input_sound_power()
+
+ >>> # 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.input_sound_power(
+ ... 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()
+ """
+
+ _inputs: InputsInputSoundPower
+ _outputs: OutputsInputSoundPower
+
+ 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="PINC", config=config, server=server)
+ self._inputs = InputsInputSoundPower(self)
+ self._outputs = OutputsInputSoundPower(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 PINC 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="PINC", server=server)
+
+ @property
+ def inputs(self) -> InputsInputSoundPower:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsInputSoundPower.
+ """
+ return self._inputs
+
+ @property
+ def outputs(self) -> OutputsInputSoundPower:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsInputSoundPower.
+ """
+ return self._outputs
+
+
+class InputsInputSoundPower(_Inputs):
+ """Intermediate class used to connect user inputs to
+ input_sound_power operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.input_sound_power()
+ >>> 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__(input_sound_power._spec().inputs, op)
+ self._time_scoping: Input[Scoping | int | float | Field] = Input(
+ input_sound_power._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping: Input[ScopingsContainer | Scoping] = Input(
+ input_sound_power._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container: Input[FieldsContainer] = Input(
+ input_sound_power._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container: Input[StreamsContainer] = Input(
+ input_sound_power._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources: Input[DataSources] = Input(
+ input_sound_power._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global: Input[bool] = Input(
+ input_sound_power._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh: Input[MeshedRegion | MeshesContainer] = Input(
+ input_sound_power._spec().input_pin(7), 7, op, -1
+ )
+ self._inputs.append(self._mesh)
+
+ @property
+ def time_scoping(self) -> Input[Scoping | int | float | Field]:
+ 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.input_sound_power()
+ >>> 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[ScopingsContainer | Scoping]:
+ 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.input_sound_power()
+ >>> 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[FieldsContainer]:
+ 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.input_sound_power()
+ >>> 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[StreamsContainer]:
+ 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.input_sound_power()
+ >>> 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[DataSources]:
+ 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.input_sound_power()
+ >>> 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[bool]:
+ 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.input_sound_power()
+ >>> 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[MeshedRegion | MeshesContainer]:
+ 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.input_sound_power()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+
+class OutputsInputSoundPower(_Outputs):
+ """Intermediate class used to get outputs from
+ input_sound_power operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.input_sound_power()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(input_sound_power._spec().outputs, op)
+ self._fields_container: Output[FieldsContainer] = Output(
+ input_sound_power._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self) -> Output[FieldsContainer]:
+ 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.input_sound_power()
+ >>> # 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/output_sound_power.py b/src/ansys/dpf/core/operators/result/output_sound_power.py
new file mode 100644
index 00000000000..d3a94b0f55d
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/output_sound_power.py
@@ -0,0 +1,475 @@
+"""
+output_sound_power
+
+Autogenerated DPF operator classes.
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+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
+
+if TYPE_CHECKING:
+ from ansys.dpf.core.data_sources import DataSources
+ from ansys.dpf.core.field import Field
+ from ansys.dpf.core.fields_container import FieldsContainer
+ from ansys.dpf.core.meshed_region import MeshedRegion
+ from ansys.dpf.core.meshes_container import MeshesContainer
+ from ansys.dpf.core.scoping import Scoping
+ from ansys.dpf.core.scopings_container import ScopingsContainer
+ from ansys.dpf.core.streams_container import StreamsContainer
+
+
+class output_sound_power(Operator):
+ r"""Read/compute POUT by calling the readers defined by the datasources.
+
+
+ Inputs
+ ------
+ 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
+
+ Outputs
+ -------
+ fields_container: FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.output_sound_power()
+
+ >>> # 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.output_sound_power(
+ ... 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()
+ """
+
+ _inputs: InputsOutputSoundPower
+ _outputs: OutputsOutputSoundPower
+
+ 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="POUT", config=config, server=server)
+ self._inputs = InputsOutputSoundPower(self)
+ self._outputs = OutputsOutputSoundPower(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 POUT 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="POUT", server=server)
+
+ @property
+ def inputs(self) -> InputsOutputSoundPower:
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs:
+ An instance of InputsOutputSoundPower.
+ """
+ return self._inputs
+
+ @property
+ def outputs(self) -> OutputsOutputSoundPower:
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs:
+ An instance of OutputsOutputSoundPower.
+ """
+ return self._outputs
+
+
+class InputsOutputSoundPower(_Inputs):
+ """Intermediate class used to connect user inputs to
+ output_sound_power operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.output_sound_power()
+ >>> 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__(output_sound_power._spec().inputs, op)
+ self._time_scoping: Input[Scoping | int | float | Field] = Input(
+ output_sound_power._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping: Input[ScopingsContainer | Scoping] = Input(
+ output_sound_power._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container: Input[FieldsContainer] = Input(
+ output_sound_power._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container: Input[StreamsContainer] = Input(
+ output_sound_power._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources: Input[DataSources] = Input(
+ output_sound_power._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global: Input[bool] = Input(
+ output_sound_power._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh: Input[MeshedRegion | MeshesContainer] = Input(
+ output_sound_power._spec().input_pin(7), 7, op, -1
+ )
+ self._inputs.append(self._mesh)
+
+ @property
+ def time_scoping(self) -> Input[Scoping | int | float | Field]:
+ 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.output_sound_power()
+ >>> 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[ScopingsContainer | Scoping]:
+ 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.output_sound_power()
+ >>> 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[FieldsContainer]:
+ 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.output_sound_power()
+ >>> 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[StreamsContainer]:
+ 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.output_sound_power()
+ >>> 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[DataSources]:
+ 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.output_sound_power()
+ >>> 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[bool]:
+ 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.output_sound_power()
+ >>> 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[MeshedRegion | MeshesContainer]:
+ 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.output_sound_power()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+
+class OutputsOutputSoundPower(_Outputs):
+ """Intermediate class used to get outputs from
+ output_sound_power operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.output_sound_power()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(output_sound_power._spec().outputs, op)
+ self._fields_container: Output[FieldsContainer] = Output(
+ output_sound_power._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self) -> Output[FieldsContainer]:
+ 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.output_sound_power()
+ >>> # Get the output from op.outputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+ return self._fields_container
diff --git a/src/ansys/dpf/gate/generated/.gitignore b/src/ansys/dpf/gate/generated/.gitignore
new file mode 100644
index 00000000000..8e5bbf044f1
--- /dev/null
+++ b/src/ansys/dpf/gate/generated/.gitignore
@@ -0,0 +1 @@
+*.py
\ No newline at end of file
diff --git a/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll b/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll
index 455e700d7af..2e438d358d4 100644
Binary files a/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll and b/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll differ
diff --git a/src/ansys/dpf/gatebin/DPFClientAPI.dll b/src/ansys/dpf/gatebin/DPFClientAPI.dll
index 03176ff7a0f..62c50c466dc 100644
Binary files a/src/ansys/dpf/gatebin/DPFClientAPI.dll and b/src/ansys/dpf/gatebin/DPFClientAPI.dll differ
diff --git a/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so b/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so
index 4a3ccb4879c..ab656e76359 100644
Binary files a/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so and b/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so differ
|