| | | Fields container already allocated modified inplace
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..f292f3b5b10
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/PL2.py
@@ -0,0 +1,448 @@
+"""
+PL2
+
+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 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(PL2._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(PL2._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(PL2._spec().input_pin(2), 2, op, -1)
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(PL2._spec().input_pin(3), 3, op, -1)
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(PL2._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(PL2._spec().input_pin(5), 5, op, -1)
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(PL2._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.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:
+ 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:
+ 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:
+ 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:
+ 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:
+ 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:
+ 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(PL2._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.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..27ed44c2399
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/acoustic_energy_density.py
@@ -0,0 +1,462 @@
+"""
+acoustic_energy_density
+
+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 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(
+ acoustic_energy_density._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ acoustic_energy_density._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ acoustic_energy_density._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ acoustic_energy_density._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ acoustic_energy_density._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ acoustic_energy_density._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(acoustic_energy_density._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.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:
+ 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:
+ 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:
+ 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:
+ 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:
+ 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:
+ 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(
+ acoustic_energy_density._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.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/input_sound_power.py b/src/ansys/dpf/core/operators/result/input_sound_power.py
new file mode 100644
index 00000000000..04a38f35106
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/input_sound_power.py
@@ -0,0 +1,454 @@
+"""
+input_sound_power
+
+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 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(input_sound_power._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(input_sound_power._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ input_sound_power._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ input_sound_power._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(input_sound_power._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ input_sound_power._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(input_sound_power._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.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:
+ 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:
+ 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:
+ 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:
+ 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:
+ 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:
+ 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(input_sound_power._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.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..047bf15daf2
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/output_sound_power.py
@@ -0,0 +1,454 @@
+"""
+output_sound_power
+
+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 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(output_sound_power._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(output_sound_power._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ output_sound_power._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ output_sound_power._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(output_sound_power._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ output_sound_power._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(output_sound_power._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.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:
+ 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:
+ 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:
+ 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:
+ 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:
+ 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:
+ 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(output_sound_power._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.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/gatebin/Ans.Dpf.GrpcClient.dll b/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll
index 455e700d7af3e349c8afd794714511a069f6529b..ac1fadaa66e26be2369bd72136e31c480ebb8d47 100644
GIT binary patch
delta 2617867
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 ln;V7koV7hC)VsM3oT
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 |