diff --git a/doc/source/_static/dpf_operators.html b/doc/source/_static/dpf_operators.html
index fd1a4a5fc2..970ccc6fa9 100644
--- a/doc/source/_static/dpf_operators.html
+++ b/doc/source/_static/dpf_operators.html
@@ -2099,7 +2099,7 @@
Configurating operators
2 for normalized by the max at a given time step of the first entry or residuals depending on the reference field option,
3 for normalized by the max over all time steps of the first entry or residuals depending on the reference field option" types="int32" optional="true"ellipsis="false"inplace="false">Outputs
Configurations
Scripting
result: add rigid body motion (fields container)
Inputs
Outputs
Configurations
Scripting
utility: merge time freq supports
Inputs
Outputs
Configurations
Scripting
min_max: incremental over fields container
Inputs
Outputs
Configurations
Scripting
scoping: split on property type
Inputs
Outputs
Configurations
Scripting
utility: overlap fields
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal elemental (field)
Inputs
Outputs
Configurations
Scripting
utility: change shell layers
Inputs
Outputs
Configurations
Scripting
utility: merge meshes
Inputs
Outputs
Configurations
Scripting
utility: merge fields
Inputs
Outputs
Configurations
Scripting
utility: merge weighted fields
Inputs
Outputs
Configurations
Scripting
utility: merge fc to fc field matrices
Inputs
Outputs
Configurations
Scripting
filter: high pass (field)
Inputs
Outputs
Configurations
Scripting
min_max: max by component
Inputs
Outputs
Configurations
Scripting
utility: weighted merge fields by label
Inputs
Outputs
Configurations
Scripting
utility: merge fields by label
Inputs
Outputs
Configurations
Scripting
averaging: elemental to elemental nodal (field)
Inputs
Outputs
Configurations
Scripting
utility: merge meshes containers
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity
Inputs
Outputs
Configurations
Scripting
utility: merge collections
Inputs
Outputs
Configurations
Scripting
logic: merge solid and shell fields
Inputs
Outputs
Configurations
Scripting
min_max: min over time
Inputs
Outputs
Configurations
Scripting
geo: element nodal contribution
Inputs
Outputs
Configurations
Scripting
min_max: over label
Inputs
Outputs
Configurations
Scripting
min_max: min by component
Inputs
Outputs
Configurations
Scripting
serialization: serializer to string
Inputs
Outputs
Configurations
Scripting
serialization: deserializer
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded velocity
Inputs
Outputs
Configurations
Scripting
mesh: skin
Inputs
Outputs
Configurations
Scripting
utility: split in for each range
Inputs
Outputs
Configurations
Scripting
utility: incremental field
Inputs
Outputs
Configurations
Scripting
utility: incremental fields container
Inputs
Outputs
Configurations
Scripting
geo: rotate (fields container)
Inputs
Outputs
Configurations
Scripting
utility: incremental property field
Inputs
Outputs
Configurations
Scripting
utility: incremental mesh
Inputs
Outputs
Configurations
Scripting
mesh: points from coordinates
Inputs
Outputs
Configurations
Scripting
utility: incremental concantenate as fields container.
Inputs
Outputs
Configurations
Scripting
utility: make producer consumer for each iterator
Inputs
Outputs
Configurations
Scripting
utility: producer consumer for each
Inputs
Outputs
Configurations
Scripting
averaging: extend to mid nodes (field)
Inputs
Outputs
Configurations
Scripting
invariant: eigen vectors (on fields container)
Inputs
Outputs
Configurations
Scripting
mesh: mesh get attribute
Inputs
Outputs
Configurations
Scripting
metadata: time freq support get attribute
Inputs
Outputs
Configurations
Scripting
utility: set attribute
Inputs
Outputs
Configurations
Scripting
utility: field get attribute
Inputs
Outputs
Configurations
Scripting
min_max: time of min
Inputs
Outputs
Configurations
Scripting
min_max: max over phase
Inputs
Outputs
Configurations
Scripting
min_max: phase of max
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains (fields container)
Inputs
Outputs
Configurations
Scripting
min_max: incremental over field
Inputs
Outputs
Configurations
Scripting
utility: workflow to pydpf generator
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (timefreq)
Inputs
Outputs
Configurations
Scripting
logic: same string fields?
Inputs
Outputs
Configurations
Scripting
logic: same meshes?
Inputs
Outputs
Configurations
Scripting
logic: same fields?
Inputs
Outputs
Configurations
Scripting
logic: fields included?
Inputs
Outputs
Configurations
Scripting
logic: same fields container?
Inputs
Outputs
Configurations
Scripting
filter: high pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: high pass (timescoping)
Inputs
Outputs
Configurations
Scripting
filter: high pass (fields container)
Inputs
Outputs
Configurations
Scripting
filter: low pass (field)
Inputs
Outputs
Configurations
Scripting
filter: low pass (fields container)
Inputs
Outputs
Configurations
Scripting
filter: band pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: band pass (timefreq)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (timescoping)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: csv to field
Inputs
Outputs
Configurations
Scripting
result: members in compression not certified
Inputs
Outputs
Configurations
Scripting
result: members in bending not certified
Inputs
Outputs
Configurations
Scripting
result: members in linear compression bending not certified
Inputs
Outputs
Configurations
Scripting
invariant: convertnum nod to bcs
Inputs
Outputs
Configurations
Scripting
geo: rotate
Inputs
Outputs
Configurations
Scripting
logic: enrich materials
Inputs
Outputs
Configurations
Scripting
serialization: data tree to json
Inputs
Outputs
Configurations
Scripting
serialization: data tree to txt
Inputs
Outputs
Configurations
Scripting
serialization: json to data tree
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (fields container)
Inputs
Outputs
Configurations
Scripting
logic: descending sort
Inputs
Outputs
Configurations
Scripting
logic: ascending sort (fields container)
Inputs
Outputs
Configurations
Scripting
logic: descending sort (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: import symbolic workflow
Inputs
Outputs
Configurations
Scripting
filter: filtering max over time workflow
Inputs
Outputs
Configurations
Scripting
metadata: integrate over time freq
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (field)
Inputs
Outputs
Configurations
Scripting
result: compute stress YZ
Inputs
Outputs
Configurations
Scripting
logic: splitter::data_sources
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal (field)
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: elemental to nodal (field)
Outputs
Configurations
Scripting
result: add rigid body motion (fields container)
Inputs
Outputs
Configurations
Scripting
utility: merge time freq supports
Inputs
Outputs
Configurations
Scripting
min_max: incremental over fields container
Inputs
Outputs
Configurations
Scripting
scoping: split on property type
Inputs
Outputs
Configurations
Scripting
utility: overlap fields
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal elemental (field)
Inputs
Outputs
Configurations
Scripting
utility: change shell layers
Inputs
Outputs
Configurations
Scripting
utility: merge meshes
Inputs
Outputs
Configurations
Scripting
utility: merge fields
Inputs
Outputs
Configurations
Scripting
utility: merge weighted fields
Inputs
Outputs
Configurations
Scripting
utility: merge fc to fc field matrices
Inputs
Outputs
Configurations
Scripting
filter: high pass (field)
Inputs
Outputs
Configurations
Scripting
min_max: max by component
Inputs
Outputs
Configurations
Scripting
utility: weighted merge fields by label
Inputs
Outputs
Configurations
Scripting
utility: merge fields by label
Inputs
Outputs
Configurations
Scripting
averaging: elemental to elemental nodal (field)
Inputs
Outputs
Configurations
Scripting
utility: merge meshes containers
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity
Inputs
Outputs
Configurations
Scripting
utility: merge collections
Inputs
Outputs
Configurations
Scripting
logic: merge solid and shell fields
Inputs
Outputs
Configurations
Scripting
min_max: min over time
Inputs
Outputs
Configurations
Scripting
geo: element nodal contribution
Inputs
Outputs
Configurations
Scripting
min_max: over label
Inputs
Outputs
Configurations
Scripting
min_max: min by component
Inputs
Outputs
Configurations
Scripting
serialization: serializer to string
Inputs
Outputs
Configurations
Scripting
serialization: deserializer
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded velocity
Inputs
Outputs
Configurations
Scripting
mesh: skin
Inputs
Outputs
Configurations
Scripting
utility: split in for each range
Inputs
Outputs
Configurations
Scripting
utility: incremental field
Inputs
Outputs
Configurations
Scripting
utility: incremental fields container
Inputs
Outputs
Configurations
Scripting
geo: rotate (fields container)
Inputs
Outputs
Configurations
Scripting
utility: incremental property field
Inputs
Outputs
Configurations
Scripting
utility: incremental mesh
Inputs
Outputs
Configurations
Scripting
mesh: points from coordinates
Inputs
Outputs
Configurations
Scripting
utility: incremental concantenate as fields container.
Inputs
Outputs
Configurations
Scripting
utility: make producer consumer for each iterator
Inputs
Outputs
Configurations
Scripting
utility: producer consumer for each
Inputs
Outputs
Configurations
Scripting
averaging: extend to mid nodes (field)
Inputs
Outputs
Configurations
Scripting
invariant: eigen vectors (on fields container)
Inputs
Outputs
Configurations
Scripting
mesh: mesh get attribute
Inputs
Outputs
Configurations
Scripting
metadata: time freq support get attribute
Inputs
Outputs
Configurations
Scripting
utility: set attribute
Inputs
Outputs
Configurations
Scripting
utility: field get attribute
Inputs
Outputs
Configurations
Scripting
min_max: time of min
Inputs
Outputs
Configurations
Scripting
min_max: max over phase
Inputs
Outputs
Configurations
Scripting
min_max: phase of max
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains (fields container)
Inputs
Outputs
Configurations
Scripting
min_max: incremental over field
Inputs
Outputs
Configurations
Scripting
utility: workflow to pydpf generator
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (timefreq)
Inputs
Outputs
Configurations
Scripting
logic: same string fields?
Inputs
Outputs
Configurations
Scripting
logic: same meshes?
Inputs
Outputs
Configurations
Scripting
logic: same fields?
Inputs
Outputs
Configurations
Scripting
logic: fields included?
Inputs
Outputs
Configurations
Scripting
logic: same fields container?
Inputs
Outputs
Configurations
Scripting
filter: high pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: high pass (timescoping)
Inputs
Outputs
Configurations
Scripting
filter: high pass (fields container)
Inputs
Outputs
Configurations
Scripting
filter: low pass (field)
Inputs
Outputs
Configurations
Scripting
filter: low pass (fields container)
Inputs
Outputs
Configurations
Scripting
filter: band pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: band pass (timefreq)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (timescoping)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: csv to field
Inputs
Outputs
Configurations
Scripting
result: members in compression not certified
Inputs
Outputs
Configurations
Scripting
result: members in bending not certified
Inputs
Outputs
Configurations
Scripting
result: members in linear compression bending not certified
Inputs
Outputs
Configurations
Scripting
invariant: convertnum nod to bcs
Inputs
Outputs
Configurations
Scripting
geo: rotate
Inputs
Outputs
Configurations
Scripting
logic: enrich materials
Inputs
Outputs
Configurations
Scripting
serialization: data tree to json
Inputs
Outputs
Configurations
Scripting
serialization: data tree to txt
Inputs
Outputs
Configurations
Scripting
serialization: json to data tree
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (fields container)
Inputs
Outputs
Configurations
Scripting
logic: descending sort
Inputs
Outputs
Configurations
Scripting
logic: ascending sort (fields container)
Inputs
Outputs
Configurations
Scripting
logic: descending sort (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: import symbolic workflow
Inputs
Outputs
Configurations
Scripting
filter: filtering max over time workflow
Inputs
Outputs
Configurations
Scripting
metadata: integrate over time freq
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (field)
Inputs
Outputs
Configurations
Scripting
result: compute stress YZ
Inputs
Outputs
Configurations
Scripting
logic: splitter::data_sources
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal (field)
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: elemental to nodal (field)
>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
-
- >>> # Make input connections
- >>> my_fields_container = dpf.FieldsContainer()
- >>> op.inputs.fields_container.connect(my_fields_container)
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> my_force_averaging = int()
- >>> op.inputs.force_averaging.connect(my_force_averaging)
- >>> my_mesh_scoping = dpf.Scoping()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> my_algorithm = int()
- >>> op.inputs.algorithm.connect(my_algorithm)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc(
- ... fields_container=my_fields_container,
- ... mesh=my_mesh,
- ... force_averaging=my_force_averaging,
- ... mesh_scoping=my_mesh_scoping,
- ... algorithm=my_algorithm,
- ... )
-
- >>> # Get output data
- >>> result_fields_container = op.outputs.fields_container()
- """
-
- def __init__(
- self,
- fields_container=None,
- mesh=None,
- force_averaging=None,
- mesh_scoping=None,
- algorithm=None,
- config=None,
- server=None,
- ):
- super().__init__(name="elemental_to_nodal_fc", config=config, server=server)
- self._inputs = InputsElementalToNodalFc(self)
- self._outputs = OutputsElementalToNodalFc(self)
- if fields_container is not None:
- self.inputs.fields_container.connect(fields_container)
- if mesh is not None:
- self.inputs.mesh.connect(mesh)
- if force_averaging is not None:
- self.inputs.force_averaging.connect(force_averaging)
- if mesh_scoping is not None:
- self.inputs.mesh_scoping.connect(mesh_scoping)
- if algorithm is not None:
- self.inputs.algorithm.connect(algorithm)
-
- @staticmethod
- def _spec():
- description = """Transforms Elemental Nodal fields to Nodal fields. The result is
- computed on a given node's scoping.1. For a finite element
- mesh, the value on a node is the average of the values of
- the neighbour elements. 2. For a finite volume mesh, the
- agorithm is : - For each node, compute interpolation
- weights for the cells connected to it based on the
- Frink's Laplacian method. - If the determinant of
- the I matrix is zero, switch to an inverse distance
- weighted average. - If not, compute the Frink
- weights and apply the Holmes' weight clip. - If
- the clipping produces a large overshoot, inverse volume
- weighted average is used.. 3. For a face finite volume
- mesh inverse distance weighted average is used."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="fields_container",
- type_names=["fields_container"],
- optional=False,
- document="""""",
- ),
- 1: PinSpecification(
- name="mesh",
- type_names=["abstract_meshed_region", "meshes_container"],
- optional=True,
- document="""""",
- ),
- 2: PinSpecification(
- name="force_averaging",
- type_names=["int32"],
- optional=True,
- document="""Averaging on nodes is used if this pin is set
- to 1 (default is 1 for integrated
- results and 0 for discrete ones).""",
- ),
- 3: PinSpecification(
- name="mesh_scoping",
- type_names=["scoping", "scopings_container"],
- optional=True,
- document="""""",
- ),
- 200: PinSpecification(
- name="algorithm",
- type_names=["int32"],
- optional=True,
- document="""Forces the usage of algorithm 1, 2 or 3
- (default is chosen based on the type
- of mesh).""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="fields_container",
- type_names=["fields_container"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(name="elemental_to_nodal_fc", server=server)
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsElementalToNodalFc
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsElementalToNodalFc
- """
- return super().outputs
-
-
-class InputsElementalToNodalFc(_Inputs):
- """Intermediate class used to connect user inputs to
- elemental_to_nodal_fc operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
- >>> my_fields_container = dpf.FieldsContainer()
- >>> op.inputs.fields_container.connect(my_fields_container)
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> my_force_averaging = int()
- >>> op.inputs.force_averaging.connect(my_force_averaging)
- >>> my_mesh_scoping = dpf.Scoping()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> my_algorithm = int()
- >>> op.inputs.algorithm.connect(my_algorithm)
- """
-
- def __init__(self, op: Operator):
- super().__init__(elemental_to_nodal_fc._spec().inputs, op)
- self._fields_container = Input(
- elemental_to_nodal_fc._spec().input_pin(0), 0, op, -1
- )
- self._inputs.append(self._fields_container)
- self._mesh = Input(elemental_to_nodal_fc._spec().input_pin(1), 1, op, -1)
- self._inputs.append(self._mesh)
- self._force_averaging = Input(
- elemental_to_nodal_fc._spec().input_pin(2), 2, op, -1
- )
- self._inputs.append(self._force_averaging)
- self._mesh_scoping = Input(
- elemental_to_nodal_fc._spec().input_pin(3), 3, op, -1
- )
- self._inputs.append(self._mesh_scoping)
- self._algorithm = Input(
- elemental_to_nodal_fc._spec().input_pin(200), 200, op, -1
- )
- self._inputs.append(self._algorithm)
-
- @property
- def fields_container(self):
- """Allows to connect fields_container input to the operator.
-
- Parameters
- ----------
- my_fields_container : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
- >>> op.inputs.fields_container.connect(my_fields_container)
- >>> # or
- >>> op.inputs.fields_container(my_fields_container)
- """
- return self._fields_container
-
- @property
- def mesh(self):
- """Allows to connect mesh input to the operator.
-
- Parameters
- ----------
- my_mesh : MeshedRegion or MeshesContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> # or
- >>> op.inputs.mesh(my_mesh)
- """
- return self._mesh
-
- @property
- def force_averaging(self):
- """Allows to connect force_averaging input to the operator.
-
- Averaging on nodes is used if this pin is set
- to 1 (default is 1 for integrated
- results and 0 for discrete ones).
-
- Parameters
- ----------
- my_force_averaging : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
- >>> op.inputs.force_averaging.connect(my_force_averaging)
- >>> # or
- >>> op.inputs.force_averaging(my_force_averaging)
- """
- return self._force_averaging
-
- @property
- def mesh_scoping(self):
- """Allows to connect mesh_scoping input to the operator.
-
- Parameters
- ----------
- my_mesh_scoping : Scoping or ScopingsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> # or
- >>> op.inputs.mesh_scoping(my_mesh_scoping)
- """
- return self._mesh_scoping
-
- @property
- def algorithm(self):
- """Allows to connect algorithm input to the operator.
-
- Forces the usage of algorithm 1, 2 or 3
- (default is chosen based on the type
- of mesh).
-
- Parameters
- ----------
- my_algorithm : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
- >>> op.inputs.algorithm.connect(my_algorithm)
- >>> # or
- >>> op.inputs.algorithm(my_algorithm)
- """
- return self._algorithm
-
-
-class OutputsElementalToNodalFc(_Outputs):
- """Intermediate class used to get outputs from
- elemental_to_nodal_fc operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
- >>> # Connect inputs : op.inputs. ...
- >>> result_fields_container = op.outputs.fields_container()
- """
-
- def __init__(self, op: Operator):
- super().__init__(elemental_to_nodal_fc._spec().outputs, op)
- self._fields_container = Output(
- elemental_to_nodal_fc._spec().output_pin(0), 0, op
- )
- self._outputs.append(self._fields_container)
-
- @property
- def fields_container(self):
- """Allows to get fields_container output of the operator
-
- Returns
- ----------
- my_fields_container : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.elemental_to_nodal_fc()
- >>> # Connect inputs : op.inputs. ...
- >>> result_fields_container = op.outputs.fields_container()
- """ # noqa: E501
- return self._fields_container
diff --git a/src/ansys/dpf/core/operators/averaging/nodal_extend_to_mid_nodes.py b/src/ansys/dpf/core/operators/averaging/nodal_extend_to_mid_nodes.py
deleted file mode 100644
index 6be3556a74..0000000000
--- a/src/ansys/dpf/core/operators/averaging/nodal_extend_to_mid_nodes.py
+++ /dev/null
@@ -1,312 +0,0 @@
-"""
-nodal_extend_to_mid_nodes
-=========================
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class nodal_extend_to_mid_nodes(Operator):
- """Extends a Nodal field defined on corner nodes to a field defined also
- on mid nodes.
-
- Parameters
- ----------
- field : Field or FieldsContainer
- Field or fields container with only one field
- is expected
- node_scoping : Scoping, optional
- Nodes expected in output.
- element_scoping : Scoping, optional
- Precomputed list of elements of interest
- (improves performances).
- mesh : MeshedRegion, optional
-
- Returns
- -------
- field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.averaging.nodal_extend_to_mid_nodes()
-
- >>> # Make input connections
- >>> my_field = dpf.Field()
- >>> op.inputs.field.connect(my_field)
- >>> my_node_scoping = dpf.Scoping()
- >>> op.inputs.node_scoping.connect(my_node_scoping)
- >>> my_element_scoping = dpf.Scoping()
- >>> op.inputs.element_scoping.connect(my_element_scoping)
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.averaging.nodal_extend_to_mid_nodes(
- ... field=my_field,
- ... node_scoping=my_node_scoping,
- ... element_scoping=my_element_scoping,
- ... mesh=my_mesh,
- ... )
-
- >>> # Get output data
- >>> result_field = op.outputs.field()
- """
-
- def __init__(
- self,
- field=None,
- node_scoping=None,
- element_scoping=None,
- mesh=None,
- config=None,
- server=None,
- ):
- super().__init__(name="nodal_extend_to_mid_nodes", config=config, server=server)
- self._inputs = InputsNodalExtendToMidNodes(self)
- self._outputs = OutputsNodalExtendToMidNodes(self)
- if field is not None:
- self.inputs.field.connect(field)
- if node_scoping is not None:
- self.inputs.node_scoping.connect(node_scoping)
- if element_scoping is not None:
- self.inputs.element_scoping.connect(element_scoping)
- if mesh is not None:
- self.inputs.mesh.connect(mesh)
-
- @staticmethod
- def _spec():
- description = """Extends a Nodal field defined on corner nodes to a field defined also
- on mid nodes."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="field",
- type_names=["field", "fields_container"],
- optional=False,
- document="""Field or fields container with only one field
- is expected""",
- ),
- 1: PinSpecification(
- name="node_scoping",
- type_names=["scoping"],
- optional=True,
- document="""Nodes expected in output.""",
- ),
- 5: PinSpecification(
- name="element_scoping",
- type_names=["scoping"],
- optional=True,
- document="""Precomputed list of elements of interest
- (improves performances).""",
- ),
- 7: PinSpecification(
- name="mesh",
- type_names=["abstract_meshed_region"],
- optional=True,
- document="""""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="field",
- type_names=["field"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(name="nodal_extend_to_mid_nodes", server=server)
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsNodalExtendToMidNodes
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsNodalExtendToMidNodes
- """
- return super().outputs
-
-
-class InputsNodalExtendToMidNodes(_Inputs):
- """Intermediate class used to connect user inputs to
- nodal_extend_to_mid_nodes operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.nodal_extend_to_mid_nodes()
- >>> my_field = dpf.Field()
- >>> op.inputs.field.connect(my_field)
- >>> my_node_scoping = dpf.Scoping()
- >>> op.inputs.node_scoping.connect(my_node_scoping)
- >>> my_element_scoping = dpf.Scoping()
- >>> op.inputs.element_scoping.connect(my_element_scoping)
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
- """
-
- def __init__(self, op: Operator):
- super().__init__(nodal_extend_to_mid_nodes._spec().inputs, op)
- self._field = Input(nodal_extend_to_mid_nodes._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._field)
- self._node_scoping = Input(
- nodal_extend_to_mid_nodes._spec().input_pin(1), 1, op, -1
- )
- self._inputs.append(self._node_scoping)
- self._element_scoping = Input(
- nodal_extend_to_mid_nodes._spec().input_pin(5), 5, op, -1
- )
- self._inputs.append(self._element_scoping)
- self._mesh = Input(nodal_extend_to_mid_nodes._spec().input_pin(7), 7, op, -1)
- self._inputs.append(self._mesh)
-
- @property
- def field(self):
- """Allows to connect field input to the operator.
-
- Field or fields container with only one field
- is expected
-
- Parameters
- ----------
- my_field : Field or FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.nodal_extend_to_mid_nodes()
- >>> op.inputs.field.connect(my_field)
- >>> # or
- >>> op.inputs.field(my_field)
- """
- return self._field
-
- @property
- def node_scoping(self):
- """Allows to connect node_scoping input to the operator.
-
- Nodes expected in output.
-
- Parameters
- ----------
- my_node_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.nodal_extend_to_mid_nodes()
- >>> op.inputs.node_scoping.connect(my_node_scoping)
- >>> # or
- >>> op.inputs.node_scoping(my_node_scoping)
- """
- return self._node_scoping
-
- @property
- def element_scoping(self):
- """Allows to connect element_scoping input to the operator.
-
- Precomputed list of elements of interest
- (improves performances).
-
- Parameters
- ----------
- my_element_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.nodal_extend_to_mid_nodes()
- >>> op.inputs.element_scoping.connect(my_element_scoping)
- >>> # or
- >>> op.inputs.element_scoping(my_element_scoping)
- """
- return self._element_scoping
-
- @property
- def mesh(self):
- """Allows to connect mesh input to the operator.
-
- Parameters
- ----------
- my_mesh : MeshedRegion
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.nodal_extend_to_mid_nodes()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> # or
- >>> op.inputs.mesh(my_mesh)
- """
- return self._mesh
-
-
-class OutputsNodalExtendToMidNodes(_Outputs):
- """Intermediate class used to get outputs from
- nodal_extend_to_mid_nodes operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.nodal_extend_to_mid_nodes()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """
-
- def __init__(self, op: Operator):
- super().__init__(nodal_extend_to_mid_nodes._spec().outputs, op)
- self._field = Output(nodal_extend_to_mid_nodes._spec().output_pin(0), 0, op)
- self._outputs.append(self._field)
-
- @property
- def field(self):
- """Allows to get field output of the operator
-
- Returns
- ----------
- my_field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.nodal_extend_to_mid_nodes()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """ # noqa: E501
- return self._field
diff --git a/src/ansys/dpf/core/operators/averaging/to_elemental_nodal_fc.py b/src/ansys/dpf/core/operators/averaging/to_elemental_nodal_fc.py
deleted file mode 100644
index e16083df90..0000000000
--- a/src/ansys/dpf/core/operators/averaging/to_elemental_nodal_fc.py
+++ /dev/null
@@ -1,265 +0,0 @@
-"""
-to_elemental_nodal_fc
-=====================
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class to_elemental_nodal_fc(Operator):
- """Transforms fields into Elemental Nodal fields using an averaging
- process. The result is computed on a given element's scoping.
-
- Parameters
- ----------
- fields_container : FieldsContainer
- mesh_scoping : Scoping, optional
- mesh : MeshedRegion, optional
-
- Returns
- -------
- fields_container : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
-
- >>> # Make input connections
- >>> my_fields_container = dpf.FieldsContainer()
- >>> op.inputs.fields_container.connect(my_fields_container)
- >>> my_mesh_scoping = dpf.Scoping()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.averaging.to_elemental_nodal_fc(
- ... fields_container=my_fields_container,
- ... mesh_scoping=my_mesh_scoping,
- ... mesh=my_mesh,
- ... )
-
- >>> # Get output data
- >>> result_fields_container = op.outputs.fields_container()
- """
-
- def __init__(
- self,
- fields_container=None,
- mesh_scoping=None,
- mesh=None,
- config=None,
- server=None,
- ):
- super().__init__(name="to_elemental_nodal_fc", config=config, server=server)
- self._inputs = InputsToElementalNodalFc(self)
- self._outputs = OutputsToElementalNodalFc(self)
- if fields_container is not None:
- self.inputs.fields_container.connect(fields_container)
- if mesh_scoping is not None:
- self.inputs.mesh_scoping.connect(mesh_scoping)
- if mesh is not None:
- self.inputs.mesh.connect(mesh)
-
- @staticmethod
- def _spec():
- description = """Transforms fields into Elemental Nodal fields using an averaging
- process. The result is computed on a given element's
- scoping."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="fields_container",
- type_names=["fields_container"],
- optional=False,
- document="""""",
- ),
- 1: PinSpecification(
- name="mesh_scoping",
- type_names=["scoping"],
- optional=True,
- document="""""",
- ),
- 7: PinSpecification(
- name="mesh",
- type_names=["abstract_meshed_region"],
- optional=True,
- document="""""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="fields_container",
- type_names=["fields_container"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(name="to_elemental_nodal_fc", server=server)
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsToElementalNodalFc
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsToElementalNodalFc
- """
- return super().outputs
-
-
-class InputsToElementalNodalFc(_Inputs):
- """Intermediate class used to connect user inputs to
- to_elemental_nodal_fc operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
- >>> my_fields_container = dpf.FieldsContainer()
- >>> op.inputs.fields_container.connect(my_fields_container)
- >>> my_mesh_scoping = dpf.Scoping()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
- """
-
- def __init__(self, op: Operator):
- super().__init__(to_elemental_nodal_fc._spec().inputs, op)
- self._fields_container = Input(
- to_elemental_nodal_fc._spec().input_pin(0), 0, op, -1
- )
- self._inputs.append(self._fields_container)
- self._mesh_scoping = Input(
- to_elemental_nodal_fc._spec().input_pin(1), 1, op, -1
- )
- self._inputs.append(self._mesh_scoping)
- self._mesh = Input(to_elemental_nodal_fc._spec().input_pin(7), 7, op, -1)
- self._inputs.append(self._mesh)
-
- @property
- def fields_container(self):
- """Allows to connect fields_container input to the operator.
-
- Parameters
- ----------
- my_fields_container : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
- >>> op.inputs.fields_container.connect(my_fields_container)
- >>> # or
- >>> op.inputs.fields_container(my_fields_container)
- """
- return self._fields_container
-
- @property
- def mesh_scoping(self):
- """Allows to connect mesh_scoping input to the operator.
-
- Parameters
- ----------
- my_mesh_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> # or
- >>> op.inputs.mesh_scoping(my_mesh_scoping)
- """
- return self._mesh_scoping
-
- @property
- def mesh(self):
- """Allows to connect mesh input to the operator.
-
- Parameters
- ----------
- my_mesh : MeshedRegion
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> # or
- >>> op.inputs.mesh(my_mesh)
- """
- return self._mesh
-
-
-class OutputsToElementalNodalFc(_Outputs):
- """Intermediate class used to get outputs from
- to_elemental_nodal_fc operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
- >>> # Connect inputs : op.inputs. ...
- >>> result_fields_container = op.outputs.fields_container()
- """
-
- def __init__(self, op: Operator):
- super().__init__(to_elemental_nodal_fc._spec().outputs, op)
- self._fields_container = Output(
- to_elemental_nodal_fc._spec().output_pin(0), 0, op
- )
- self._outputs.append(self._fields_container)
-
- @property
- def fields_container(self):
- """Allows to get fields_container output of the operator
-
- Returns
- ----------
- my_fields_container : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.averaging.to_elemental_nodal_fc()
- >>> # Connect inputs : op.inputs. ...
- >>> result_fields_container = op.outputs.fields_container()
- """ # noqa: E501
- return self._fields_container
diff --git a/src/ansys/dpf/core/operators/compression/__init__.py b/src/ansys/dpf/core/operators/compression/__init__.py
new file mode 100644
index 0000000000..d666415b18
--- /dev/null
+++ b/src/ansys/dpf/core/operators/compression/__init__.py
@@ -0,0 +1,4 @@
+from .apply_svd import apply_svd
+from .apply_zfp import apply_zfp
+from .kmeans_clustering import kmeans_clustering
+from .zfp_decompress import zfp_decompress
diff --git a/src/ansys/dpf/core/operators/filter/__init__.py b/src/ansys/dpf/core/operators/filter/__init__.py
index 14cd284a27..0c05c58035 100644
--- a/src/ansys/dpf/core/operators/filter/__init__.py
+++ b/src/ansys/dpf/core/operators/filter/__init__.py
@@ -1,22 +1,22 @@
-from .abc_weightings import abc_weightings
-from .field_band_pass import field_band_pass
-from .field_band_pass_fc import field_band_pass_fc
-from .field_high_pass import field_high_pass
-from .field_high_pass_fc import field_high_pass_fc
-from .field_low_pass import field_low_pass
-from .field_low_pass_fc import field_low_pass_fc
-from .field_signed_high_pass import field_signed_high_pass
-from .field_signed_high_pass_fc import field_signed_high_pass_fc
-from .filtering_max_over_time import filtering_max_over_time
-from .scoping_band_pass import scoping_band_pass
-from .scoping_high_pass import scoping_high_pass
-from .scoping_low_pass import scoping_low_pass
-from .scoping_signed_high_pass import scoping_signed_high_pass
-from .timefreq_band_pass import timefreq_band_pass
-from .timefreq_high_pass import timefreq_high_pass
-from .timefreq_low_pass import timefreq_low_pass
-from .timefreq_signed_high_pass import timefreq_signed_high_pass
-from .timescoping_band_pass import timescoping_band_pass
-from .timescoping_high_pass import timescoping_high_pass
-from .timescoping_low_pass import timescoping_low_pass
-from .timescoping_signed_high_pass import timescoping_signed_high_pass
+from .abc_weightings import abc_weightings
+from .field_band_pass import field_band_pass
+from .field_band_pass_fc import field_band_pass_fc
+from .field_high_pass import field_high_pass
+from .field_high_pass_fc import field_high_pass_fc
+from .field_low_pass import field_low_pass
+from .field_low_pass_fc import field_low_pass_fc
+from .field_signed_high_pass import field_signed_high_pass
+from .field_signed_high_pass_fc import field_signed_high_pass_fc
+from .filtering_max_over_time import filtering_max_over_time
+from .scoping_band_pass import scoping_band_pass
+from .scoping_high_pass import scoping_high_pass
+from .scoping_low_pass import scoping_low_pass
+from .scoping_signed_high_pass import scoping_signed_high_pass
+from .timefreq_band_pass import timefreq_band_pass
+from .timefreq_high_pass import timefreq_high_pass
+from .timefreq_low_pass import timefreq_low_pass
+from .timefreq_signed_high_pass import timefreq_signed_high_pass
+from .timescoping_band_pass import timescoping_band_pass
+from .timescoping_high_pass import timescoping_high_pass
+from .timescoping_low_pass import timescoping_low_pass
+from .timescoping_signed_high_pass import timescoping_signed_high_pass
diff --git a/src/ansys/dpf/core/operators/geo/__init__.py b/src/ansys/dpf/core/operators/geo/__init__.py
index 4baf6471f7..77cb0bcf5e 100644
--- a/src/ansys/dpf/core/operators/geo/__init__.py
+++ b/src/ansys/dpf/core/operators/geo/__init__.py
@@ -1,18 +1,18 @@
-from .cartesian_to_spherical import cartesian_to_spherical
-from .cartesian_to_spherical_fc import cartesian_to_spherical_fc
-from .element_nodal_contribution import element_nodal_contribution
-from .elements_facets_surfaces_over_time import elements_facets_surfaces_over_time
-from .elements_volume import elements_volume
-from .elements_volumes_over_time import elements_volumes_over_time
-from .faces_area import faces_area
-from .gauss_to_node import gauss_to_node
-from .integrate_over_elements import integrate_over_elements
-from .normals import normals
-from .normals_provider_nl import normals_provider_nl
-from .rotate import rotate
-from .rotate_fc import rotate_fc
-from .rotate_in_cylindrical_cs import rotate_in_cylindrical_cs
-from .rotate_in_cylindrical_cs_fc import rotate_in_cylindrical_cs_fc
-from .spherical_to_cartesian import spherical_to_cartesian
-from .spherical_to_cartesian_fc import spherical_to_cartesian_fc
-from .to_polar_coordinates import to_polar_coordinates
+from .cartesian_to_spherical import cartesian_to_spherical
+from .cartesian_to_spherical_fc import cartesian_to_spherical_fc
+from .elements_facets_surfaces_over_time import elements_facets_surfaces_over_time
+from .elements_volume import elements_volume
+from .elements_volumes_over_time import elements_volumes_over_time
+from .element_nodal_contribution import element_nodal_contribution
+from .faces_area import faces_area
+from .gauss_to_node import gauss_to_node
+from .integrate_over_elements import integrate_over_elements
+from .normals import normals
+from .normals_provider_nl import normals_provider_nl
+from .rotate import rotate
+from .rotate_fc import rotate_fc
+from .rotate_in_cylindrical_cs import rotate_in_cylindrical_cs
+from .rotate_in_cylindrical_cs_fc import rotate_in_cylindrical_cs_fc
+from .spherical_to_cartesian import spherical_to_cartesian
+from .spherical_to_cartesian_fc import spherical_to_cartesian_fc
+from .to_polar_coordinates import to_polar_coordinates
diff --git a/src/ansys/dpf/core/operators/invariant/__init__.py b/src/ansys/dpf/core/operators/invariant/__init__.py
index 9bc77ab145..54f0de3348 100644
--- a/src/ansys/dpf/core/operators/invariant/__init__.py
+++ b/src/ansys/dpf/core/operators/invariant/__init__.py
@@ -1,15 +1,15 @@
-from .convertnum_bcs_to_nod import convertnum_bcs_to_nod
-from .convertnum_nod_to_bcs import convertnum_nod_to_bcs
-from .convertnum_op import convertnum_op
-from .eigen_values import eigen_values
-from .eigen_values_fc import eigen_values_fc
-from .eigen_vectors import eigen_vectors
-from .eigen_vectors_fc import eigen_vectors_fc
-from .invariants import invariants
-from .invariants_fc import invariants_fc
-from .principal_invariants import principal_invariants
-from .principal_invariants_fc import principal_invariants_fc
-from .segalman_von_mises_eqv import segalman_von_mises_eqv
-from .segalman_von_mises_eqv_fc import segalman_von_mises_eqv_fc
-from .von_mises_eqv import von_mises_eqv
-from .von_mises_eqv_fc import von_mises_eqv_fc
+from .convertnum_bcs_to_nod import convertnum_bcs_to_nod
+from .convertnum_nod_to_bcs import convertnum_nod_to_bcs
+from .convertnum_op import convertnum_op
+from .eigen_values import eigen_values
+from .eigen_values_fc import eigen_values_fc
+from .eigen_vectors import eigen_vectors
+from .eigen_vectors_fc import eigen_vectors_fc
+from .invariants import invariants
+from .invariants_fc import invariants_fc
+from .principal_invariants import principal_invariants
+from .principal_invariants_fc import principal_invariants_fc
+from .segalman_von_mises_eqv import segalman_von_mises_eqv
+from .segalman_von_mises_eqv_fc import segalman_von_mises_eqv_fc
+from .von_mises_eqv import von_mises_eqv
+from .von_mises_eqv_fc import von_mises_eqv_fc
diff --git a/src/ansys/dpf/core/operators/logic/__init__.py b/src/ansys/dpf/core/operators/logic/__init__.py
index c945020942..06ac5d7350 100644
--- a/src/ansys/dpf/core/operators/logic/__init__.py
+++ b/src/ansys/dpf/core/operators/logic/__init__.py
@@ -1,20 +1,20 @@
-from .ascending_sort import ascending_sort
-from .ascending_sort_fc import ascending_sort_fc
-from .component_selector import component_selector
-from .component_selector_fc import component_selector_fc
-from .component_transformer import component_transformer
-from .component_transformer_fc import component_transformer_fc
-from .descending_sort import descending_sort
-from .descending_sort_fc import descending_sort_fc
-from .elementary_data_selector import elementary_data_selector
-from .elementary_data_selector_fc import elementary_data_selector_fc
-from .enrich_materials import enrich_materials
-from .identical_fc import identical_fc
-from .identical_fields import identical_fields
-from .identical_meshes import identical_meshes
-from .identical_property_fields import identical_property_fields
-from .identical_string_fields import identical_string_fields
-from .included_fields import included_fields
-from .solid_shell_fields import solid_shell_fields
-from .split_data_sources import split_data_sources
-from .split_streams import split_streams
+from .ascending_sort import ascending_sort
+from .ascending_sort_fc import ascending_sort_fc
+from .component_selector import component_selector
+from .component_selector_fc import component_selector_fc
+from .component_transformer import component_transformer
+from .component_transformer_fc import component_transformer_fc
+from .descending_sort import descending_sort
+from .descending_sort_fc import descending_sort_fc
+from .elementary_data_selector import elementary_data_selector
+from .elementary_data_selector_fc import elementary_data_selector_fc
+from .enrich_materials import enrich_materials
+from .identical_fc import identical_fc
+from .identical_fields import identical_fields
+from .identical_meshes import identical_meshes
+from .identical_property_fields import identical_property_fields
+from .identical_string_fields import identical_string_fields
+from .included_fields import included_fields
+from .solid_shell_fields import solid_shell_fields
+from .split_data_sources import split_data_sources
+from .split_streams import split_streams
diff --git a/src/ansys/dpf/core/operators/mapping/__init__.py b/src/ansys/dpf/core/operators/mapping/__init__.py
index 13555d8e57..ccd94389a5 100644
--- a/src/ansys/dpf/core/operators/mapping/__init__.py
+++ b/src/ansys/dpf/core/operators/mapping/__init__.py
@@ -1,9 +1,9 @@
-from .fft import fft
-from .find_reduced_coordinates import find_reduced_coordinates
-from .on_coordinates import on_coordinates
-from .on_reduced_coordinates import on_reduced_coordinates
-from .prep_sampling_fft import prep_sampling_fft
-from .prepare_mapping_workflow import prepare_mapping_workflow
-from .scoping_on_coordinates import scoping_on_coordinates
-from .solid_to_skin import solid_to_skin
-from .solid_to_skin_fc import solid_to_skin_fc
+from .fft import fft
+from .find_reduced_coordinates import find_reduced_coordinates
+from .on_coordinates import on_coordinates
+from .on_reduced_coordinates import on_reduced_coordinates
+from .prepare_mapping_workflow import prepare_mapping_workflow
+from .prep_sampling_fft import prep_sampling_fft
+from .scoping_on_coordinates import scoping_on_coordinates
+from .solid_to_skin import solid_to_skin
+from .solid_to_skin_fc import solid_to_skin_fc
diff --git a/src/ansys/dpf/core/operators/math/__init__.py b/src/ansys/dpf/core/operators/math/__init__.py
index 9c74f94fe6..ffe7e59036 100644
--- a/src/ansys/dpf/core/operators/math/__init__.py
+++ b/src/ansys/dpf/core/operators/math/__init__.py
@@ -1,103 +1,101 @@
-from .absolute_value_by_component import absolute_value_by_component
-from .absolute_value_by_component_fc import absolute_value_by_component_fc
-from .accumulate import accumulate
-from .accumulate_fc import accumulate_fc
-from .accumulate_level_over_label_fc import accumulate_level_over_label_fc
-from .accumulate_min_over_label_fc import accumulate_min_over_label_fc
-from .accumulate_over_label_fc import accumulate_over_label_fc
-from .accumulation_per_scoping import accumulation_per_scoping
-from .add import add
-from .add_constant import add_constant
-from .add_constant_fc import add_constant_fc
-from .add_fc import add_fc
-from .amplitude import amplitude
-from .amplitude_fc import amplitude_fc
-from .average_over_label_fc import average_over_label_fc
-from .centroid import centroid
-from .centroid_fc import centroid_fc
-from .component_wise_divide import component_wise_divide
-from .component_wise_divide_fc import component_wise_divide_fc
-from .component_wise_product import component_wise_product
-from .component_wise_product_fc import component_wise_product_fc
-from .compute_residual_and_error import compute_residual_and_error
-from .conjugate import conjugate
-from .correlation import correlation
-from .cos import cos
-from .cos_fc import cos_fc
-from .cplx_derive import cplx_derive
-from .cplx_divide import cplx_divide
-from .cplx_dot import cplx_dot
-from .cplx_multiply import cplx_multiply
-from .cross_product import cross_product
-from .cross_product_fc import cross_product_fc
-from .dot import dot
-from .dot_tensor import dot_tensor
-from .elemental_density import elemental_density
-from .entity_extractor import entity_extractor
-from .exponential import exponential
-from .exponential_fc import exponential_fc
-from .fft_approx import fft_approx
-from .fft_eval import fft_eval
-from .fft_gradient_eval import fft_gradient_eval
-from .fft_multi_harmonic_minmax import fft_multi_harmonic_minmax
-from .generalized_inner_product import generalized_inner_product
-from .generalized_inner_product_fc import generalized_inner_product_fc
-from .img_part import img_part
-from .invert import invert
-from .invert_fc import invert_fc
-from .kronecker_prod import kronecker_prod
-from .linear_combination import linear_combination
-from .ln import ln
-from .ln_fc import ln_fc
-from .mac import mac
-from .make_one_on_comp import make_one_on_comp
-from .matrix_inverse import matrix_inverse
-from .minus import minus
-from .minus_fc import minus_fc
-from .modal_damping_ratio import modal_damping_ratio
-from .modal_participation import modal_participation
-from .modal_superposition import modal_superposition
-from .modulus import modulus
-from .nodal_density import nodal_density
-from .norm import norm
-from .norm_fc import norm_fc
-from .outer_product import outer_product
-from .overall_dot import overall_dot
-from .phase import phase
-from .phase_fc import phase_fc
-from .polar_to_cplx import polar_to_cplx
-from .pow import pow
-from .pow_fc import pow_fc
-from .qr_solve import qr_solve
-from .real_part import real_part
-from .relative_error import relative_error
-from .scale import scale
-from .scale_by_field import scale_by_field
-from .scale_by_field_fc import scale_by_field_fc
-from .scale_fc import scale_fc
-from .sin import sin
-from .sin_fc import sin_fc
-from .sqr import sqr
-from .sqr_fc import sqr_fc
-from .sqrt import sqrt
-from .sqrt_fc import sqrt_fc
-from .svd import svd
-from .sweeping_phase import sweeping_phase
-from .sweeping_phase_fc import sweeping_phase_fc
-from .time_derivation import time_derivation
-from .time_freq_interpolation import time_freq_interpolation
-from .time_integration import time_integration
-from .unit_convert import unit_convert
-from .unit_convert_fc import unit_convert_fc
-from .window_bartlett import window_bartlett
-from .window_bartlett_fc import window_bartlett_fc
-from .window_blackman import window_blackman
-from .window_blackman_fc import window_blackman_fc
-from .window_hamming import window_hamming
-from .window_hamming_fc import window_hamming_fc
-from .window_hanning import window_hanning
-from .window_hanning_fc import window_hanning_fc
-from .window_triangular import window_triangular
-from .window_triangular_fc import window_triangular_fc
-from .window_welch import window_welch
-from .window_welch_fc import window_welch_fc
+from .absolute_value_by_component import absolute_value_by_component
+from .absolute_value_by_component_fc import absolute_value_by_component_fc
+from .accumulate import accumulate
+from .accumulate_fc import accumulate_fc
+from .accumulate_level_over_label_fc import accumulate_level_over_label_fc
+from .accumulate_min_over_label_fc import accumulate_min_over_label_fc
+from .accumulate_over_label_fc import accumulate_over_label_fc
+from .accumulation_per_scoping import accumulation_per_scoping
+from .add import add
+from .add_constant import add_constant
+from .add_constant_fc import add_constant_fc
+from .add_fc import add_fc
+from .amplitude import amplitude
+from .amplitude_fc import amplitude_fc
+from .average_over_label_fc import average_over_label_fc
+from .centroid import centroid
+from .centroid_fc import centroid_fc
+from .component_wise_divide import component_wise_divide
+from .component_wise_divide_fc import component_wise_divide_fc
+from .component_wise_product import component_wise_product
+from .component_wise_product_fc import component_wise_product_fc
+from .compute_residual_and_error import compute_residual_and_error
+from .conjugate import conjugate
+from .correlation import correlation
+from .cos import cos
+from .cos_fc import cos_fc
+from .cplx_derive import cplx_derive
+from .cplx_divide import cplx_divide
+from .cplx_dot import cplx_dot
+from .cplx_multiply import cplx_multiply
+from .cross_product import cross_product
+from .cross_product_fc import cross_product_fc
+from .dot import dot
+from .dot_tensor import dot_tensor
+from .entity_extractor import entity_extractor
+from .exponential import exponential
+from .exponential_fc import exponential_fc
+from .fft_approx import fft_approx
+from .fft_eval import fft_eval
+from .fft_gradient_eval import fft_gradient_eval
+from .fft_multi_harmonic_minmax import fft_multi_harmonic_minmax
+from .generalized_inner_product import generalized_inner_product
+from .generalized_inner_product_fc import generalized_inner_product_fc
+from .img_part import img_part
+from .invert import invert
+from .invert_fc import invert_fc
+from .kronecker_prod import kronecker_prod
+from .linear_combination import linear_combination
+from .ln import ln
+from .ln_fc import ln_fc
+from .mac import mac
+from .make_one_on_comp import make_one_on_comp
+from .matrix_inverse import matrix_inverse
+from .minus import minus
+from .minus_fc import minus_fc
+from .min_max_over_time import min_max_over_time
+from .modal_damping_ratio import modal_damping_ratio
+from .modal_superposition import modal_superposition
+from .modulus import modulus
+from .norm import norm
+from .norm_fc import norm_fc
+from .outer_product import outer_product
+from .overall_dot import overall_dot
+from .phase import phase
+from .phase_fc import phase_fc
+from .polar_to_cplx import polar_to_cplx
+from .pow import pow
+from .pow_fc import pow_fc
+from .qr_solve import qr_solve
+from .real_part import real_part
+from .relative_error import relative_error
+from .scale import scale
+from .scale_by_field import scale_by_field
+from .scale_by_field_fc import scale_by_field_fc
+from .scale_fc import scale_fc
+from .sin import sin
+from .sin_fc import sin_fc
+from .sqr import sqr
+from .sqrt import sqrt
+from .sqrt_fc import sqrt_fc
+from .sqr_fc import sqr_fc
+from .svd import svd
+from .sweeping_phase import sweeping_phase
+from .sweeping_phase_fc import sweeping_phase_fc
+from .time_derivation import time_derivation
+from .time_freq_interpolation import time_freq_interpolation
+from .time_integration import time_integration
+from .unit_convert import unit_convert
+from .unit_convert_fc import unit_convert_fc
+from .window_bartlett import window_bartlett
+from .window_bartlett_fc import window_bartlett_fc
+from .window_blackman import window_blackman
+from .window_blackman_fc import window_blackman_fc
+from .window_hamming import window_hamming
+from .window_hamming_fc import window_hamming_fc
+from .window_hanning import window_hanning
+from .window_hanning_fc import window_hanning_fc
+from .window_triangular import window_triangular
+from .window_triangular_fc import window_triangular_fc
+from .window_welch import window_welch
+from .window_welch_fc import window_welch_fc
diff --git a/src/ansys/dpf/core/operators/math/elemental_density.py b/src/ansys/dpf/core/operators/math/elemental_density.py
deleted file mode 100644
index f4615603f2..0000000000
--- a/src/ansys/dpf/core/operators/math/elemental_density.py
+++ /dev/null
@@ -1,346 +0,0 @@
-"""
-elemental_density
-=================
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class elemental_density(Operator):
- """Extract Elemental Topology Density result from topo solver output.
- Default behavior is to use graphical density.
-
- Parameters
- ----------
- time_scoping : Scoping, optional
- mesh_scoping : Scoping, optional
- streams : StreamsContainer, optional
- Topo file stream.
- data_sources : DataSources, optional
- Topo file data source.
- custom_ponderation_name : str
- Take custom ponderation_field from the topo
- file by name
-
- Returns
- -------
- field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.math.elemental_density()
-
- >>> # Make input connections
- >>> my_time_scoping = dpf.Scoping()
- >>> op.inputs.time_scoping.connect(my_time_scoping)
- >>> my_mesh_scoping = dpf.Scoping()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> my_streams = dpf.StreamsContainer()
- >>> op.inputs.streams.connect(my_streams)
- >>> my_data_sources = dpf.DataSources()
- >>> op.inputs.data_sources.connect(my_data_sources)
- >>> my_custom_ponderation_name = str()
- >>> op.inputs.custom_ponderation_name.connect(my_custom_ponderation_name)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.math.elemental_density(
- ... time_scoping=my_time_scoping,
- ... mesh_scoping=my_mesh_scoping,
- ... streams=my_streams,
- ... data_sources=my_data_sources,
- ... custom_ponderation_name=my_custom_ponderation_name,
- ... )
-
- >>> # Get output data
- >>> result_field = op.outputs.field()
- """
-
- def __init__(
- self,
- time_scoping=None,
- mesh_scoping=None,
- streams=None,
- data_sources=None,
- custom_ponderation_name=None,
- config=None,
- server=None,
- ):
- super().__init__(
- name="hdf5::topo::elemental_density", config=config, server=server
- )
- self._inputs = InputsElementalDensity(self)
- self._outputs = OutputsElementalDensity(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 streams is not None:
- self.inputs.streams.connect(streams)
- if data_sources is not None:
- self.inputs.data_sources.connect(data_sources)
- if custom_ponderation_name is not None:
- self.inputs.custom_ponderation_name.connect(custom_ponderation_name)
-
- @staticmethod
- def _spec():
- description = """Extract Elemental Topology Density result from topo solver output.
- Default behavior is to use graphical density."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="time_scoping",
- type_names=["scoping"],
- optional=True,
- document="""""",
- ),
- 1: PinSpecification(
- name="mesh_scoping",
- type_names=["scoping"],
- optional=True,
- document="""""",
- ),
- 3: PinSpecification(
- name="streams",
- type_names=["streams_container"],
- optional=True,
- document="""Topo file stream.""",
- ),
- 4: PinSpecification(
- name="data_sources",
- type_names=["data_sources"],
- optional=True,
- document="""Topo file data source.""",
- ),
- 200: PinSpecification(
- name="custom_ponderation_name",
- type_names=["string"],
- optional=False,
- document="""Take custom ponderation_field from the topo
- file by name""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="field",
- type_names=["field"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(
- name="hdf5::topo::elemental_density", server=server
- )
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsElementalDensity
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsElementalDensity
- """
- return super().outputs
-
-
-class InputsElementalDensity(_Inputs):
- """Intermediate class used to connect user inputs to
- elemental_density operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.elemental_density()
- >>> my_time_scoping = dpf.Scoping()
- >>> op.inputs.time_scoping.connect(my_time_scoping)
- >>> my_mesh_scoping = dpf.Scoping()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> my_streams = dpf.StreamsContainer()
- >>> op.inputs.streams.connect(my_streams)
- >>> my_data_sources = dpf.DataSources()
- >>> op.inputs.data_sources.connect(my_data_sources)
- >>> my_custom_ponderation_name = str()
- >>> op.inputs.custom_ponderation_name.connect(my_custom_ponderation_name)
- """
-
- def __init__(self, op: Operator):
- super().__init__(elemental_density._spec().inputs, op)
- self._time_scoping = Input(elemental_density._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._time_scoping)
- self._mesh_scoping = Input(elemental_density._spec().input_pin(1), 1, op, -1)
- self._inputs.append(self._mesh_scoping)
- self._streams = Input(elemental_density._spec().input_pin(3), 3, op, -1)
- self._inputs.append(self._streams)
- self._data_sources = Input(elemental_density._spec().input_pin(4), 4, op, -1)
- self._inputs.append(self._data_sources)
- self._custom_ponderation_name = Input(
- elemental_density._spec().input_pin(200), 200, op, -1
- )
- self._inputs.append(self._custom_ponderation_name)
-
- @property
- def time_scoping(self):
- """Allows to connect time_scoping input to the operator.
-
- Parameters
- ----------
- my_time_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.elemental_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):
- """Allows to connect mesh_scoping input to the operator.
-
- Parameters
- ----------
- my_mesh_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.elemental_density()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> # or
- >>> op.inputs.mesh_scoping(my_mesh_scoping)
- """
- return self._mesh_scoping
-
- @property
- def streams(self):
- """Allows to connect streams input to the operator.
-
- Topo file stream.
-
- Parameters
- ----------
- my_streams : StreamsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.elemental_density()
- >>> op.inputs.streams.connect(my_streams)
- >>> # or
- >>> op.inputs.streams(my_streams)
- """
- return self._streams
-
- @property
- def data_sources(self):
- """Allows to connect data_sources input to the operator.
-
- Topo file data source.
-
- Parameters
- ----------
- my_data_sources : DataSources
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.elemental_density()
- >>> op.inputs.data_sources.connect(my_data_sources)
- >>> # or
- >>> op.inputs.data_sources(my_data_sources)
- """
- return self._data_sources
-
- @property
- def custom_ponderation_name(self):
- """Allows to connect custom_ponderation_name input to the operator.
-
- Take custom ponderation_field from the topo
- file by name
-
- Parameters
- ----------
- my_custom_ponderation_name : str
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.elemental_density()
- >>> op.inputs.custom_ponderation_name.connect(my_custom_ponderation_name)
- >>> # or
- >>> op.inputs.custom_ponderation_name(my_custom_ponderation_name)
- """
- return self._custom_ponderation_name
-
-
-class OutputsElementalDensity(_Outputs):
- """Intermediate class used to get outputs from
- elemental_density operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.elemental_density()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """
-
- def __init__(self, op: Operator):
- super().__init__(elemental_density._spec().outputs, op)
- self._field = Output(elemental_density._spec().output_pin(0), 0, op)
- self._outputs.append(self._field)
-
- @property
- def field(self):
- """Allows to get field output of the operator
-
- Returns
- ----------
- my_field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.elemental_density()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """ # noqa: E501
- return self._field
diff --git a/src/ansys/dpf/core/operators/math/modal_participation.py b/src/ansys/dpf/core/operators/math/modal_participation.py
deleted file mode 100644
index 5ab608582d..0000000000
--- a/src/ansys/dpf/core/operators/math/modal_participation.py
+++ /dev/null
@@ -1,346 +0,0 @@
-"""
-modal_participation
-===================
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class modal_participation(Operator):
- """Compute the modal participation factor for a given vector field V,
- defined as sum_i ( V .dot. mode_shape_i * ponderation ).
-
- Parameters
- ----------
- v_real : Field
- Real part of field v
- v_imag : Field
- Imag part of field v
- mode_shapes : FieldsContainer
- ponderation : Field, optional
- force_label_space : dict, optional
- If set, will force a label space for output
- result.
-
- Returns
- -------
- output : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.math.modal_participation()
-
- >>> # Make input connections
- >>> my_v_real = dpf.Field()
- >>> op.inputs.v_real.connect(my_v_real)
- >>> my_v_imag = dpf.Field()
- >>> op.inputs.v_imag.connect(my_v_imag)
- >>> my_mode_shapes = dpf.FieldsContainer()
- >>> op.inputs.mode_shapes.connect(my_mode_shapes)
- >>> my_ponderation = dpf.Field()
- >>> op.inputs.ponderation.connect(my_ponderation)
- >>> my_force_label_space = dict()
- >>> op.inputs.force_label_space.connect(my_force_label_space)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.math.modal_participation(
- ... v_real=my_v_real,
- ... v_imag=my_v_imag,
- ... mode_shapes=my_mode_shapes,
- ... ponderation=my_ponderation,
- ... force_label_space=my_force_label_space,
- ... )
-
- >>> # Get output data
- >>> result_output = op.outputs.output()
- """
-
- def __init__(
- self,
- v_real=None,
- v_imag=None,
- mode_shapes=None,
- ponderation=None,
- force_label_space=None,
- config=None,
- server=None,
- ):
- super().__init__(
- name="harmonic::modal_participation", config=config, server=server
- )
- self._inputs = InputsModalParticipation(self)
- self._outputs = OutputsModalParticipation(self)
- if v_real is not None:
- self.inputs.v_real.connect(v_real)
- if v_imag is not None:
- self.inputs.v_imag.connect(v_imag)
- if mode_shapes is not None:
- self.inputs.mode_shapes.connect(mode_shapes)
- if ponderation is not None:
- self.inputs.ponderation.connect(ponderation)
- if force_label_space is not None:
- self.inputs.force_label_space.connect(force_label_space)
-
- @staticmethod
- def _spec():
- description = """Compute the modal participation factor for a given vector field V,
- defined as sum_i ( V .dot. mode_shape_i * ponderation )."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="v_real",
- type_names=["field"],
- optional=False,
- document="""Real part of field v""",
- ),
- 1: PinSpecification(
- name="v_imag",
- type_names=["field"],
- optional=False,
- document="""Imag part of field v""",
- ),
- 2: PinSpecification(
- name="mode_shapes",
- type_names=["fields_container"],
- optional=False,
- document="""""",
- ),
- 3: PinSpecification(
- name="ponderation",
- type_names=["field"],
- optional=True,
- document="""""",
- ),
- 4: PinSpecification(
- name="force_label_space",
- type_names=["label_space"],
- optional=True,
- document="""If set, will force a label space for output
- result.""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="output",
- type_names=["fields_container"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(
- name="harmonic::modal_participation", server=server
- )
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsModalParticipation
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsModalParticipation
- """
- return super().outputs
-
-
-class InputsModalParticipation(_Inputs):
- """Intermediate class used to connect user inputs to
- modal_participation operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.modal_participation()
- >>> my_v_real = dpf.Field()
- >>> op.inputs.v_real.connect(my_v_real)
- >>> my_v_imag = dpf.Field()
- >>> op.inputs.v_imag.connect(my_v_imag)
- >>> my_mode_shapes = dpf.FieldsContainer()
- >>> op.inputs.mode_shapes.connect(my_mode_shapes)
- >>> my_ponderation = dpf.Field()
- >>> op.inputs.ponderation.connect(my_ponderation)
- >>> my_force_label_space = dict()
- >>> op.inputs.force_label_space.connect(my_force_label_space)
- """
-
- def __init__(self, op: Operator):
- super().__init__(modal_participation._spec().inputs, op)
- self._v_real = Input(modal_participation._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._v_real)
- self._v_imag = Input(modal_participation._spec().input_pin(1), 1, op, -1)
- self._inputs.append(self._v_imag)
- self._mode_shapes = Input(modal_participation._spec().input_pin(2), 2, op, -1)
- self._inputs.append(self._mode_shapes)
- self._ponderation = Input(modal_participation._spec().input_pin(3), 3, op, -1)
- self._inputs.append(self._ponderation)
- self._force_label_space = Input(
- modal_participation._spec().input_pin(4), 4, op, -1
- )
- self._inputs.append(self._force_label_space)
-
- @property
- def v_real(self):
- """Allows to connect v_real input to the operator.
-
- Real part of field v
-
- Parameters
- ----------
- my_v_real : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.modal_participation()
- >>> op.inputs.v_real.connect(my_v_real)
- >>> # or
- >>> op.inputs.v_real(my_v_real)
- """
- return self._v_real
-
- @property
- def v_imag(self):
- """Allows to connect v_imag input to the operator.
-
- Imag part of field v
-
- Parameters
- ----------
- my_v_imag : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.modal_participation()
- >>> op.inputs.v_imag.connect(my_v_imag)
- >>> # or
- >>> op.inputs.v_imag(my_v_imag)
- """
- return self._v_imag
-
- @property
- def mode_shapes(self):
- """Allows to connect mode_shapes input to the operator.
-
- Parameters
- ----------
- my_mode_shapes : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.modal_participation()
- >>> op.inputs.mode_shapes.connect(my_mode_shapes)
- >>> # or
- >>> op.inputs.mode_shapes(my_mode_shapes)
- """
- return self._mode_shapes
-
- @property
- def ponderation(self):
- """Allows to connect ponderation input to the operator.
-
- Parameters
- ----------
- my_ponderation : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.modal_participation()
- >>> op.inputs.ponderation.connect(my_ponderation)
- >>> # or
- >>> op.inputs.ponderation(my_ponderation)
- """
- return self._ponderation
-
- @property
- def force_label_space(self):
- """Allows to connect force_label_space input to the operator.
-
- If set, will force a label space for output
- result.
-
- Parameters
- ----------
- my_force_label_space : dict
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.modal_participation()
- >>> op.inputs.force_label_space.connect(my_force_label_space)
- >>> # or
- >>> op.inputs.force_label_space(my_force_label_space)
- """
- return self._force_label_space
-
-
-class OutputsModalParticipation(_Outputs):
- """Intermediate class used to get outputs from
- modal_participation operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.modal_participation()
- >>> # Connect inputs : op.inputs. ...
- >>> result_output = op.outputs.output()
- """
-
- def __init__(self, op: Operator):
- super().__init__(modal_participation._spec().outputs, op)
- self._output = Output(modal_participation._spec().output_pin(0), 0, op)
- self._outputs.append(self._output)
-
- @property
- def output(self):
- """Allows to get output output of the operator
-
- Returns
- ----------
- my_output : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.modal_participation()
- >>> # Connect inputs : op.inputs. ...
- >>> result_output = op.outputs.output()
- """ # noqa: E501
- return self._output
diff --git a/src/ansys/dpf/core/operators/math/nodal_density.py b/src/ansys/dpf/core/operators/math/nodal_density.py
deleted file mode 100644
index 9f1e5dfe1f..0000000000
--- a/src/ansys/dpf/core/operators/math/nodal_density.py
+++ /dev/null
@@ -1,342 +0,0 @@
-"""
-nodal_density
-=============
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class nodal_density(Operator):
- """Extract Nodal Topology Density result from topo solver output. Default
- behavior is to use graphical density.
-
- Parameters
- ----------
- time_scoping : Scoping, optional
- mesh_scoping : Scoping, optional
- streams : StreamsContainer, optional
- Topo file stream.
- data_sources : DataSources, optional
- Topo file data source.
- custom_ponderation_name : str
- Take custom ponderation_field from the topo
- file by name
-
- Returns
- -------
- field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.math.nodal_density()
-
- >>> # Make input connections
- >>> my_time_scoping = dpf.Scoping()
- >>> op.inputs.time_scoping.connect(my_time_scoping)
- >>> my_mesh_scoping = dpf.Scoping()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> my_streams = dpf.StreamsContainer()
- >>> op.inputs.streams.connect(my_streams)
- >>> my_data_sources = dpf.DataSources()
- >>> op.inputs.data_sources.connect(my_data_sources)
- >>> my_custom_ponderation_name = str()
- >>> op.inputs.custom_ponderation_name.connect(my_custom_ponderation_name)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.math.nodal_density(
- ... time_scoping=my_time_scoping,
- ... mesh_scoping=my_mesh_scoping,
- ... streams=my_streams,
- ... data_sources=my_data_sources,
- ... custom_ponderation_name=my_custom_ponderation_name,
- ... )
-
- >>> # Get output data
- >>> result_field = op.outputs.field()
- """
-
- def __init__(
- self,
- time_scoping=None,
- mesh_scoping=None,
- streams=None,
- data_sources=None,
- custom_ponderation_name=None,
- config=None,
- server=None,
- ):
- super().__init__(name="hdf5::topo::nodal_density", config=config, server=server)
- self._inputs = InputsNodalDensity(self)
- self._outputs = OutputsNodalDensity(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 streams is not None:
- self.inputs.streams.connect(streams)
- if data_sources is not None:
- self.inputs.data_sources.connect(data_sources)
- if custom_ponderation_name is not None:
- self.inputs.custom_ponderation_name.connect(custom_ponderation_name)
-
- @staticmethod
- def _spec():
- description = """Extract Nodal Topology Density result from topo solver output. Default
- behavior is to use graphical density."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="time_scoping",
- type_names=["scoping"],
- optional=True,
- document="""""",
- ),
- 1: PinSpecification(
- name="mesh_scoping",
- type_names=["scoping"],
- optional=True,
- document="""""",
- ),
- 3: PinSpecification(
- name="streams",
- type_names=["streams_container"],
- optional=True,
- document="""Topo file stream.""",
- ),
- 4: PinSpecification(
- name="data_sources",
- type_names=["data_sources"],
- optional=True,
- document="""Topo file data source.""",
- ),
- 200: PinSpecification(
- name="custom_ponderation_name",
- type_names=["string"],
- optional=False,
- document="""Take custom ponderation_field from the topo
- file by name""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="field",
- type_names=["field"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(name="hdf5::topo::nodal_density", server=server)
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsNodalDensity
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsNodalDensity
- """
- return super().outputs
-
-
-class InputsNodalDensity(_Inputs):
- """Intermediate class used to connect user inputs to
- nodal_density operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.nodal_density()
- >>> my_time_scoping = dpf.Scoping()
- >>> op.inputs.time_scoping.connect(my_time_scoping)
- >>> my_mesh_scoping = dpf.Scoping()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> my_streams = dpf.StreamsContainer()
- >>> op.inputs.streams.connect(my_streams)
- >>> my_data_sources = dpf.DataSources()
- >>> op.inputs.data_sources.connect(my_data_sources)
- >>> my_custom_ponderation_name = str()
- >>> op.inputs.custom_ponderation_name.connect(my_custom_ponderation_name)
- """
-
- def __init__(self, op: Operator):
- super().__init__(nodal_density._spec().inputs, op)
- self._time_scoping = Input(nodal_density._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._time_scoping)
- self._mesh_scoping = Input(nodal_density._spec().input_pin(1), 1, op, -1)
- self._inputs.append(self._mesh_scoping)
- self._streams = Input(nodal_density._spec().input_pin(3), 3, op, -1)
- self._inputs.append(self._streams)
- self._data_sources = Input(nodal_density._spec().input_pin(4), 4, op, -1)
- self._inputs.append(self._data_sources)
- self._custom_ponderation_name = Input(
- nodal_density._spec().input_pin(200), 200, op, -1
- )
- self._inputs.append(self._custom_ponderation_name)
-
- @property
- def time_scoping(self):
- """Allows to connect time_scoping input to the operator.
-
- Parameters
- ----------
- my_time_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.nodal_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):
- """Allows to connect mesh_scoping input to the operator.
-
- Parameters
- ----------
- my_mesh_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.nodal_density()
- >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
- >>> # or
- >>> op.inputs.mesh_scoping(my_mesh_scoping)
- """
- return self._mesh_scoping
-
- @property
- def streams(self):
- """Allows to connect streams input to the operator.
-
- Topo file stream.
-
- Parameters
- ----------
- my_streams : StreamsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.nodal_density()
- >>> op.inputs.streams.connect(my_streams)
- >>> # or
- >>> op.inputs.streams(my_streams)
- """
- return self._streams
-
- @property
- def data_sources(self):
- """Allows to connect data_sources input to the operator.
-
- Topo file data source.
-
- Parameters
- ----------
- my_data_sources : DataSources
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.nodal_density()
- >>> op.inputs.data_sources.connect(my_data_sources)
- >>> # or
- >>> op.inputs.data_sources(my_data_sources)
- """
- return self._data_sources
-
- @property
- def custom_ponderation_name(self):
- """Allows to connect custom_ponderation_name input to the operator.
-
- Take custom ponderation_field from the topo
- file by name
-
- Parameters
- ----------
- my_custom_ponderation_name : str
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.nodal_density()
- >>> op.inputs.custom_ponderation_name.connect(my_custom_ponderation_name)
- >>> # or
- >>> op.inputs.custom_ponderation_name(my_custom_ponderation_name)
- """
- return self._custom_ponderation_name
-
-
-class OutputsNodalDensity(_Outputs):
- """Intermediate class used to get outputs from
- nodal_density operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.nodal_density()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """
-
- def __init__(self, op: Operator):
- super().__init__(nodal_density._spec().outputs, op)
- self._field = Output(nodal_density._spec().output_pin(0), 0, op)
- self._outputs.append(self._field)
-
- @property
- def field(self):
- """Allows to get field output of the operator
-
- Returns
- ----------
- my_field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.math.nodal_density()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """ # noqa: E501
- return self._field
diff --git a/src/ansys/dpf/core/operators/mesh/__init__.py b/src/ansys/dpf/core/operators/mesh/__init__.py
index 83ad8525f0..b20edea73d 100644
--- a/src/ansys/dpf/core/operators/mesh/__init__.py
+++ b/src/ansys/dpf/core/operators/mesh/__init__.py
@@ -1,31 +1,32 @@
-from .beam_properties import beam_properties
-from .change_cs import change_cs
-from .combine_levelset import combine_levelset
-from .decimate_mesh import decimate_mesh
-from .exclude_levelset import exclude_levelset
-from .external_layer import external_layer
-from .from_field import from_field
-from .from_scoping import from_scoping
-from .from_scopings import from_scopings
-from .iso_surfaces import iso_surfaces
-from .make_plane_levelset import make_plane_levelset
-from .make_sphere_levelset import make_sphere_levelset
-from .mesh_clip import mesh_clip
-from .mesh_cut import mesh_cut
-from .mesh_extraction import mesh_extraction
-from .mesh_get_attribute import mesh_get_attribute
-from .mesh_plan_clip import mesh_plan_clip
-from .mesh_provider import mesh_provider
-from .mesh_to_graphics import mesh_to_graphics
-from .mesh_to_graphics_edges import mesh_to_graphics_edges
-from .mesh_to_pyvista import mesh_to_pyvista
-from .mesh_to_tetra import mesh_to_tetra
-from .meshes_provider import meshes_provider
-from .node_coordinates import node_coordinates
-from .points_from_coordinates import points_from_coordinates
-from .skin import skin
-from .split_fields import split_fields
-from .split_mesh import split_mesh
-from .stl_export import stl_export
-from .tri_mesh_skin import tri_mesh_skin
-from .wireframe import wireframe
+from .acmo_mesh_provider import acmo_mesh_provider
+from .beam_properties import beam_properties
+from .change_cs import change_cs
+from .combine_levelset import combine_levelset
+from .decimate_mesh import decimate_mesh
+from .exclude_levelset import exclude_levelset
+from .external_layer import external_layer
+from .from_field import from_field
+from .from_scoping import from_scoping
+from .from_scopings import from_scopings
+from .iso_surfaces import iso_surfaces
+from .make_plane_levelset import make_plane_levelset
+from .make_sphere_levelset import make_sphere_levelset
+from .meshes_provider import meshes_provider
+from .mesh_clip import mesh_clip
+from .mesh_cut import mesh_cut
+from .mesh_extraction import mesh_extraction
+from .mesh_get_attribute import mesh_get_attribute
+from .mesh_plan_clip import mesh_plan_clip
+from .mesh_provider import mesh_provider
+from .mesh_to_graphics import mesh_to_graphics
+from .mesh_to_graphics_edges import mesh_to_graphics_edges
+from .mesh_to_pyvista import mesh_to_pyvista
+from .mesh_to_tetra import mesh_to_tetra
+from .node_coordinates import node_coordinates
+from .points_from_coordinates import points_from_coordinates
+from .skin import skin
+from .split_fields import split_fields
+from .split_mesh import split_mesh
+from .stl_export import stl_export
+from .tri_mesh_skin import tri_mesh_skin
+from .wireframe import wireframe
diff --git a/src/ansys/dpf/core/operators/mesh/skin.py b/src/ansys/dpf/core/operators/mesh/skin.py
index d09c7c0c59..4a07d76979 100644
--- a/src/ansys/dpf/core/operators/mesh/skin.py
+++ b/src/ansys/dpf/core/operators/mesh/skin.py
@@ -29,6 +29,10 @@ class skin(Operator):
mesh shell elements (boolean = 1) are
duplicated, one per each orientation,
or (boolean = 0) remain unchanged.
+ add_beam : bool, optional
+ If input mesh contains beam elements, output
+ mesh beam elements (boolean = 1) are
+ added or (boolean = 0) are ignored.
Returns
-------
@@ -67,12 +71,15 @@ class skin(Operator):
>>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
>>> my_duplicate_shell = bool()
>>> op.inputs.duplicate_shell.connect(my_duplicate_shell)
+ >>> my_add_beam = bool()
+ >>> op.inputs.add_beam.connect(my_add_beam)
>>> # Instantiate operator and connect inputs in one line
>>> op = dpf.operators.mesh.skin(
... mesh=my_mesh,
... mesh_scoping=my_mesh_scoping,
... duplicate_shell=my_duplicate_shell,
+ ... add_beam=my_add_beam,
... )
>>> # Get output data
@@ -88,6 +95,7 @@ def __init__(
mesh=None,
mesh_scoping=None,
duplicate_shell=None,
+ add_beam=None,
config=None,
server=None,
):
@@ -100,6 +108,8 @@ def __init__(
self.inputs.mesh_scoping.connect(mesh_scoping)
if duplicate_shell is not None:
self.inputs.duplicate_shell.connect(duplicate_shell)
+ if add_beam is not None:
+ self.inputs.add_beam.connect(add_beam)
@staticmethod
def _spec():
@@ -133,6 +143,14 @@ def _spec():
duplicated, one per each orientation,
or (boolean = 0) remain unchanged.""",
),
+ 3: PinSpecification(
+ name="add_beam",
+ type_names=["bool"],
+ optional=True,
+ document="""If input mesh contains beam elements, output
+ mesh beam elements (boolean = 1) are
+ added or (boolean = 0) are ignored.""",
+ ),
},
map_output_pin_spec={
0: PinSpecification(
@@ -232,6 +250,8 @@ class InputsSkin(_Inputs):
>>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
>>> my_duplicate_shell = bool()
>>> op.inputs.duplicate_shell.connect(my_duplicate_shell)
+ >>> my_add_beam = bool()
+ >>> op.inputs.add_beam.connect(my_add_beam)
"""
def __init__(self, op: Operator):
@@ -242,6 +262,8 @@ def __init__(self, op: Operator):
self._inputs.append(self._mesh_scoping)
self._duplicate_shell = Input(skin._spec().input_pin(2), 2, op, -1)
self._inputs.append(self._duplicate_shell)
+ self._add_beam = Input(skin._spec().input_pin(3), 3, op, -1)
+ self._inputs.append(self._add_beam)
@property
def mesh(self):
@@ -308,6 +330,28 @@ def duplicate_shell(self):
"""
return self._duplicate_shell
+ @property
+ def add_beam(self):
+ """Allows to connect add_beam input to the operator.
+
+ If input mesh contains beam elements, output
+ mesh beam elements (boolean = 1) are
+ added or (boolean = 0) are ignored.
+
+ Parameters
+ ----------
+ my_add_beam : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.mesh.skin()
+ >>> op.inputs.add_beam.connect(my_add_beam)
+ >>> # or
+ >>> op.inputs.add_beam(my_add_beam)
+ """
+ return self._add_beam
+
class OutputsSkin(_Outputs):
"""Intermediate class used to get outputs from
diff --git a/src/ansys/dpf/core/operators/metadata/__init__.py b/src/ansys/dpf/core/operators/metadata/__init__.py
index e96bcc5fbd..9355e95dce 100644
--- a/src/ansys/dpf/core/operators/metadata/__init__.py
+++ b/src/ansys/dpf/core/operators/metadata/__init__.py
@@ -1,16 +1,16 @@
-from .boundary_condition_provider import boundary_condition_provider
-from .cyclic_mesh_expansion import cyclic_mesh_expansion
-from .cyclic_support_provider import cyclic_support_provider
-from .datasources_provider import datasources_provider
-from .integrate_over_time_freq import integrate_over_time_freq
-from .is_cyclic import is_cyclic
-from .material_support_provider import material_support_provider
-from .mesh_info_provider import mesh_info_provider
-from .mesh_property_provider import mesh_property_provider
-from .mesh_selection_manager_provider import mesh_selection_manager_provider
-from .mesh_support_provider import mesh_support_provider
-from .property_field_provider_by_name import property_field_provider_by_name
-from .result_info_provider import result_info_provider
-from .streams_provider import streams_provider
-from .time_freq_provider import time_freq_provider
-from .time_freq_support_get_attribute import time_freq_support_get_attribute
+from .boundary_condition_provider import boundary_condition_provider
+from .cyclic_mesh_expansion import cyclic_mesh_expansion
+from .cyclic_support_provider import cyclic_support_provider
+from .datasources_provider import datasources_provider
+from .integrate_over_time_freq import integrate_over_time_freq
+from .is_cyclic import is_cyclic
+from .material_support_provider import material_support_provider
+from .mesh_info_provider import mesh_info_provider
+from .mesh_property_provider import mesh_property_provider
+from .mesh_selection_manager_provider import mesh_selection_manager_provider
+from .mesh_support_provider import mesh_support_provider
+from .property_field_provider_by_name import property_field_provider_by_name
+from .result_info_provider import result_info_provider
+from .streams_provider import streams_provider
+from .time_freq_provider import time_freq_provider
+from .time_freq_support_get_attribute import time_freq_support_get_attribute
diff --git a/src/ansys/dpf/core/operators/min_max/__init__.py b/src/ansys/dpf/core/operators/min_max/__init__.py
index 9bbb261ae9..624fe65931 100644
--- a/src/ansys/dpf/core/operators/min_max/__init__.py
+++ b/src/ansys/dpf/core/operators/min_max/__init__.py
@@ -1,16 +1,16 @@
-from .max_by_component import max_by_component
-from .max_over_phase import max_over_phase
-from .max_over_time_by_entity import max_over_time_by_entity
-from .min_by_component import min_by_component
-from .min_max import min_max
-from .min_max_by_entity import min_max_by_entity
-from .min_max_by_time import min_max_by_time
-from .min_max_fc import min_max_fc
-from .min_max_fc_inc import min_max_fc_inc
-from .min_max_inc import min_max_inc
-from .min_max_over_label_fc import min_max_over_label_fc
-from .min_max_over_time_by_entity import min_max_over_time_by_entity
-from .min_over_time_by_entity import min_over_time_by_entity
-from .phase_of_max import phase_of_max
-from .time_of_max_by_entity import time_of_max_by_entity
-from .time_of_min_by_entity import time_of_min_by_entity
+from .max_by_component import max_by_component
+from .max_over_phase import max_over_phase
+from .max_over_time_by_entity import max_over_time_by_entity
+from .min_by_component import min_by_component
+from .min_max import min_max
+from .min_max_by_entity import min_max_by_entity
+from .min_max_by_time import min_max_by_time
+from .min_max_fc import min_max_fc
+from .min_max_fc_inc import min_max_fc_inc
+from .min_max_inc import min_max_inc
+from .min_max_over_label_fc import min_max_over_label_fc
+from .min_max_over_time_by_entity import min_max_over_time_by_entity
+from .min_over_time_by_entity import min_over_time_by_entity
+from .phase_of_max import phase_of_max
+from .time_of_max_by_entity import time_of_max_by_entity
+from .time_of_min_by_entity import time_of_min_by_entity
diff --git a/src/ansys/dpf/core/operators/result/__init__.py b/src/ansys/dpf/core/operators/result/__init__.py
index 1225981ae3..5beffae008 100644
--- a/src/ansys/dpf/core/operators/result/__init__.py
+++ b/src/ansys/dpf/core/operators/result/__init__.py
@@ -1,318 +1,319 @@
-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 .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
-from .beam_axial_force import beam_axial_force
-from .beam_axial_plastic_strain import beam_axial_plastic_strain
-from .beam_axial_stress import beam_axial_stress
-from .beam_axial_total_strain import beam_axial_total_strain
-from .beam_rs_shear_stress import beam_rs_shear_stress
-from .beam_s_bending_moment import beam_s_bending_moment
-from .beam_s_shear_force import beam_s_shear_force
-from .beam_t_bending_moment import beam_t_bending_moment
-from .beam_t_shear_force import beam_t_shear_force
-from .beam_torsional_moment import beam_torsional_moment
-from .beam_tr_shear_stress import beam_tr_shear_stress
-from .cms_dst_table_provider import cms_dst_table_provider
-from .cms_matrices_provider import cms_matrices_provider
-from .cms_subfile_info_provider import cms_subfile_info_provider
-from .co_energy import co_energy
-from .compute_invariant_terms_motion import compute_invariant_terms_motion
-from .compute_invariant_terms_rbd import compute_invariant_terms_rbd
-from .compute_stress import compute_stress
-from .compute_stress_1 import compute_stress_1
-from .compute_stress_2 import compute_stress_2
-from .compute_stress_3 import compute_stress_3
-from .compute_stress_X import compute_stress_X
-from .compute_stress_XY import compute_stress_XY
-from .compute_stress_XZ import compute_stress_XZ
-from .compute_stress_Y import compute_stress_Y
-from .compute_stress_YZ import compute_stress_YZ
-from .compute_stress_Z import compute_stress_Z
-from .compute_stress_von_mises import compute_stress_von_mises
-from .compute_total_strain import compute_total_strain
-from .compute_total_strain_1 import compute_total_strain_1
-from .compute_total_strain_2 import compute_total_strain_2
-from .compute_total_strain_3 import compute_total_strain_3
-from .compute_total_strain_X import compute_total_strain_X
-from .compute_total_strain_XY import compute_total_strain_XY
-from .compute_total_strain_XZ import compute_total_strain_XZ
-from .compute_total_strain_Y import compute_total_strain_Y
-from .compute_total_strain_YZ import compute_total_strain_YZ
-from .compute_total_strain_Z import compute_total_strain_Z
-from .contact_fluid_penetration_pressure import contact_fluid_penetration_pressure
-from .contact_friction_stress import contact_friction_stress
-from .contact_gap_distance import contact_gap_distance
-from .contact_penetration import contact_penetration
-from .contact_pressure import contact_pressure
-from .contact_sliding_distance import contact_sliding_distance
-from .contact_status import contact_status
-from .contact_surface_heat_flux import contact_surface_heat_flux
-from .contact_total_stress import contact_total_stress
-from .coordinate_system import coordinate_system
-from .coordinates import coordinates
-from .creep_strain_energy_density import creep_strain_energy_density
-from .current_density import current_density
-from .custom import custom
-from .cyclic_analytic_seqv_max import cyclic_analytic_seqv_max
-from .cyclic_analytic_usum_max import cyclic_analytic_usum_max
-from .cyclic_equivalent_mass import cyclic_equivalent_mass
-from .cyclic_expanded_acceleration import cyclic_expanded_acceleration
-from .cyclic_expanded_displacement import cyclic_expanded_displacement
-from .cyclic_expanded_el_strain import cyclic_expanded_el_strain
-from .cyclic_expanded_enf import cyclic_expanded_enf
-from .cyclic_expanded_heat_flux import cyclic_expanded_heat_flux
-from .cyclic_expanded_stress import cyclic_expanded_stress
-from .cyclic_expanded_temperature import cyclic_expanded_temperature
-from .cyclic_expanded_velocity import cyclic_expanded_velocity
-from .cyclic_expansion import cyclic_expansion
-from .cyclic_kinetic_energy import cyclic_kinetic_energy
-from .cyclic_nmisc import cyclic_nmisc
-from .cyclic_strain_energy import cyclic_strain_energy
-from .cyclic_volume import cyclic_volume
-from .density import density
-from .displacement import displacement
-from .displacement_X import displacement_X
-from .displacement_Y import displacement_Y
-from .displacement_Z import displacement_Z
-from .div_lighthill_tensor import div_lighthill_tensor
-from .dynamic_viscosity import dynamic_viscosity
-from .elastic_strain import elastic_strain
-from .elastic_strain_X import elastic_strain_X
-from .elastic_strain_XY import elastic_strain_XY
-from .elastic_strain_XZ import elastic_strain_XZ
-from .elastic_strain_Y import elastic_strain_Y
-from .elastic_strain_YZ import elastic_strain_YZ
-from .elastic_strain_Z import elastic_strain_Z
-from .elastic_strain_energy_density import elastic_strain_energy_density
-from .elastic_strain_eqv import elastic_strain_eqv
-from .elastic_strain_intensity import elastic_strain_intensity
-from .elastic_strain_max_shear import elastic_strain_max_shear
-from .elastic_strain_principal_1 import elastic_strain_principal_1
-from .elastic_strain_principal_2 import elastic_strain_principal_2
-from .elastic_strain_principal_3 import elastic_strain_principal_3
-from .elastic_strain_rotation_by_euler_nodes import elastic_strain_rotation_by_euler_nodes
-from .electric_field import electric_field
-from .electric_flux_density import electric_flux_density
-from .electric_potential import electric_potential
-from .element_centroids import element_centroids
-from .element_nodal_forces import element_nodal_forces
-from .element_orientations import element_orientations
-from .element_orientations_X import element_orientations_X
-from .element_orientations_Y import element_orientations_Y
-from .element_orientations_Z import element_orientations_Z
-from .elemental_heat_generation import elemental_heat_generation
-from .elemental_mass import elemental_mass
-from .elemental_volume import elemental_volume
-from .enf_rotation_by_euler_nodes import enf_rotation_by_euler_nodes
-from .enthalpy import enthalpy
-from .entropy import entropy
-from .epsilon import epsilon
-from .equivalent_mass import equivalent_mass
-from .equivalent_radiated_power import equivalent_radiated_power
-from .eqv_stress_parameter import eqv_stress_parameter
-from .erp_radiation_efficiency import erp_radiation_efficiency
-from .euler_load_buckling import euler_load_buckling
-from .euler_nodes import euler_nodes
-from .gasket_deformation import gasket_deformation
-from .gasket_deformation_X import gasket_deformation_X
-from .gasket_deformation_XY import gasket_deformation_XY
-from .gasket_deformation_XZ import gasket_deformation_XZ
-from .gasket_inelastic_closure import gasket_inelastic_closure
-from .gasket_inelastic_closure_X import gasket_inelastic_closure_X
-from .gasket_inelastic_closure_XY import gasket_inelastic_closure_XY
-from .gasket_inelastic_closure_XZ import gasket_inelastic_closure_XZ
-from .gasket_stress import gasket_stress
-from .gasket_stress_X import gasket_stress_X
-from .gasket_stress_XY import gasket_stress_XY
-from .gasket_stress_XZ import gasket_stress_XZ
-from .gasket_thermal_closure import gasket_thermal_closure
-from .gasket_thermal_closure_X import gasket_thermal_closure_X
-from .gasket_thermal_closure_XY import gasket_thermal_closure_XY
-from .gasket_thermal_closure_XZ import gasket_thermal_closure_XZ
-from .global_added_mass import global_added_mass
-from .global_added_mass_pct import global_added_mass_pct
-from .global_center_mass import global_center_mass
-from .global_energy_ratio import global_energy_ratio
-from .global_energy_ratio_wo_eroded import global_energy_ratio_wo_eroded
-from .global_eroded_hourglass_energy import global_eroded_hourglass_energy
-from .global_eroded_internal_energy import global_eroded_internal_energy
-from .global_eroded_kinetic_energy import global_eroded_kinetic_energy
-from .global_external_work import global_external_work
-from .global_hourglass_energy import global_hourglass_energy
-from .global_internal_energy import global_internal_energy
-from .global_joint_internal_energy import global_joint_internal_energy
-from .global_kinetic_energy import global_kinetic_energy
-from .global_rigid_body_stopper_energy import global_rigid_body_stopper_energy
-from .global_sliding_interface_energy import global_sliding_interface_energy
-from .global_spring_damper_energy import global_spring_damper_energy
-from .global_system_damping_energy import global_system_damping_energy
-from .global_time_step import global_time_step
-from .global_to_nodal import global_to_nodal
-from .global_total_energy import global_total_energy
-from .global_total_mass import global_total_mass
-from .global_velocity import global_velocity
-from .heat_flux import heat_flux
-from .heat_flux_X import heat_flux_X
-from .heat_flux_Y import heat_flux_Y
-from .heat_flux_Z import heat_flux_Z
-from .hydrostatic_pressure import hydrostatic_pressure
-from .incremental_energy import incremental_energy
-from .initial_coordinates import initial_coordinates
-from .interface_contact_area import interface_contact_area
-from .interface_contact_force import interface_contact_force
-from .interface_contact_mass import interface_contact_mass
-from .interface_contact_moment import interface_contact_moment
-from .interface_resultant_contact_force import interface_resultant_contact_force
-from .joint_force_reaction import joint_force_reaction
-from .joint_moment_reaction import joint_moment_reaction
-from .joint_relative_acceleration import joint_relative_acceleration
-from .joint_relative_angular_acceleration import joint_relative_angular_acceleration
-from .joint_relative_angular_velocity import joint_relative_angular_velocity
-from .joint_relative_displacement import joint_relative_displacement
-from .joint_relative_rotation import joint_relative_rotation
-from .joint_relative_velocity import joint_relative_velocity
-from .kinetic_energy import kinetic_energy
-from .mach_number import mach_number
-from .mapdl_material_properties import mapdl_material_properties
-from .mapdl_section import mapdl_section
-from .mapdl_split_on_facet_indices import mapdl_split_on_facet_indices
-from .mapdl_split_to_acmo_facet_indices import mapdl_split_to_acmo_facet_indices
-from .mass_flow_rate import mass_flow_rate
-from .mass_fraction import mass_fraction
-from .material_property_of_element import material_property_of_element
-from .mean_static_pressure import mean_static_pressure
-from .mean_temperature import mean_temperature
-from .mean_velocity import mean_velocity
-from .members_in_bending_not_certified import members_in_bending_not_certified
-from .members_in_compression_not_certified import members_in_compression_not_certified
-from .members_in_linear_compression_bending_not_certified import members_in_linear_compression_bending_not_certified
-from .migrate_to_h5dpf import migrate_to_h5dpf
-from .modal_basis import modal_basis
-from .nmisc import nmisc
-from .nodal_force import nodal_force
-from .nodal_moment import nodal_moment
-from .nodal_to_global import nodal_to_global
-from .normal_contact_force import normal_contact_force
-from .normal_contact_moment import normal_contact_moment
-from .num_surface_status_changes import num_surface_status_changes
-from .omega import omega
-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
-from .part_hourglass_energy import part_hourglass_energy
-from .part_internal_energy import part_internal_energy
-from .part_kinetic_energy import part_kinetic_energy
-from .part_momentum import part_momentum
-from .part_rigid_body_velocity import part_rigid_body_velocity
-from .plastic_state_variable import plastic_state_variable
-from .plastic_strain import plastic_strain
-from .plastic_strain_X import plastic_strain_X
-from .plastic_strain_XY import plastic_strain_XY
-from .plastic_strain_XZ import plastic_strain_XZ
-from .plastic_strain_Y import plastic_strain_Y
-from .plastic_strain_YZ import plastic_strain_YZ
-from .plastic_strain_Z import plastic_strain_Z
-from .plastic_strain_energy_density import plastic_strain_energy_density
-from .plastic_strain_eqv import plastic_strain_eqv
-from .plastic_strain_intensity import plastic_strain_intensity
-from .plastic_strain_max_shear import plastic_strain_max_shear
-from .plastic_strain_principal_1 import plastic_strain_principal_1
-from .plastic_strain_principal_2 import plastic_strain_principal_2
-from .plastic_strain_principal_3 import plastic_strain_principal_3
-from .plastic_strain_rotation_by_euler_nodes import plastic_strain_rotation_by_euler_nodes
-from .poynting_vector import poynting_vector
-from .poynting_vector_surface import poynting_vector_surface
-from .pres_to_field import pres_to_field
-from .pressure import pressure
-from .prns_to_field import prns_to_field
-from .raw_displacement import raw_displacement
-from .raw_reaction_force import raw_reaction_force
-from .reaction_force import reaction_force
-from .reaction_force_X import reaction_force_X
-from .reaction_force_Y import reaction_force_Y
-from .reaction_force_Z import reaction_force_Z
-from .read_cms_rbd_file import read_cms_rbd_file
-from .recombine_harmonic_indeces_cyclic import recombine_harmonic_indeces_cyclic
-from .remove_rigid_body_motion import remove_rigid_body_motion
-from .remove_rigid_body_motion_fc import remove_rigid_body_motion_fc
-from .rigid_transformation import rigid_transformation
-from .rigid_transformation_provider import rigid_transformation_provider
-from .rms_static_pressure import rms_static_pressure
-from .rms_temperature import rms_temperature
-from .rms_velocity import rms_velocity
-from .rom_data_provider import rom_data_provider
-from .run import run
-from .smisc import smisc
-from .specific_heat import specific_heat
-from .spectrum_data import spectrum_data
-from .static_pressure import static_pressure
-from .stiffness_matrix_energy import stiffness_matrix_energy
-from .strain_eqv_as_mechanical import strain_eqv_as_mechanical
-from .strain_eqv_as_mechanical_workflow import strain_eqv_as_mechanical_workflow
-from .stress import stress
-from .stress_X import stress_X
-from .stress_XY import stress_XY
-from .stress_XZ import stress_XZ
-from .stress_Y import stress_Y
-from .stress_YZ import stress_YZ
-from .stress_Z import stress_Z
-from .stress_eqv_as_mechanical import stress_eqv_as_mechanical
-from .stress_eqv_as_mechanical_workflow import stress_eqv_as_mechanical_workflow
-from .stress_intensity import stress_intensity
-from .stress_max_shear import stress_max_shear
-from .stress_principal_1 import stress_principal_1
-from .stress_principal_2 import stress_principal_2
-from .stress_principal_3 import stress_principal_3
-from .stress_ratio import stress_ratio
-from .stress_rotation_by_euler_nodes import stress_rotation_by_euler_nodes
-from .stress_von_mises import stress_von_mises
-from .structural_temperature import structural_temperature
-from .superficial_velocity import superficial_velocity
-from .surface_heat_rate import surface_heat_rate
-from .swelling_strains import swelling_strains
-from .tangential_contact_force import tangential_contact_force
-from .tangential_contact_moment import tangential_contact_moment
-from .temperature import temperature
-from .temperature_grad import temperature_grad
-from .thermal_conductivity import thermal_conductivity
-from .thermal_dissipation_energy import thermal_dissipation_energy
-from .thermal_strain import thermal_strain
-from .thermal_strain_X import thermal_strain_X
-from .thermal_strain_XY import thermal_strain_XY
-from .thermal_strain_XZ import thermal_strain_XZ
-from .thermal_strain_Y import thermal_strain_Y
-from .thermal_strain_YZ import thermal_strain_YZ
-from .thermal_strain_Z import thermal_strain_Z
-from .thermal_strain_principal_1 import thermal_strain_principal_1
-from .thermal_strain_principal_2 import thermal_strain_principal_2
-from .thermal_strain_principal_3 import thermal_strain_principal_3
-from .thermal_strains_eqv import thermal_strains_eqv
-from .thickness import thickness
-from .torque import torque
-from .total_contact_force import total_contact_force
-from .total_contact_moment import total_contact_moment
-from .total_mass import total_mass
-from .total_pressure import total_pressure
-from .total_strain import total_strain
-from .total_temperature import total_temperature
-from .transform_invariant_terms_rbd import transform_invariant_terms_rbd
-from .transient_rayleigh_integration import transient_rayleigh_integration
-from .turbulent_kinetic_energy import turbulent_kinetic_energy
-from .turbulent_viscosity import turbulent_viscosity
-from .velocity import velocity
-from .velocity_X import velocity_X
-from .velocity_Y import velocity_Y
-from .velocity_Z import velocity_Z
-from .volume_fraction import volume_fraction
-from .wall_shear_stress import wall_shear_stress
-from .workflow_energy_per_component import workflow_energy_per_component
-from .workflow_energy_per_harmonic import workflow_energy_per_harmonic
-from .write_cms_rbd_file import write_cms_rbd_file
-from .write_motion_dfmf_file import write_motion_dfmf_file
-from .y_plus import y_plus
+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 .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
+from .beam_axial_force import beam_axial_force
+from .beam_axial_plastic_strain import beam_axial_plastic_strain
+from .beam_axial_stress import beam_axial_stress
+from .beam_axial_total_strain import beam_axial_total_strain
+from .beam_rs_shear_stress import beam_rs_shear_stress
+from .beam_s_bending_moment import beam_s_bending_moment
+from .beam_s_shear_force import beam_s_shear_force
+from .beam_torsional_moment import beam_torsional_moment
+from .beam_tr_shear_stress import beam_tr_shear_stress
+from .beam_t_bending_moment import beam_t_bending_moment
+from .beam_t_shear_force import beam_t_shear_force
+from .cgns_result_provider import cgns_result_provider
+from .cms_dst_table_provider import cms_dst_table_provider
+from .cms_matrices_provider import cms_matrices_provider
+from .cms_subfile_info_provider import cms_subfile_info_provider
+from .compute_invariant_terms_motion import compute_invariant_terms_motion
+from .compute_invariant_terms_rbd import compute_invariant_terms_rbd
+from .compute_stress import compute_stress
+from .compute_stress_1 import compute_stress_1
+from .compute_stress_2 import compute_stress_2
+from .compute_stress_3 import compute_stress_3
+from .compute_stress_von_mises import compute_stress_von_mises
+from .compute_stress_X import compute_stress_X
+from .compute_stress_XY import compute_stress_XY
+from .compute_stress_XZ import compute_stress_XZ
+from .compute_stress_Y import compute_stress_Y
+from .compute_stress_YZ import compute_stress_YZ
+from .compute_stress_Z import compute_stress_Z
+from .compute_total_strain import compute_total_strain
+from .compute_total_strain_1 import compute_total_strain_1
+from .compute_total_strain_2 import compute_total_strain_2
+from .compute_total_strain_3 import compute_total_strain_3
+from .compute_total_strain_X import compute_total_strain_X
+from .compute_total_strain_XY import compute_total_strain_XY
+from .compute_total_strain_XZ import compute_total_strain_XZ
+from .compute_total_strain_Y import compute_total_strain_Y
+from .compute_total_strain_YZ import compute_total_strain_YZ
+from .compute_total_strain_Z import compute_total_strain_Z
+from .contact_fluid_penetration_pressure import contact_fluid_penetration_pressure
+from .contact_friction_stress import contact_friction_stress
+from .contact_gap_distance import contact_gap_distance
+from .contact_penetration import contact_penetration
+from .contact_pressure import contact_pressure
+from .contact_sliding_distance import contact_sliding_distance
+from .contact_status import contact_status
+from .contact_surface_heat_flux import contact_surface_heat_flux
+from .contact_total_stress import contact_total_stress
+from .coordinates import coordinates
+from .coordinate_system import coordinate_system
+from .co_energy import co_energy
+from .creep_strain_energy_density import creep_strain_energy_density
+from .current_density import current_density
+from .custom import custom
+from .cyclic_analytic_seqv_max import cyclic_analytic_seqv_max
+from .cyclic_analytic_usum_max import cyclic_analytic_usum_max
+from .cyclic_equivalent_mass import cyclic_equivalent_mass
+from .cyclic_expanded_acceleration import cyclic_expanded_acceleration
+from .cyclic_expanded_displacement import cyclic_expanded_displacement
+from .cyclic_expanded_el_strain import cyclic_expanded_el_strain
+from .cyclic_expanded_enf import cyclic_expanded_enf
+from .cyclic_expanded_heat_flux import cyclic_expanded_heat_flux
+from .cyclic_expanded_stress import cyclic_expanded_stress
+from .cyclic_expanded_temperature import cyclic_expanded_temperature
+from .cyclic_expanded_velocity import cyclic_expanded_velocity
+from .cyclic_expansion import cyclic_expansion
+from .cyclic_kinetic_energy import cyclic_kinetic_energy
+from .cyclic_nmisc import cyclic_nmisc
+from .cyclic_strain_energy import cyclic_strain_energy
+from .cyclic_volume import cyclic_volume
+from .density import density
+from .displacement import displacement
+from .displacement_X import displacement_X
+from .displacement_Y import displacement_Y
+from .displacement_Z import displacement_Z
+from .div_lighthill_tensor import div_lighthill_tensor
+from .dynamic_viscosity import dynamic_viscosity
+from .elastic_strain import elastic_strain
+from .elastic_strain_energy_density import elastic_strain_energy_density
+from .elastic_strain_eqv import elastic_strain_eqv
+from .elastic_strain_intensity import elastic_strain_intensity
+from .elastic_strain_max_shear import elastic_strain_max_shear
+from .elastic_strain_principal_1 import elastic_strain_principal_1
+from .elastic_strain_principal_2 import elastic_strain_principal_2
+from .elastic_strain_principal_3 import elastic_strain_principal_3
+from .elastic_strain_rotation_by_euler_nodes import elastic_strain_rotation_by_euler_nodes
+from .elastic_strain_X import elastic_strain_X
+from .elastic_strain_XY import elastic_strain_XY
+from .elastic_strain_XZ import elastic_strain_XZ
+from .elastic_strain_Y import elastic_strain_Y
+from .elastic_strain_YZ import elastic_strain_YZ
+from .elastic_strain_Z import elastic_strain_Z
+from .electric_field import electric_field
+from .electric_flux_density import electric_flux_density
+from .electric_potential import electric_potential
+from .elemental_heat_generation import elemental_heat_generation
+from .elemental_mass import elemental_mass
+from .elemental_volume import elemental_volume
+from .element_centroids import element_centroids
+from .element_nodal_forces import element_nodal_forces
+from .element_orientations import element_orientations
+from .element_orientations_X import element_orientations_X
+from .element_orientations_Y import element_orientations_Y
+from .element_orientations_Z import element_orientations_Z
+from .enf_rotation_by_euler_nodes import enf_rotation_by_euler_nodes
+from .enthalpy import enthalpy
+from .entropy import entropy
+from .epsilon import epsilon
+from .equivalent_mass import equivalent_mass
+from .equivalent_radiated_power import equivalent_radiated_power
+from .eqv_stress_parameter import eqv_stress_parameter
+from .erp_radiation_efficiency import erp_radiation_efficiency
+from .euler_load_buckling import euler_load_buckling
+from .euler_nodes import euler_nodes
+from .gasket_deformation import gasket_deformation
+from .gasket_deformation_X import gasket_deformation_X
+from .gasket_deformation_XY import gasket_deformation_XY
+from .gasket_deformation_XZ import gasket_deformation_XZ
+from .gasket_inelastic_closure import gasket_inelastic_closure
+from .gasket_inelastic_closure_X import gasket_inelastic_closure_X
+from .gasket_inelastic_closure_XY import gasket_inelastic_closure_XY
+from .gasket_inelastic_closure_XZ import gasket_inelastic_closure_XZ
+from .gasket_stress import gasket_stress
+from .gasket_stress_X import gasket_stress_X
+from .gasket_stress_XY import gasket_stress_XY
+from .gasket_stress_XZ import gasket_stress_XZ
+from .gasket_thermal_closure import gasket_thermal_closure
+from .gasket_thermal_closure_X import gasket_thermal_closure_X
+from .gasket_thermal_closure_XY import gasket_thermal_closure_XY
+from .gasket_thermal_closure_XZ import gasket_thermal_closure_XZ
+from .global_added_mass import global_added_mass
+from .global_added_mass_pct import global_added_mass_pct
+from .global_center_mass import global_center_mass
+from .global_energy_ratio import global_energy_ratio
+from .global_energy_ratio_wo_eroded import global_energy_ratio_wo_eroded
+from .global_eroded_hourglass_energy import global_eroded_hourglass_energy
+from .global_eroded_internal_energy import global_eroded_internal_energy
+from .global_eroded_kinetic_energy import global_eroded_kinetic_energy
+from .global_external_work import global_external_work
+from .global_hourglass_energy import global_hourglass_energy
+from .global_internal_energy import global_internal_energy
+from .global_joint_internal_energy import global_joint_internal_energy
+from .global_kinetic_energy import global_kinetic_energy
+from .global_rigid_body_stopper_energy import global_rigid_body_stopper_energy
+from .global_sliding_interface_energy import global_sliding_interface_energy
+from .global_spring_damper_energy import global_spring_damper_energy
+from .global_system_damping_energy import global_system_damping_energy
+from .global_time_step import global_time_step
+from .global_total_energy import global_total_energy
+from .global_total_mass import global_total_mass
+from .global_to_nodal import global_to_nodal
+from .global_velocity import global_velocity
+from .heat_flux import heat_flux
+from .heat_flux_X import heat_flux_X
+from .heat_flux_Y import heat_flux_Y
+from .heat_flux_Z import heat_flux_Z
+from .hydrostatic_pressure import hydrostatic_pressure
+from .incremental_energy import incremental_energy
+from .initial_coordinates import initial_coordinates
+from .interface_contact_area import interface_contact_area
+from .interface_contact_force import interface_contact_force
+from .interface_contact_mass import interface_contact_mass
+from .interface_contact_moment import interface_contact_moment
+from .interface_resultant_contact_force import interface_resultant_contact_force
+from .joint_force_reaction import joint_force_reaction
+from .joint_moment_reaction import joint_moment_reaction
+from .joint_relative_acceleration import joint_relative_acceleration
+from .joint_relative_angular_acceleration import joint_relative_angular_acceleration
+from .joint_relative_angular_velocity import joint_relative_angular_velocity
+from .joint_relative_displacement import joint_relative_displacement
+from .joint_relative_rotation import joint_relative_rotation
+from .joint_relative_velocity import joint_relative_velocity
+from .kinetic_energy import kinetic_energy
+from .mach_number import mach_number
+from .mapdl_material_properties import mapdl_material_properties
+from .mapdl_section import mapdl_section
+from .mapdl_split_on_facet_indices import mapdl_split_on_facet_indices
+from .mapdl_split_to_acmo_facet_indices import mapdl_split_to_acmo_facet_indices
+from .mass_flow_rate import mass_flow_rate
+from .mass_fraction import mass_fraction
+from .material_property_of_element import material_property_of_element
+from .mean_static_pressure import mean_static_pressure
+from .mean_temperature import mean_temperature
+from .mean_velocity import mean_velocity
+from .members_in_bending_not_certified import members_in_bending_not_certified
+from .members_in_compression_not_certified import members_in_compression_not_certified
+from .members_in_linear_compression_bending_not_certified import members_in_linear_compression_bending_not_certified
+from .migrate_to_h5dpf import migrate_to_h5dpf
+from .modal_basis import modal_basis
+from .nmisc import nmisc
+from .nodal_force import nodal_force
+from .nodal_moment import nodal_moment
+from .nodal_to_global import nodal_to_global
+from .normal_contact_force import normal_contact_force
+from .normal_contact_moment import normal_contact_moment
+from .num_surface_status_changes import num_surface_status_changes
+from .omega import omega
+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
+from .part_hourglass_energy import part_hourglass_energy
+from .part_internal_energy import part_internal_energy
+from .part_kinetic_energy import part_kinetic_energy
+from .part_momentum import part_momentum
+from .part_rigid_body_velocity import part_rigid_body_velocity
+from .plastic_state_variable import plastic_state_variable
+from .plastic_strain import plastic_strain
+from .plastic_strain_energy_density import plastic_strain_energy_density
+from .plastic_strain_eqv import plastic_strain_eqv
+from .plastic_strain_intensity import plastic_strain_intensity
+from .plastic_strain_max_shear import plastic_strain_max_shear
+from .plastic_strain_principal_1 import plastic_strain_principal_1
+from .plastic_strain_principal_2 import plastic_strain_principal_2
+from .plastic_strain_principal_3 import plastic_strain_principal_3
+from .plastic_strain_rotation_by_euler_nodes import plastic_strain_rotation_by_euler_nodes
+from .plastic_strain_X import plastic_strain_X
+from .plastic_strain_XY import plastic_strain_XY
+from .plastic_strain_XZ import plastic_strain_XZ
+from .plastic_strain_Y import plastic_strain_Y
+from .plastic_strain_YZ import plastic_strain_YZ
+from .plastic_strain_Z import plastic_strain_Z
+from .poynting_vector import poynting_vector
+from .poynting_vector_surface import poynting_vector_surface
+from .pressure import pressure
+from .pres_to_field import pres_to_field
+from .prns_to_field import prns_to_field
+from .raw_displacement import raw_displacement
+from .raw_reaction_force import raw_reaction_force
+from .reaction_force import reaction_force
+from .reaction_force_X import reaction_force_X
+from .reaction_force_Y import reaction_force_Y
+from .reaction_force_Z import reaction_force_Z
+from .read_cms_rbd_file import read_cms_rbd_file
+from .recombine_harmonic_indeces_cyclic import recombine_harmonic_indeces_cyclic
+from .remove_rigid_body_motion import remove_rigid_body_motion
+from .remove_rigid_body_motion_fc import remove_rigid_body_motion_fc
+from .rigid_transformation import rigid_transformation
+from .rigid_transformation_provider import rigid_transformation_provider
+from .rms_static_pressure import rms_static_pressure
+from .rms_temperature import rms_temperature
+from .rms_velocity import rms_velocity
+from .rom_data_provider import rom_data_provider
+from .run import run
+from .smisc import smisc
+from .specific_heat import specific_heat
+from .spectrum_data import spectrum_data
+from .static_pressure import static_pressure
+from .stiffness_matrix_energy import stiffness_matrix_energy
+from .strain_eqv_as_mechanical import strain_eqv_as_mechanical
+from .strain_eqv_as_mechanical_workflow import strain_eqv_as_mechanical_workflow
+from .stress import stress
+from .stress_eqv_as_mechanical import stress_eqv_as_mechanical
+from .stress_eqv_as_mechanical_workflow import stress_eqv_as_mechanical_workflow
+from .stress_intensity import stress_intensity
+from .stress_max_shear import stress_max_shear
+from .stress_principal_1 import stress_principal_1
+from .stress_principal_2 import stress_principal_2
+from .stress_principal_3 import stress_principal_3
+from .stress_ratio import stress_ratio
+from .stress_rotation_by_euler_nodes import stress_rotation_by_euler_nodes
+from .stress_von_mises import stress_von_mises
+from .stress_X import stress_X
+from .stress_XY import stress_XY
+from .stress_XZ import stress_XZ
+from .stress_Y import stress_Y
+from .stress_YZ import stress_YZ
+from .stress_Z import stress_Z
+from .structural_temperature import structural_temperature
+from .superficial_velocity import superficial_velocity
+from .surface_heat_rate import surface_heat_rate
+from .swelling_strains import swelling_strains
+from .tangential_contact_force import tangential_contact_force
+from .tangential_contact_moment import tangential_contact_moment
+from .temperature import temperature
+from .temperature_grad import temperature_grad
+from .thermal_conductivity import thermal_conductivity
+from .thermal_dissipation_energy import thermal_dissipation_energy
+from .thermal_strain import thermal_strain
+from .thermal_strains_eqv import thermal_strains_eqv
+from .thermal_strain_principal_1 import thermal_strain_principal_1
+from .thermal_strain_principal_2 import thermal_strain_principal_2
+from .thermal_strain_principal_3 import thermal_strain_principal_3
+from .thermal_strain_X import thermal_strain_X
+from .thermal_strain_XY import thermal_strain_XY
+from .thermal_strain_XZ import thermal_strain_XZ
+from .thermal_strain_Y import thermal_strain_Y
+from .thermal_strain_YZ import thermal_strain_YZ
+from .thermal_strain_Z import thermal_strain_Z
+from .thickness import thickness
+from .torque import torque
+from .total_contact_force import total_contact_force
+from .total_contact_moment import total_contact_moment
+from .total_mass import total_mass
+from .total_pressure import total_pressure
+from .total_strain import total_strain
+from .total_temperature import total_temperature
+from .transform_invariant_terms_rbd import transform_invariant_terms_rbd
+from .transient_rayleigh_integration import transient_rayleigh_integration
+from .turbulent_kinetic_energy import turbulent_kinetic_energy
+from .turbulent_viscosity import turbulent_viscosity
+from .velocity import velocity
+from .velocity_X import velocity_X
+from .velocity_Y import velocity_Y
+from .velocity_Z import velocity_Z
+from .volume_fraction import volume_fraction
+from .wall_shear_stress import wall_shear_stress
+from .workflow_energy_per_component import workflow_energy_per_component
+from .workflow_energy_per_harmonic import workflow_energy_per_harmonic
+from .write_cms_rbd_file import write_cms_rbd_file
+from .write_motion_dfmf_file import write_motion_dfmf_file
+from .y_plus import y_plus
diff --git a/src/ansys/dpf/core/operators/scoping/__init__.py b/src/ansys/dpf/core/operators/scoping/__init__.py
index 7eddddff1b..802d8e1b65 100644
--- a/src/ansys/dpf/core/operators/scoping/__init__.py
+++ b/src/ansys/dpf/core/operators/scoping/__init__.py
@@ -1,18 +1,16 @@
-from .change_fc import change_fc
-from .compute_element_centroids import compute_element_centroids
-from .connectivity_ids import connectivity_ids
-from .elemental_from_mesh import elemental_from_mesh
-from .from_mesh import from_mesh
-from .intersect import intersect
-from .nodal_from_mesh import nodal_from_mesh
-from .on_mesh_property import on_mesh_property
-from .on_named_selection import on_named_selection
-from .on_property import on_property
-from .reduce_sampling import reduce_sampling
-from .rescope import rescope
-from .rescope_custom_type_field import rescope_custom_type_field
-from .rescope_fc import rescope_fc
-from .rescope_property_field import rescope_property_field
-from .scoping_get_attribute import scoping_get_attribute
-from .split_on_property_type import split_on_property_type
-from .transpose import transpose
+from .change_fc import change_fc
+from .compute_element_centroids import compute_element_centroids
+from .connectivity_ids import connectivity_ids
+from .from_mesh import from_mesh
+from .intersect import intersect
+from .on_mesh_property import on_mesh_property
+from .on_named_selection import on_named_selection
+from .on_property import on_property
+from .reduce_sampling import reduce_sampling
+from .rescope import rescope
+from .rescope_custom_type_field import rescope_custom_type_field
+from .rescope_fc import rescope_fc
+from .rescope_property_field import rescope_property_field
+from .scoping_get_attribute import scoping_get_attribute
+from .split_on_property_type import split_on_property_type
+from .transpose import transpose
diff --git a/src/ansys/dpf/core/operators/scoping/elemental_from_mesh.py b/src/ansys/dpf/core/operators/scoping/elemental_from_mesh.py
deleted file mode 100644
index c6a6d5ffe4..0000000000
--- a/src/ansys/dpf/core/operators/scoping/elemental_from_mesh.py
+++ /dev/null
@@ -1,183 +0,0 @@
-"""
-elemental_from_mesh
-===================
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class elemental_from_mesh(Operator):
- """Retrieves the elemental scoping of a given input mesh, which contains
- the element IDs.
-
- Parameters
- ----------
- mesh : MeshedRegion
-
- Returns
- -------
- mesh_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.scoping.elemental_from_mesh()
-
- >>> # Make input connections
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.scoping.elemental_from_mesh(
- ... mesh=my_mesh,
- ... )
-
- >>> # Get output data
- >>> result_mesh_scoping = op.outputs.mesh_scoping()
- """
-
- def __init__(self, mesh=None, config=None, server=None):
- super().__init__(name="GetElementScopingFromMesh", config=config, server=server)
- self._inputs = InputsElementalFromMesh(self)
- self._outputs = OutputsElementalFromMesh(self)
- if mesh is not None:
- self.inputs.mesh.connect(mesh)
-
- @staticmethod
- def _spec():
- description = """Retrieves the elemental scoping of a given input mesh, which contains
- the element IDs."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="mesh",
- type_names=["abstract_meshed_region"],
- optional=False,
- document="""""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="mesh_scoping",
- type_names=["scoping"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(name="GetElementScopingFromMesh", server=server)
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsElementalFromMesh
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsElementalFromMesh
- """
- return super().outputs
-
-
-class InputsElementalFromMesh(_Inputs):
- """Intermediate class used to connect user inputs to
- elemental_from_mesh operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.scoping.elemental_from_mesh()
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
- """
-
- def __init__(self, op: Operator):
- super().__init__(elemental_from_mesh._spec().inputs, op)
- self._mesh = Input(elemental_from_mesh._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._mesh)
-
- @property
- def mesh(self):
- """Allows to connect mesh input to the operator.
-
- Parameters
- ----------
- my_mesh : MeshedRegion
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.scoping.elemental_from_mesh()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> # or
- >>> op.inputs.mesh(my_mesh)
- """
- return self._mesh
-
-
-class OutputsElementalFromMesh(_Outputs):
- """Intermediate class used to get outputs from
- elemental_from_mesh operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.scoping.elemental_from_mesh()
- >>> # Connect inputs : op.inputs. ...
- >>> result_mesh_scoping = op.outputs.mesh_scoping()
- """
-
- def __init__(self, op: Operator):
- super().__init__(elemental_from_mesh._spec().outputs, op)
- self._mesh_scoping = Output(elemental_from_mesh._spec().output_pin(0), 0, op)
- self._outputs.append(self._mesh_scoping)
-
- @property
- def mesh_scoping(self):
- """Allows to get mesh_scoping output of the operator
-
- Returns
- ----------
- my_mesh_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.scoping.elemental_from_mesh()
- >>> # Connect inputs : op.inputs. ...
- >>> result_mesh_scoping = op.outputs.mesh_scoping()
- """ # noqa: E501
- return self._mesh_scoping
diff --git a/src/ansys/dpf/core/operators/scoping/nodal_from_mesh.py b/src/ansys/dpf/core/operators/scoping/nodal_from_mesh.py
deleted file mode 100644
index e6c6ad5315..0000000000
--- a/src/ansys/dpf/core/operators/scoping/nodal_from_mesh.py
+++ /dev/null
@@ -1,183 +0,0 @@
-"""
-nodal_from_mesh
-===============
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class nodal_from_mesh(Operator):
- """Retrieves the nodal scoping of a given input mesh, which contains the
- node IDs.
-
- Parameters
- ----------
- mesh : MeshedRegion
-
- Returns
- -------
- mesh_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.scoping.nodal_from_mesh()
-
- >>> # Make input connections
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.scoping.nodal_from_mesh(
- ... mesh=my_mesh,
- ... )
-
- >>> # Get output data
- >>> result_mesh_scoping = op.outputs.mesh_scoping()
- """
-
- def __init__(self, mesh=None, config=None, server=None):
- super().__init__(name="GetNodeScopingFromMesh", config=config, server=server)
- self._inputs = InputsNodalFromMesh(self)
- self._outputs = OutputsNodalFromMesh(self)
- if mesh is not None:
- self.inputs.mesh.connect(mesh)
-
- @staticmethod
- def _spec():
- description = """Retrieves the nodal scoping of a given input mesh, which contains the
- node IDs."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="mesh",
- type_names=["abstract_meshed_region"],
- optional=False,
- document="""""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="mesh_scoping",
- type_names=["scoping"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(name="GetNodeScopingFromMesh", server=server)
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsNodalFromMesh
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsNodalFromMesh
- """
- return super().outputs
-
-
-class InputsNodalFromMesh(_Inputs):
- """Intermediate class used to connect user inputs to
- nodal_from_mesh operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.scoping.nodal_from_mesh()
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
- """
-
- def __init__(self, op: Operator):
- super().__init__(nodal_from_mesh._spec().inputs, op)
- self._mesh = Input(nodal_from_mesh._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._mesh)
-
- @property
- def mesh(self):
- """Allows to connect mesh input to the operator.
-
- Parameters
- ----------
- my_mesh : MeshedRegion
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.scoping.nodal_from_mesh()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> # or
- >>> op.inputs.mesh(my_mesh)
- """
- return self._mesh
-
-
-class OutputsNodalFromMesh(_Outputs):
- """Intermediate class used to get outputs from
- nodal_from_mesh operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.scoping.nodal_from_mesh()
- >>> # Connect inputs : op.inputs. ...
- >>> result_mesh_scoping = op.outputs.mesh_scoping()
- """
-
- def __init__(self, op: Operator):
- super().__init__(nodal_from_mesh._spec().outputs, op)
- self._mesh_scoping = Output(nodal_from_mesh._spec().output_pin(0), 0, op)
- self._outputs.append(self._mesh_scoping)
-
- @property
- def mesh_scoping(self):
- """Allows to get mesh_scoping output of the operator
-
- Returns
- ----------
- my_mesh_scoping : Scoping
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.scoping.nodal_from_mesh()
- >>> # Connect inputs : op.inputs. ...
- >>> result_mesh_scoping = op.outputs.mesh_scoping()
- """ # noqa: E501
- return self._mesh_scoping
diff --git a/src/ansys/dpf/core/operators/serialization/__init__.py b/src/ansys/dpf/core/operators/serialization/__init__.py
index a9da06e6bc..a6b246ceff 100644
--- a/src/ansys/dpf/core/operators/serialization/__init__.py
+++ b/src/ansys/dpf/core/operators/serialization/__init__.py
@@ -1,23 +1,20 @@
-from .csv_to_field import csv_to_field
-from .data_tree_to_json import data_tree_to_json
-from .data_tree_to_txt import data_tree_to_txt
-from .deserializer import deserializer
-from .export_symbolic_workflow import export_symbolic_workflow
-from .field_to_csv import field_to_csv
-from .hdf5dpf_custom_read import hdf5dpf_custom_read
-from .hdf5dpf_generate_result_file import hdf5dpf_generate_result_file
-from .import_symbolic_workflow import import_symbolic_workflow
-from .json_to_data_tree import json_to_data_tree
-from .mechanical_csv_to_field import mechanical_csv_to_field
-from .migrate_file_to_vtk import migrate_file_to_vtk
-from .migrate_to_vtu import migrate_to_vtu
-from .serialize_to_hdf5 import serialize_to_hdf5
-from .serializer import serializer
-from .serializer_to_string import serializer_to_string
-from .string_deserializer import string_deserializer
-from .txt_to_data_tree import txt_to_data_tree
-from .vtk_export import vtk_export
-from .vtk_to_fields import vtk_to_fields
-from .vtu_export import vtu_export
-from .workflow_export_json import workflow_export_json
-from .workflow_import_json import workflow_import_json
+from .csv_to_field import csv_to_field
+from .data_tree_to_json import data_tree_to_json
+from .data_tree_to_txt import data_tree_to_txt
+from .deserializer import deserializer
+from .export_symbolic_workflow import export_symbolic_workflow
+from .field_to_csv import field_to_csv
+from .hdf5dpf_custom_read import hdf5dpf_custom_read
+from .hdf5dpf_generate_result_file import hdf5dpf_generate_result_file
+from .import_symbolic_workflow import import_symbolic_workflow
+from .json_to_data_tree import json_to_data_tree
+from .migrate_file_to_vtk import migrate_file_to_vtk
+from .migrate_to_vtu import migrate_to_vtu
+from .serializer import serializer
+from .serializer_to_string import serializer_to_string
+from .serialize_to_hdf5 import serialize_to_hdf5
+from .string_deserializer import string_deserializer
+from .txt_to_data_tree import txt_to_data_tree
+from .vtk_export import vtk_export
+from .vtk_to_fields import vtk_to_fields
+from .vtu_export import vtu_export
diff --git a/src/ansys/dpf/core/operators/serialization/mechanical_csv_to_field.py b/src/ansys/dpf/core/operators/serialization/mechanical_csv_to_field.py
deleted file mode 100644
index 11c3ef8c19..0000000000
--- a/src/ansys/dpf/core/operators/serialization/mechanical_csv_to_field.py
+++ /dev/null
@@ -1,295 +0,0 @@
-"""
-mechanical_csv_to_field
-=======================
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class mechanical_csv_to_field(Operator):
- """Reads mechanical exported csv file
-
- Parameters
- ----------
- unit : Class Dataprocessing::Unit::Cunit
- mesh : MeshedRegion, optional
- data_sources : DataSources
- requested_location : str or FieldDefinition
-
- Returns
- -------
- field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.serialization.mechanical_csv_to_field()
-
- >>> # Make input connections
- >>> my_unit = dpf.Class Dataprocessing::Unit::Cunit()
- >>> op.inputs.unit.connect(my_unit)
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> my_data_sources = dpf.DataSources()
- >>> op.inputs.data_sources.connect(my_data_sources)
- >>> my_requested_location = str()
- >>> op.inputs.requested_location.connect(my_requested_location)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.serialization.mechanical_csv_to_field(
- ... unit=my_unit,
- ... mesh=my_mesh,
- ... data_sources=my_data_sources,
- ... requested_location=my_requested_location,
- ... )
-
- >>> # Get output data
- >>> result_field = op.outputs.field()
- """
-
- def __init__(
- self,
- unit=None,
- mesh=None,
- data_sources=None,
- requested_location=None,
- config=None,
- server=None,
- ):
- super().__init__(name="mechanical_csv_to_field", config=config, server=server)
- self._inputs = InputsMechanicalCsvToField(self)
- self._outputs = OutputsMechanicalCsvToField(self)
- if unit is not None:
- self.inputs.unit.connect(unit)
- if mesh is not None:
- self.inputs.mesh.connect(mesh)
- if data_sources is not None:
- self.inputs.data_sources.connect(data_sources)
- if requested_location is not None:
- self.inputs.requested_location.connect(requested_location)
-
- @staticmethod
- def _spec():
- description = """Reads mechanical exported csv file"""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="unit",
- type_names=["class dataProcessing::unit::CUnit"],
- optional=False,
- document="""""",
- ),
- 1: PinSpecification(
- name="mesh",
- type_names=["abstract_meshed_region"],
- optional=True,
- document="""""",
- ),
- 4: PinSpecification(
- name="data_sources",
- type_names=["data_sources"],
- optional=False,
- document="""""",
- ),
- 9: PinSpecification(
- name="requested_location",
- type_names=["string", "field_definition"],
- optional=False,
- document="""""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="field",
- type_names=["field"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(name="mechanical_csv_to_field", server=server)
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsMechanicalCsvToField
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsMechanicalCsvToField
- """
- return super().outputs
-
-
-class InputsMechanicalCsvToField(_Inputs):
- """Intermediate class used to connect user inputs to
- mechanical_csv_to_field operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.serialization.mechanical_csv_to_field()
- >>> my_unit = dpf.Class Dataprocessing::Unit::Cunit()
- >>> op.inputs.unit.connect(my_unit)
- >>> my_mesh = dpf.MeshedRegion()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> my_data_sources = dpf.DataSources()
- >>> op.inputs.data_sources.connect(my_data_sources)
- >>> my_requested_location = str()
- >>> op.inputs.requested_location.connect(my_requested_location)
- """
-
- def __init__(self, op: Operator):
- super().__init__(mechanical_csv_to_field._spec().inputs, op)
- self._unit = Input(mechanical_csv_to_field._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._unit)
- self._mesh = Input(mechanical_csv_to_field._spec().input_pin(1), 1, op, -1)
- self._inputs.append(self._mesh)
- self._data_sources = Input(
- mechanical_csv_to_field._spec().input_pin(4), 4, op, -1
- )
- self._inputs.append(self._data_sources)
- self._requested_location = Input(
- mechanical_csv_to_field._spec().input_pin(9), 9, op, -1
- )
- self._inputs.append(self._requested_location)
-
- @property
- def unit(self):
- """Allows to connect unit input to the operator.
-
- Parameters
- ----------
- my_unit : Class Dataprocessing::Unit::Cunit
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.serialization.mechanical_csv_to_field()
- >>> op.inputs.unit.connect(my_unit)
- >>> # or
- >>> op.inputs.unit(my_unit)
- """
- return self._unit
-
- @property
- def mesh(self):
- """Allows to connect mesh input to the operator.
-
- Parameters
- ----------
- my_mesh : MeshedRegion
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.serialization.mechanical_csv_to_field()
- >>> op.inputs.mesh.connect(my_mesh)
- >>> # or
- >>> op.inputs.mesh(my_mesh)
- """
- return self._mesh
-
- @property
- def data_sources(self):
- """Allows to connect data_sources input to the operator.
-
- Parameters
- ----------
- my_data_sources : DataSources
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.serialization.mechanical_csv_to_field()
- >>> op.inputs.data_sources.connect(my_data_sources)
- >>> # or
- >>> op.inputs.data_sources(my_data_sources)
- """
- return self._data_sources
-
- @property
- def requested_location(self):
- """Allows to connect requested_location input to the operator.
-
- Parameters
- ----------
- my_requested_location : str or FieldDefinition
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.serialization.mechanical_csv_to_field()
- >>> op.inputs.requested_location.connect(my_requested_location)
- >>> # or
- >>> op.inputs.requested_location(my_requested_location)
- """
- return self._requested_location
-
-
-class OutputsMechanicalCsvToField(_Outputs):
- """Intermediate class used to get outputs from
- mechanical_csv_to_field operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.serialization.mechanical_csv_to_field()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """
-
- def __init__(self, op: Operator):
- super().__init__(mechanical_csv_to_field._spec().outputs, op)
- self._field = Output(mechanical_csv_to_field._spec().output_pin(0), 0, op)
- self._outputs.append(self._field)
-
- @property
- def field(self):
- """Allows to get field output of the operator
-
- Returns
- ----------
- my_field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.serialization.mechanical_csv_to_field()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """ # noqa: E501
- return self._field
diff --git a/src/ansys/dpf/core/operators/serialization/workflow_export_json.py b/src/ansys/dpf/core/operators/serialization/workflow_export_json.py
deleted file mode 100644
index 0186d6c905..0000000000
--- a/src/ansys/dpf/core/operators/serialization/workflow_export_json.py
+++ /dev/null
@@ -1,169 +0,0 @@
-"""
-workflow_export_json
-====================
-"""
-from ansys.dpf.core.dpf_operator import Operator
-from ansys.dpf.core.inputs import Input, _Inputs
-from ansys.dpf.core.outputs import Output, _Outputs, _modify_output_spec_with_one_type
-from ansys.dpf.core.operators.specification import PinSpecification, Specification
-
-"""Operators from "serialization" category
-"""
-
-class workflow_export_json(Operator):
- """Export a workflow in json format.
-
- available inputs:
- - workflow (Workflow)
- - file_path (str) (optional)
-
- available outputs:
- - json_workflow (DataSources ,str)
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.serialization.workflow_export_json()
-
- >>> # Make input connections
- >>> my_workflow = dpf.Workflow()
- >>> op.inputs.workflow.connect(my_workflow)
- >>> my_file_path = str()
- >>> op.inputs.file_path.connect(my_file_path)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.serialization.workflow_export_json(workflow=my_workflow,file_path=my_file_path)
-
- >>> # Get output data
- >>> result_json_workflow = op.outputs.json_workflow()"""
- def __init__(self, workflow=None, file_path=None, config=None, server=None):
- super().__init__(name="serialization::workflow_export_json", config = config, server = server)
- self._inputs = InputsWorkflowExportJson(self)
- self._outputs = OutputsWorkflowExportJson(self)
- if workflow !=None:
- self.inputs.workflow.connect(workflow)
- if file_path !=None:
- self.inputs.file_path.connect(file_path)
-
- @staticmethod
- def _spec():
- spec = Specification(description="""Export a workflow in json format.""",
- map_input_pin_spec={
- 0 : PinSpecification(name = "workflow", type_names=["workflow"], optional=False, document="""Workflow to serialize."""),
- 1 : PinSpecification(name = "file_path", type_names=["string"], optional=True, document="""File path to write results to. When given the operator will return a data source to the path, otherwise a json string will be output.""")},
- map_output_pin_spec={
- 0 : PinSpecification(name = "json_workflow", type_names=["data_sources","string"], optional=False, document="""Depending on the input of pin 1 the output will either be a data source to a json file or a json string.""")})
- return spec
-
-
- @staticmethod
- def default_config():
- return Operator.default_config(name = "serialization::workflow_export_json")
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator.
-
- Returns
- --------
- inputs : InputsWorkflowExportJson
- """
- return super().inputs
-
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it.
-
- Returns
- --------
- outputs : OutputsWorkflowExportJson
- """
- return super().outputs
-
-
-#internal name: serialization::workflow_export_json
-#scripting name: workflow_export_json
-class InputsWorkflowExportJson(_Inputs):
- """Intermediate class used to connect user inputs to workflow_export_json operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.serialization.workflow_export_json()
- >>> my_workflow = dpf.Workflow()
- >>> op.inputs.workflow.connect(my_workflow)
- >>> my_file_path = str()
- >>> op.inputs.file_path.connect(my_file_path)
- """
- def __init__(self, op: Operator):
- super().__init__(workflow_export_json._spec().inputs, op)
- self._workflow = Input(workflow_export_json._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._workflow)
- self._file_path = Input(workflow_export_json._spec().input_pin(1), 1, op, -1)
- self._inputs.append(self._file_path)
-
- @property
- def workflow(self):
- """Allows to connect workflow input to the operator
-
- - pindoc: Workflow to serialize.
-
- Parameters
- ----------
- my_workflow : Workflow,
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.serialization.workflow_export_json()
- >>> op.inputs.workflow.connect(my_workflow)
- >>> #or
- >>> op.inputs.workflow(my_workflow)
-
- """
- return self._workflow
-
- @property
- def file_path(self):
- """Allows to connect file_path input to the operator
-
- - pindoc: File path to write results to. When given the operator will return a data source to the path, otherwise a json string will be output.
-
- Parameters
- ----------
- my_file_path : str,
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.serialization.workflow_export_json()
- >>> op.inputs.file_path.connect(my_file_path)
- >>> #or
- >>> op.inputs.file_path(my_file_path)
-
- """
- return self._file_path
-
-class OutputsWorkflowExportJson(_Outputs):
- """Intermediate class used to get outputs from workflow_export_json operator
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.serialization.workflow_export_json()
- >>> # Connect inputs : op.inputs. ...
- >>> result_json_workflow = op.outputs.json_workflow()
- """
- def __init__(self, op: Operator):
- super().__init__(workflow_export_json._spec().outputs, op)
- self.json_workflow_as_data_sources = Output( _modify_output_spec_with_one_type(workflow_export_json._spec().output_pin(0), "data_sources"), 0, op)
- self._outputs.append(self.json_workflow_as_data_sources)
- self.json_workflow_as_string = Output( _modify_output_spec_with_one_type(workflow_export_json._spec().output_pin(0), "string"), 0, op)
- self._outputs.append(self.json_workflow_as_string)
-
diff --git a/src/ansys/dpf/core/operators/serialization/workflow_import_json.py b/src/ansys/dpf/core/operators/serialization/workflow_import_json.py
deleted file mode 100644
index 1a9ae7bcd9..0000000000
--- a/src/ansys/dpf/core/operators/serialization/workflow_import_json.py
+++ /dev/null
@@ -1,156 +0,0 @@
-"""
-workflow_import_json
-====================
-"""
-from ansys.dpf.core.dpf_operator import Operator
-from ansys.dpf.core.inputs import Input, _Inputs
-from ansys.dpf.core.outputs import Output, _Outputs, _modify_output_spec_with_one_type
-from ansys.dpf.core.operators.specification import PinSpecification, Specification
-
-"""Operators from "serialization" category
-"""
-
-class workflow_import_json(Operator):
- """Import a workflow in json format.
-
- available inputs:
- - json_workflow (str, DataSources)
-
- available outputs:
- - workflow (Workflow)
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.serialization.workflow_import_json()
-
- >>> # Make input connections
- >>> my_json_workflow = str()
- >>> op.inputs.json_workflow.connect(my_json_workflow)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.serialization.workflow_import_json(json_workflow=my_json_workflow)
-
- >>> # Get output data
- >>> result_workflow = op.outputs.workflow()"""
- def __init__(self, json_workflow=None, config=None, server=None):
- super().__init__(name="serialization::workflow_import_json", config = config, server = server)
- self._inputs = InputsWorkflowImportJson(self)
- self._outputs = OutputsWorkflowImportJson(self)
- if json_workflow !=None:
- self.inputs.json_workflow.connect(json_workflow)
-
- @staticmethod
- def _spec():
- spec = Specification(description="""Import a workflow in json format.""",
- map_input_pin_spec={
- 0 : PinSpecification(name = "json_workflow", type_names=["string","data_sources"], optional=False, document="""Input json data as either a data source or a string""")},
- map_output_pin_spec={
- 0 : PinSpecification(name = "workflow", type_names=["workflow"], optional=False, document="""Instantiate workflow.""")})
- return spec
-
-
- @staticmethod
- def default_config():
- return Operator.default_config(name = "serialization::workflow_import_json")
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator.
-
- Returns
- --------
- inputs : InputsWorkflowImportJson
- """
- return super().inputs
-
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it.
-
- Returns
- --------
- outputs : OutputsWorkflowImportJson
- """
- return super().outputs
-
-
-#internal name: serialization::workflow_import_json
-#scripting name: workflow_import_json
-class InputsWorkflowImportJson(_Inputs):
- """Intermediate class used to connect user inputs to workflow_import_json operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.serialization.workflow_import_json()
- >>> my_json_workflow = str()
- >>> op.inputs.json_workflow.connect(my_json_workflow)
- """
- def __init__(self, op: Operator):
- super().__init__(workflow_import_json._spec().inputs, op)
- self._json_workflow = Input(workflow_import_json._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._json_workflow)
-
- @property
- def json_workflow(self):
- """Allows to connect json_workflow input to the operator
-
- - pindoc: Input json data as either a data source or a string
-
- Parameters
- ----------
- my_json_workflow : str, DataSources,
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.serialization.workflow_import_json()
- >>> op.inputs.json_workflow.connect(my_json_workflow)
- >>> #or
- >>> op.inputs.json_workflow(my_json_workflow)
-
- """
- return self._json_workflow
-
-class OutputsWorkflowImportJson(_Outputs):
- """Intermediate class used to get outputs from workflow_import_json operator
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.serialization.workflow_import_json()
- >>> # Connect inputs : op.inputs. ...
- >>> result_workflow = op.outputs.workflow()
- """
- def __init__(self, op: Operator):
- super().__init__(workflow_import_json._spec().outputs, op)
- self._workflow = Output(workflow_import_json._spec().output_pin(0), 0, op)
- self._outputs.append(self._workflow)
-
- @property
- def workflow(self):
- """Allows to get workflow output of the operator
-
-
- - pindoc: Instantiate workflow.
-
- Returns
- ----------
- my_workflow : Workflow,
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.serialization.workflow_import_json()
- >>> # Connect inputs : op.inputs. ...
- >>> result_workflow = op.outputs.workflow()
- """
- return self._workflow
-
diff --git a/src/ansys/dpf/core/operators/server/__init__.py b/src/ansys/dpf/core/operators/server/__init__.py
new file mode 100644
index 0000000000..ebb3494558
--- /dev/null
+++ b/src/ansys/dpf/core/operators/server/__init__.py
@@ -0,0 +1,2 @@
+from .grpc_shutdown_server import grpc_shutdown_server
+from .grpc_start_server import grpc_start_server
diff --git a/src/ansys/dpf/core/operators/utility/__init__.py b/src/ansys/dpf/core/operators/utility/__init__.py
index 97992d4970..f69d5800d4 100644
--- a/src/ansys/dpf/core/operators/utility/__init__.py
+++ b/src/ansys/dpf/core/operators/utility/__init__.py
@@ -1,79 +1,76 @@
-from .Workflow_to_PyDPF_Generator import Workflow_to_PyDPF_Generator
-from .assemble_scalars_to_matrices import assemble_scalars_to_matrices
-from .assemble_scalars_to_matrices_fc import assemble_scalars_to_matrices_fc
-from .assemble_scalars_to_vectors import assemble_scalars_to_vectors
-from .assemble_scalars_to_vectors_fc import assemble_scalars_to_vectors_fc
-from .bind_support import bind_support
-from .bind_support_fc import bind_support_fc
-from .change_location import change_location
-from .change_shell_layers import change_shell_layers
-from .compute_time_scoping import compute_time_scoping
-from .default_value import default_value
-from .delegate_to_operator import delegate_to_operator
-from .ds_get_attribute import ds_get_attribute
-from .extract_field import extract_field
-from .extract_scoping import extract_scoping
-from .extract_sub_fc import extract_sub_fc
-from .extract_sub_mc import extract_sub_mc
-from .extract_sub_sc import extract_sub_sc
-from .extract_time_freq import extract_time_freq
-from .fc_get_attribute import fc_get_attribute
-from .field import field
-from .field_get_attribute import field_get_attribute
-from .field_to_fc import field_to_fc
-from .fields_container import fields_container
-from .fields_container_matrices_label import fields_container_matrices_label
-from .for_each import for_each
-from .forward import forward
-from .forward_field import forward_field
-from .forward_fields_container import forward_fields_container
-from .forward_meshes_container import forward_meshes_container
-from .hdf5dpf_workglow_provider import hdf5dpf_workglow_provider
-from .html_doc import html_doc
-from .incremental_concatenate_as_fc import incremental_concatenate_as_fc
-from .ints_to_scoping import ints_to_scoping
-from .make_for_each_range import make_for_each_range
-from .make_label_space import make_label_space
-from .make_overall import make_overall
-from .make_producer_consumer_for_each_iterator import make_producer_consumer_for_each_iterator
-from .merge_any import merge_any
-from .merge_collections import merge_collections
-from .merge_data_tree import merge_data_tree
-from .merge_fields import merge_fields
-from .merge_fields_by_label import merge_fields_by_label
-from .merge_fields_containers import merge_fields_containers
-from .merge_generic_data_container import merge_generic_data_container
-from .merge_materials import merge_materials
-from .merge_meshes import merge_meshes
-from .merge_meshes_containers import merge_meshes_containers
-from .merge_property_fields import merge_property_fields
-from .merge_result_infos import merge_result_infos
-from .merge_scopings import merge_scopings
-from .merge_scopings_containers import merge_scopings_containers
-from .merge_string_fields import merge_string_fields
-from .merge_supports import merge_supports
-from .merge_time_freq_supports import merge_time_freq_supports
-from .merge_to_field_matrix import merge_to_field_matrix
-from .merge_weighted_fields import merge_weighted_fields
-from .merge_weighted_fields_containers import merge_weighted_fields_containers
-from .mesh import mesh
-from .mesh_to_mc import mesh_to_mc
-from .meshes_container import meshes_container
-from .overlap_fields import overlap_fields
-from .producer_consumer_for_each import producer_consumer_for_each
-from .property_field import property_field
-from .python_generator import python_generator
-from .python_script_exec import python_script_exec
-from .remote_operator_instantiate import remote_operator_instantiate
-from .remote_workflow_instantiate import remote_workflow_instantiate
-from .remove_unnecessary_labels import remove_unnecessary_labels
-from .scalars_to_field import scalars_to_field
-from .server_path import server_path
-from .set_attribute import set_attribute
-from .set_property import set_property
-from .split_in_for_each_range import split_in_for_each_range
-from .strain_from_voigt import strain_from_voigt
-from .strain_from_voigt_fc import strain_from_voigt_fc
-from .txt_file_to_dpf import txt_file_to_dpf
-from .unitary_field import unitary_field
-from .weighted_merge_fields_by_label import weighted_merge_fields_by_label
+from .assemble_scalars_to_matrices import assemble_scalars_to_matrices
+from .assemble_scalars_to_matrices_fc import assemble_scalars_to_matrices_fc
+from .assemble_scalars_to_vectors import assemble_scalars_to_vectors
+from .assemble_scalars_to_vectors_fc import assemble_scalars_to_vectors_fc
+from .bind_support import bind_support
+from .change_location import change_location
+from .change_shell_layers import change_shell_layers
+from .compute_time_scoping import compute_time_scoping
+from .default_value import default_value
+from .delegate_to_operator import delegate_to_operator
+from .ds_get_attribute import ds_get_attribute
+from .extract_field import extract_field
+from .extract_scoping import extract_scoping
+from .extract_sub_fc import extract_sub_fc
+from .extract_sub_mc import extract_sub_mc
+from .extract_sub_sc import extract_sub_sc
+from .extract_time_freq import extract_time_freq
+from .fc_get_attribute import fc_get_attribute
+from .field import field
+from .fields_container import fields_container
+from .fields_container_matrices_label import fields_container_matrices_label
+from .field_get_attribute import field_get_attribute
+from .field_to_fc import field_to_fc
+from .forward import forward
+from .forward_field import forward_field
+from .forward_fields_container import forward_fields_container
+from .forward_meshes_container import forward_meshes_container
+from .for_each import for_each
+from .hdf5dpf_workglow_provider import hdf5dpf_workglow_provider
+from .html_doc import html_doc
+from .incremental_concatenate_as_fc import incremental_concatenate_as_fc
+from .ints_to_scoping import ints_to_scoping
+from .make_for_each_range import make_for_each_range
+from .make_label_space import make_label_space
+from .make_overall import make_overall
+from .make_producer_consumer_for_each_iterator import make_producer_consumer_for_each_iterator
+from .merge_any import merge_any
+from .merge_collections import merge_collections
+from .merge_data_tree import merge_data_tree
+from .merge_fields import merge_fields
+from .merge_fields_by_label import merge_fields_by_label
+from .merge_fields_containers import merge_fields_containers
+from .merge_generic_data_container import merge_generic_data_container
+from .merge_materials import merge_materials
+from .merge_meshes import merge_meshes
+from .merge_meshes_containers import merge_meshes_containers
+from .merge_property_fields import merge_property_fields
+from .merge_result_infos import merge_result_infos
+from .merge_scopings import merge_scopings
+from .merge_scopings_containers import merge_scopings_containers
+from .merge_string_fields import merge_string_fields
+from .merge_supports import merge_supports
+from .merge_time_freq_supports import merge_time_freq_supports
+from .merge_to_field_matrix import merge_to_field_matrix
+from .merge_weighted_fields import merge_weighted_fields
+from .merge_weighted_fields_containers import merge_weighted_fields_containers
+from .mesh import mesh
+from .meshes_container import meshes_container
+from .mesh_to_mc import mesh_to_mc
+from .overlap_fields import overlap_fields
+from .producer_consumer_for_each import producer_consumer_for_each
+from .property_field import property_field
+from .python_generator import python_generator
+from .remote_operator_instantiate import remote_operator_instantiate
+from .remote_workflow_instantiate import remote_workflow_instantiate
+from .remove_unnecessary_labels import remove_unnecessary_labels
+from .scalars_to_field import scalars_to_field
+from .server_path import server_path
+from .set_attribute import set_attribute
+from .set_property import set_property
+from .split_in_for_each_range import split_in_for_each_range
+from .strain_from_voigt import strain_from_voigt
+from .strain_from_voigt_fc import strain_from_voigt_fc
+from .txt_file_to_dpf import txt_file_to_dpf
+from .weighted_merge_fields_by_label import weighted_merge_fields_by_label
+from .Workflow_to_PyDPF_Generator import Workflow_to_PyDPF_Generator
diff --git a/src/ansys/dpf/core/operators/utility/bind_support_fc.py b/src/ansys/dpf/core/operators/utility/bind_support_fc.py
deleted file mode 100644
index 0e6947a1c1..0000000000
--- a/src/ansys/dpf/core/operators/utility/bind_support_fc.py
+++ /dev/null
@@ -1,222 +0,0 @@
-"""
-bind_support_fc
-===============
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class bind_support_fc(Operator):
- """Ties a support to a fields container.
-
- Parameters
- ----------
- fields_container : FieldsContainer
- support : MeshedRegion or AbstractFieldSupport or TimeFreqSupport
- Meshed region or a support of the field.
-
- Returns
- -------
- fields_container : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.utility.bind_support_fc()
-
- >>> # Make input connections
- >>> my_fields_container = dpf.FieldsContainer()
- >>> op.inputs.fields_container.connect(my_fields_container)
- >>> my_support = dpf.MeshedRegion()
- >>> op.inputs.support.connect(my_support)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.utility.bind_support_fc(
- ... fields_container=my_fields_container,
- ... support=my_support,
- ... )
-
- >>> # Get output data
- >>> result_fields_container = op.outputs.fields_container()
- """
-
- def __init__(self, fields_container=None, support=None, config=None, server=None):
- super().__init__(name="BindSupportFC", config=config, server=server)
- self._inputs = InputsBindSupportFc(self)
- self._outputs = OutputsBindSupportFc(self)
- if fields_container is not None:
- self.inputs.fields_container.connect(fields_container)
- if support is not None:
- self.inputs.support.connect(support)
-
- @staticmethod
- def _spec():
- description = """Ties a support to a fields container."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="fields_container",
- type_names=["fields_container"],
- optional=False,
- document="""""",
- ),
- 1: PinSpecification(
- name="support",
- type_names=[
- "abstract_meshed_region",
- "abstract_field_support",
- "time_freq_support",
- ],
- optional=False,
- document="""Meshed region or a support of the field.""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="fields_container",
- type_names=["fields_container"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(name="BindSupportFC", server=server)
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsBindSupportFc
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsBindSupportFc
- """
- return super().outputs
-
-
-class InputsBindSupportFc(_Inputs):
- """Intermediate class used to connect user inputs to
- bind_support_fc operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.bind_support_fc()
- >>> my_fields_container = dpf.FieldsContainer()
- >>> op.inputs.fields_container.connect(my_fields_container)
- >>> my_support = dpf.MeshedRegion()
- >>> op.inputs.support.connect(my_support)
- """
-
- def __init__(self, op: Operator):
- super().__init__(bind_support_fc._spec().inputs, op)
- self._fields_container = Input(bind_support_fc._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._fields_container)
- self._support = Input(bind_support_fc._spec().input_pin(1), 1, op, -1)
- self._inputs.append(self._support)
-
- @property
- def fields_container(self):
- """Allows to connect fields_container input to the operator.
-
- Parameters
- ----------
- my_fields_container : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.bind_support_fc()
- >>> op.inputs.fields_container.connect(my_fields_container)
- >>> # or
- >>> op.inputs.fields_container(my_fields_container)
- """
- return self._fields_container
-
- @property
- def support(self):
- """Allows to connect support input to the operator.
-
- Meshed region or a support of the field.
-
- Parameters
- ----------
- my_support : MeshedRegion or AbstractFieldSupport or TimeFreqSupport
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.bind_support_fc()
- >>> op.inputs.support.connect(my_support)
- >>> # or
- >>> op.inputs.support(my_support)
- """
- return self._support
-
-
-class OutputsBindSupportFc(_Outputs):
- """Intermediate class used to get outputs from
- bind_support_fc operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.bind_support_fc()
- >>> # Connect inputs : op.inputs. ...
- >>> result_fields_container = op.outputs.fields_container()
- """
-
- def __init__(self, op: Operator):
- super().__init__(bind_support_fc._spec().outputs, op)
- self._fields_container = Output(bind_support_fc._spec().output_pin(0), 0, op)
- self._outputs.append(self._fields_container)
-
- @property
- def fields_container(self):
- """Allows to get fields_container output of the operator
-
- Returns
- ----------
- my_fields_container : FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.bind_support_fc()
- >>> # Connect inputs : op.inputs. ...
- >>> result_fields_container = op.outputs.fields_container()
- """ # noqa: E501
- return self._fields_container
diff --git a/src/ansys/dpf/core/operators/utility/make_time_chunk_for_each.py b/src/ansys/dpf/core/operators/utility/make_time_chunk_for_each.py
deleted file mode 100644
index 7094db1124..0000000000
--- a/src/ansys/dpf/core/operators/utility/make_time_chunk_for_each.py
+++ /dev/null
@@ -1,686 +0,0 @@
-"""
-make_time_chunk_for_each
-========================
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class make_time_chunk_for_each(Operator):
- """Splits a list of time/freq values into chunks depending on evaluated
- result properties,mesh size and max number of bytes accepted and
- calls 'make_for_each_range' to generate a range that can be
- consumed by the for_each operator
-
- Parameters
- ----------
- target_time_freq_values : float
- List of time/freq values to potentially split
- in chunks.
- operator_to_iterate : Operator
- Operator that must be reconnected with the
- range values.
- pin_index : int
- abstract_meshed_region : MeshedRegion
- The number of nodes (for "nodal" results) or
- number of elements (for "elemental"
- results) is used to compute the
- chunk.
- chunk_config : DataTree
- A data tree with an int attribute
- "max_num_bytes", an int attribute
- "dimensionality" (average result size
- by entity), a string attribute
- "location" ("nodal" or"elemental") is
- expected.
- producer_op11 : Operator
- producer_op12 : Operator
- output_pin_of_producer_op11 : int
- output_pin_of_producer_op12 : int
- input_pin_of_consumer_op11 : int
- input_pin_of_consumer_op12 : int
- consumer_op11 : Operator
- consumer_op12 : Operator
-
- Returns
- -------
- chunks :
- To connect to "producer_consumer_for_each"
- operator on pin 0
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
-
- >>> # Make input connections
- >>> my_target_time_freq_values = float()
- >>> op.inputs.target_time_freq_values.connect(my_target_time_freq_values)
- >>> my_operator_to_iterate = dpf.Operator()
- >>> op.inputs.operator_to_iterate.connect(my_operator_to_iterate)
- >>> my_pin_index = int()
- >>> op.inputs.pin_index.connect(my_pin_index)
- >>> my_abstract_meshed_region = dpf.MeshedRegion()
- >>> op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
- >>> my_chunk_config = dpf.DataTree()
- >>> op.inputs.chunk_config.connect(my_chunk_config)
- >>> my_producer_op11 = dpf.Operator()
- >>> op.inputs.producer_op11.connect(my_producer_op11)
- >>> my_producer_op12 = dpf.Operator()
- >>> op.inputs.producer_op12.connect(my_producer_op12)
- >>> my_output_pin_of_producer_op11 = int()
- >>> op.inputs.output_pin_of_producer_op11.connect(my_output_pin_of_producer_op11)
- >>> my_output_pin_of_producer_op12 = int()
- >>> op.inputs.output_pin_of_producer_op12.connect(my_output_pin_of_producer_op12)
- >>> my_input_pin_of_consumer_op11 = int()
- >>> op.inputs.input_pin_of_consumer_op11.connect(my_input_pin_of_consumer_op11)
- >>> my_input_pin_of_consumer_op12 = int()
- >>> op.inputs.input_pin_of_consumer_op12.connect(my_input_pin_of_consumer_op12)
- >>> my_consumer_op11 = dpf.Operator()
- >>> op.inputs.consumer_op11.connect(my_consumer_op11)
- >>> my_consumer_op12 = dpf.Operator()
- >>> op.inputs.consumer_op12.connect(my_consumer_op12)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.utility.make_time_chunk_for_each(
- ... target_time_freq_values=my_target_time_freq_values,
- ... operator_to_iterate=my_operator_to_iterate,
- ... pin_index=my_pin_index,
- ... abstract_meshed_region=my_abstract_meshed_region,
- ... chunk_config=my_chunk_config,
- ... producer_op11=my_producer_op11,
- ... producer_op12=my_producer_op12,
- ... output_pin_of_producer_op11=my_output_pin_of_producer_op11,
- ... output_pin_of_producer_op12=my_output_pin_of_producer_op12,
- ... input_pin_of_consumer_op11=my_input_pin_of_consumer_op11,
- ... input_pin_of_consumer_op12=my_input_pin_of_consumer_op12,
- ... consumer_op11=my_consumer_op11,
- ... consumer_op12=my_consumer_op12,
- ... )
-
- >>> # Get output data
- >>> result_chunks = op.outputs.chunks()
- """
-
- def __init__(
- self,
- target_time_freq_values=None,
- operator_to_iterate=None,
- pin_index=None,
- abstract_meshed_region=None,
- chunk_config=None,
- producer_op11=None,
- producer_op12=None,
- output_pin_of_producer_op11=None,
- output_pin_of_producer_op12=None,
- input_pin_of_consumer_op11=None,
- input_pin_of_consumer_op12=None,
- consumer_op11=None,
- consumer_op12=None,
- config=None,
- server=None,
- ):
- super().__init__(
- name="mechanical::make_time_chunk_for_each", config=config, server=server
- )
- self._inputs = InputsMakeTimeChunkForEach(self)
- self._outputs = OutputsMakeTimeChunkForEach(self)
- if target_time_freq_values is not None:
- self.inputs.target_time_freq_values.connect(target_time_freq_values)
- if operator_to_iterate is not None:
- self.inputs.operator_to_iterate.connect(operator_to_iterate)
- if pin_index is not None:
- self.inputs.pin_index.connect(pin_index)
- if abstract_meshed_region is not None:
- self.inputs.abstract_meshed_region.connect(abstract_meshed_region)
- if chunk_config is not None:
- self.inputs.chunk_config.connect(chunk_config)
- if producer_op11 is not None:
- self.inputs.producer_op11.connect(producer_op11)
- if producer_op12 is not None:
- self.inputs.producer_op12.connect(producer_op12)
- if output_pin_of_producer_op11 is not None:
- self.inputs.output_pin_of_producer_op11.connect(output_pin_of_producer_op11)
- if output_pin_of_producer_op12 is not None:
- self.inputs.output_pin_of_producer_op12.connect(output_pin_of_producer_op12)
- if input_pin_of_consumer_op11 is not None:
- self.inputs.input_pin_of_consumer_op11.connect(input_pin_of_consumer_op11)
- if input_pin_of_consumer_op12 is not None:
- self.inputs.input_pin_of_consumer_op12.connect(input_pin_of_consumer_op12)
- if consumer_op11 is not None:
- self.inputs.consumer_op11.connect(consumer_op11)
- if consumer_op12 is not None:
- self.inputs.consumer_op12.connect(consumer_op12)
-
- @staticmethod
- def _spec():
- description = """Splits a list of time/freq values into chunks depending on evaluated
- result properties,mesh size and max number of bytes
- accepted and calls "make_for_each_range" to generate a
- range that can be consumed by the for_each operator"""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="target_time_freq_values",
- type_names=["vector", "double"],
- optional=False,
- document="""List of time/freq values to potentially split
- in chunks.""",
- ),
- 1: PinSpecification(
- name="operator_to_iterate",
- type_names=["operator"],
- optional=False,
- document="""Operator that must be reconnected with the
- range values.""",
- ),
- 2: PinSpecification(
- name="pin_index",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 7: PinSpecification(
- name="abstract_meshed_region",
- type_names=["abstract_meshed_region"],
- optional=False,
- document="""The number of nodes (for "nodal" results) or
- number of elements (for "elemental"
- results) is used to compute the
- chunk.""",
- ),
- 200: PinSpecification(
- name="chunk_config",
- type_names=["abstract_data_tree"],
- optional=False,
- document="""A data tree with an int attribute
- "max_num_bytes", an int attribute
- "dimensionality" (average result size
- by entity), a string attribute
- "location" ("nodal" or"elemental") is
- expected.""",
- ),
- 1000: PinSpecification(
- name="producer_op1",
- type_names=["operator"],
- optional=False,
- document="""""",
- ),
- 1001: PinSpecification(
- name="producer_op1",
- type_names=["operator"],
- optional=False,
- document="""""",
- ),
- 1001: PinSpecification(
- name="output_pin_of_producer_op1",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 1002: PinSpecification(
- name="output_pin_of_producer_op1",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 1002: PinSpecification(
- name="input_pin_of_consumer_op1",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 1003: PinSpecification(
- name="input_pin_of_consumer_op1",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 1003: PinSpecification(
- name="consumer_op1",
- type_names=["operator"],
- optional=False,
- document="""""",
- ),
- 1004: PinSpecification(
- name="consumer_op1",
- type_names=["operator"],
- optional=False,
- document="""""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="chunks",
- optional=False,
- document="""To connect to "producer_consumer_for_each"
- operator on pin 0""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(
- name="mechanical::make_time_chunk_for_each", server=server
- )
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsMakeTimeChunkForEach
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsMakeTimeChunkForEach
- """
- return super().outputs
-
-
-class InputsMakeTimeChunkForEach(_Inputs):
- """Intermediate class used to connect user inputs to
- make_time_chunk_for_each operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> my_target_time_freq_values = float()
- >>> op.inputs.target_time_freq_values.connect(my_target_time_freq_values)
- >>> my_operator_to_iterate = dpf.Operator()
- >>> op.inputs.operator_to_iterate.connect(my_operator_to_iterate)
- >>> my_pin_index = int()
- >>> op.inputs.pin_index.connect(my_pin_index)
- >>> my_abstract_meshed_region = dpf.MeshedRegion()
- >>> op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
- >>> my_chunk_config = dpf.DataTree()
- >>> op.inputs.chunk_config.connect(my_chunk_config)
- >>> my_producer_op11 = dpf.Operator()
- >>> op.inputs.producer_op11.connect(my_producer_op11)
- >>> my_producer_op12 = dpf.Operator()
- >>> op.inputs.producer_op12.connect(my_producer_op12)
- >>> my_output_pin_of_producer_op11 = int()
- >>> op.inputs.output_pin_of_producer_op11.connect(my_output_pin_of_producer_op11)
- >>> my_output_pin_of_producer_op12 = int()
- >>> op.inputs.output_pin_of_producer_op12.connect(my_output_pin_of_producer_op12)
- >>> my_input_pin_of_consumer_op11 = int()
- >>> op.inputs.input_pin_of_consumer_op11.connect(my_input_pin_of_consumer_op11)
- >>> my_input_pin_of_consumer_op12 = int()
- >>> op.inputs.input_pin_of_consumer_op12.connect(my_input_pin_of_consumer_op12)
- >>> my_consumer_op11 = dpf.Operator()
- >>> op.inputs.consumer_op11.connect(my_consumer_op11)
- >>> my_consumer_op12 = dpf.Operator()
- >>> op.inputs.consumer_op12.connect(my_consumer_op12)
- """
-
- def __init__(self, op: Operator):
- super().__init__(make_time_chunk_for_each._spec().inputs, op)
- self._target_time_freq_values = Input(
- make_time_chunk_for_each._spec().input_pin(0), 0, op, -1
- )
- self._inputs.append(self._target_time_freq_values)
- self._operator_to_iterate = Input(
- make_time_chunk_for_each._spec().input_pin(1), 1, op, -1
- )
- self._inputs.append(self._operator_to_iterate)
- self._pin_index = Input(
- make_time_chunk_for_each._spec().input_pin(2), 2, op, -1
- )
- self._inputs.append(self._pin_index)
- self._abstract_meshed_region = Input(
- make_time_chunk_for_each._spec().input_pin(7), 7, op, -1
- )
- self._inputs.append(self._abstract_meshed_region)
- self._chunk_config = Input(
- make_time_chunk_for_each._spec().input_pin(200), 200, op, -1
- )
- self._inputs.append(self._chunk_config)
- self._producer_op11 = Input(
- make_time_chunk_for_each._spec().input_pin(1000), 1000, op, 0
- )
- self._inputs.append(self._producer_op11)
- self._producer_op12 = Input(
- make_time_chunk_for_each._spec().input_pin(1001), 1001, op, 1
- )
- self._inputs.append(self._producer_op12)
- self._output_pin_of_producer_op11 = Input(
- make_time_chunk_for_each._spec().input_pin(1001), 1001, op, 0
- )
- self._inputs.append(self._output_pin_of_producer_op11)
- self._output_pin_of_producer_op12 = Input(
- make_time_chunk_for_each._spec().input_pin(1002), 1002, op, 1
- )
- self._inputs.append(self._output_pin_of_producer_op12)
- self._input_pin_of_consumer_op11 = Input(
- make_time_chunk_for_each._spec().input_pin(1002), 1002, op, 0
- )
- self._inputs.append(self._input_pin_of_consumer_op11)
- self._input_pin_of_consumer_op12 = Input(
- make_time_chunk_for_each._spec().input_pin(1003), 1003, op, 1
- )
- self._inputs.append(self._input_pin_of_consumer_op12)
- self._consumer_op11 = Input(
- make_time_chunk_for_each._spec().input_pin(1003), 1003, op, 0
- )
- self._inputs.append(self._consumer_op11)
- self._consumer_op12 = Input(
- make_time_chunk_for_each._spec().input_pin(1004), 1004, op, 1
- )
- self._inputs.append(self._consumer_op12)
-
- @property
- def target_time_freq_values(self):
- """Allows to connect target_time_freq_values input to the operator.
-
- List of time/freq values to potentially split
- in chunks.
-
- Parameters
- ----------
- my_target_time_freq_values : float
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.target_time_freq_values.connect(my_target_time_freq_values)
- >>> # or
- >>> op.inputs.target_time_freq_values(my_target_time_freq_values)
- """
- return self._target_time_freq_values
-
- @property
- def operator_to_iterate(self):
- """Allows to connect operator_to_iterate input to the operator.
-
- Operator that must be reconnected with the
- range values.
-
- Parameters
- ----------
- my_operator_to_iterate : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.operator_to_iterate.connect(my_operator_to_iterate)
- >>> # or
- >>> op.inputs.operator_to_iterate(my_operator_to_iterate)
- """
- return self._operator_to_iterate
-
- @property
- def pin_index(self):
- """Allows to connect pin_index input to the operator.
-
- Parameters
- ----------
- my_pin_index : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.pin_index.connect(my_pin_index)
- >>> # or
- >>> op.inputs.pin_index(my_pin_index)
- """
- return self._pin_index
-
- @property
- def abstract_meshed_region(self):
- """Allows to connect abstract_meshed_region input to the operator.
-
- The number of nodes (for "nodal" results) or
- number of elements (for "elemental"
- results) is used to compute the
- chunk.
-
- Parameters
- ----------
- my_abstract_meshed_region : MeshedRegion
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
- >>> # or
- >>> op.inputs.abstract_meshed_region(my_abstract_meshed_region)
- """
- return self._abstract_meshed_region
-
- @property
- def chunk_config(self):
- """Allows to connect chunk_config input to the operator.
-
- A data tree with an int attribute
- "max_num_bytes", an int attribute
- "dimensionality" (average result size
- by entity), a string attribute
- "location" ("nodal" or"elemental") is
- expected.
-
- Parameters
- ----------
- my_chunk_config : DataTree
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.chunk_config.connect(my_chunk_config)
- >>> # or
- >>> op.inputs.chunk_config(my_chunk_config)
- """
- return self._chunk_config
-
- @property
- def producer_op11(self):
- """Allows to connect producer_op11 input to the operator.
-
- Parameters
- ----------
- my_producer_op11 : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.producer_op11.connect(my_producer_op11)
- >>> # or
- >>> op.inputs.producer_op11(my_producer_op11)
- """
- return self._producer_op11
-
- @property
- def producer_op12(self):
- """Allows to connect producer_op12 input to the operator.
-
- Parameters
- ----------
- my_producer_op12 : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.producer_op12.connect(my_producer_op12)
- >>> # or
- >>> op.inputs.producer_op12(my_producer_op12)
- """
- return self._producer_op12
-
- @property
- def output_pin_of_producer_op11(self):
- """Allows to connect output_pin_of_producer_op11 input to the operator.
-
- Parameters
- ----------
- my_output_pin_of_producer_op11 : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.output_pin_of_producer_op11.connect(my_output_pin_of_producer_op11)
- >>> # or
- >>> op.inputs.output_pin_of_producer_op11(my_output_pin_of_producer_op11)
- """
- return self._output_pin_of_producer_op11
-
- @property
- def output_pin_of_producer_op12(self):
- """Allows to connect output_pin_of_producer_op12 input to the operator.
-
- Parameters
- ----------
- my_output_pin_of_producer_op12 : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.output_pin_of_producer_op12.connect(my_output_pin_of_producer_op12)
- >>> # or
- >>> op.inputs.output_pin_of_producer_op12(my_output_pin_of_producer_op12)
- """
- return self._output_pin_of_producer_op12
-
- @property
- def input_pin_of_consumer_op11(self):
- """Allows to connect input_pin_of_consumer_op11 input to the operator.
-
- Parameters
- ----------
- my_input_pin_of_consumer_op11 : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.input_pin_of_consumer_op11.connect(my_input_pin_of_consumer_op11)
- >>> # or
- >>> op.inputs.input_pin_of_consumer_op11(my_input_pin_of_consumer_op11)
- """
- return self._input_pin_of_consumer_op11
-
- @property
- def input_pin_of_consumer_op12(self):
- """Allows to connect input_pin_of_consumer_op12 input to the operator.
-
- Parameters
- ----------
- my_input_pin_of_consumer_op12 : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.input_pin_of_consumer_op12.connect(my_input_pin_of_consumer_op12)
- >>> # or
- >>> op.inputs.input_pin_of_consumer_op12(my_input_pin_of_consumer_op12)
- """
- return self._input_pin_of_consumer_op12
-
- @property
- def consumer_op11(self):
- """Allows to connect consumer_op11 input to the operator.
-
- Parameters
- ----------
- my_consumer_op11 : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.consumer_op11.connect(my_consumer_op11)
- >>> # or
- >>> op.inputs.consumer_op11(my_consumer_op11)
- """
- return self._consumer_op11
-
- @property
- def consumer_op12(self):
- """Allows to connect consumer_op12 input to the operator.
-
- Parameters
- ----------
- my_consumer_op12 : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> op.inputs.consumer_op12.connect(my_consumer_op12)
- >>> # or
- >>> op.inputs.consumer_op12(my_consumer_op12)
- """
- return self._consumer_op12
-
-
-class OutputsMakeTimeChunkForEach(_Outputs):
- """Intermediate class used to get outputs from
- make_time_chunk_for_each operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> # Connect inputs : op.inputs. ...
- >>> result_chunks = op.outputs.chunks()
- """
-
- def __init__(self, op: Operator):
- super().__init__(make_time_chunk_for_each._spec().outputs, op)
- self._chunks = Output(make_time_chunk_for_each._spec().output_pin(0), 0, op)
- self._outputs.append(self._chunks)
-
- @property
- def chunks(self):
- """Allows to get chunks output of the operator
-
- Returns
- ----------
- my_chunks :
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_chunk_for_each()
- >>> # Connect inputs : op.inputs. ...
- >>> result_chunks = op.outputs.chunks()
- """ # noqa: E501
- return self._chunks
diff --git a/src/ansys/dpf/core/operators/utility/make_time_freq_support_chunk_for_each.py b/src/ansys/dpf/core/operators/utility/make_time_freq_support_chunk_for_each.py
deleted file mode 100644
index 3876fbddcb..0000000000
--- a/src/ansys/dpf/core/operators/utility/make_time_freq_support_chunk_for_each.py
+++ /dev/null
@@ -1,696 +0,0 @@
-"""
-make_time_freq_support_chunk_for_each
-=====================================
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class make_time_freq_support_chunk_for_each(Operator):
- """Splits a time freq support into chunks depending on evaluated result
- properties,mesh or field size and max number of bytes accepted and
- calls 'make_for_each_range' to generate a range that can be
- consumed by the for_each operator
-
- Parameters
- ----------
- target_time_freq_support : TimeFreqSupport
- List of time freq support to potentially
- split in chunks.
- operator_to_iterate : Operator
- Operator that must be reconnected with the
- range values.
- pin_index : int
- abstract_meshed_region : MeshedRegion or Field
- When a mesh is provided, the number of nodes
- (for "nodal" results) or number of
- elements (for "elemental" results) is
- used to compute the chunk. when a
- field is provided, its scoping size
- is used to compute the chunk.
- chunk_config : DataTree
- A data tree with an int attribute
- "max_num_bytes", an int attribute
- "dimensionality" (average result size
- by entity), a string attribute
- "location" ("nodal" or"elemental") is
- expected.
- producer_op11 : Operator
- producer_op12 : Operator
- output_pin_of_producer_op11 : int
- output_pin_of_producer_op12 : int
- input_pin_of_consumer_op11 : int
- input_pin_of_consumer_op12 : int
- consumer_op11 : Operator
- consumer_op12 : Operator
-
- Returns
- -------
- chunks :
- To connect to "producer_consumer_for_each"
- operator on pin 0
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
-
- >>> # Make input connections
- >>> my_target_time_freq_support = dpf.TimeFreqSupport()
- >>> op.inputs.target_time_freq_support.connect(my_target_time_freq_support)
- >>> my_operator_to_iterate = dpf.Operator()
- >>> op.inputs.operator_to_iterate.connect(my_operator_to_iterate)
- >>> my_pin_index = int()
- >>> op.inputs.pin_index.connect(my_pin_index)
- >>> my_abstract_meshed_region = dpf.MeshedRegion()
- >>> op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
- >>> my_chunk_config = dpf.DataTree()
- >>> op.inputs.chunk_config.connect(my_chunk_config)
- >>> my_producer_op11 = dpf.Operator()
- >>> op.inputs.producer_op11.connect(my_producer_op11)
- >>> my_producer_op12 = dpf.Operator()
- >>> op.inputs.producer_op12.connect(my_producer_op12)
- >>> my_output_pin_of_producer_op11 = int()
- >>> op.inputs.output_pin_of_producer_op11.connect(my_output_pin_of_producer_op11)
- >>> my_output_pin_of_producer_op12 = int()
- >>> op.inputs.output_pin_of_producer_op12.connect(my_output_pin_of_producer_op12)
- >>> my_input_pin_of_consumer_op11 = int()
- >>> op.inputs.input_pin_of_consumer_op11.connect(my_input_pin_of_consumer_op11)
- >>> my_input_pin_of_consumer_op12 = int()
- >>> op.inputs.input_pin_of_consumer_op12.connect(my_input_pin_of_consumer_op12)
- >>> my_consumer_op11 = dpf.Operator()
- >>> op.inputs.consumer_op11.connect(my_consumer_op11)
- >>> my_consumer_op12 = dpf.Operator()
- >>> op.inputs.consumer_op12.connect(my_consumer_op12)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each(
- ... target_time_freq_support=my_target_time_freq_support,
- ... operator_to_iterate=my_operator_to_iterate,
- ... pin_index=my_pin_index,
- ... abstract_meshed_region=my_abstract_meshed_region,
- ... chunk_config=my_chunk_config,
- ... producer_op11=my_producer_op11,
- ... producer_op12=my_producer_op12,
- ... output_pin_of_producer_op11=my_output_pin_of_producer_op11,
- ... output_pin_of_producer_op12=my_output_pin_of_producer_op12,
- ... input_pin_of_consumer_op11=my_input_pin_of_consumer_op11,
- ... input_pin_of_consumer_op12=my_input_pin_of_consumer_op12,
- ... consumer_op11=my_consumer_op11,
- ... consumer_op12=my_consumer_op12,
- ... )
-
- >>> # Get output data
- >>> result_chunks = op.outputs.chunks()
- """
-
- def __init__(
- self,
- target_time_freq_support=None,
- operator_to_iterate=None,
- pin_index=None,
- abstract_meshed_region=None,
- chunk_config=None,
- producer_op11=None,
- producer_op12=None,
- output_pin_of_producer_op11=None,
- output_pin_of_producer_op12=None,
- input_pin_of_consumer_op11=None,
- input_pin_of_consumer_op12=None,
- consumer_op11=None,
- consumer_op12=None,
- config=None,
- server=None,
- ):
- super().__init__(
- name="mechanical::make_time_freq_support_chunk_for_each",
- config=config,
- server=server,
- )
- self._inputs = InputsMakeTimeFreqSupportChunkForEach(self)
- self._outputs = OutputsMakeTimeFreqSupportChunkForEach(self)
- if target_time_freq_support is not None:
- self.inputs.target_time_freq_support.connect(target_time_freq_support)
- if operator_to_iterate is not None:
- self.inputs.operator_to_iterate.connect(operator_to_iterate)
- if pin_index is not None:
- self.inputs.pin_index.connect(pin_index)
- if abstract_meshed_region is not None:
- self.inputs.abstract_meshed_region.connect(abstract_meshed_region)
- if chunk_config is not None:
- self.inputs.chunk_config.connect(chunk_config)
- if producer_op11 is not None:
- self.inputs.producer_op11.connect(producer_op11)
- if producer_op12 is not None:
- self.inputs.producer_op12.connect(producer_op12)
- if output_pin_of_producer_op11 is not None:
- self.inputs.output_pin_of_producer_op11.connect(output_pin_of_producer_op11)
- if output_pin_of_producer_op12 is not None:
- self.inputs.output_pin_of_producer_op12.connect(output_pin_of_producer_op12)
- if input_pin_of_consumer_op11 is not None:
- self.inputs.input_pin_of_consumer_op11.connect(input_pin_of_consumer_op11)
- if input_pin_of_consumer_op12 is not None:
- self.inputs.input_pin_of_consumer_op12.connect(input_pin_of_consumer_op12)
- if consumer_op11 is not None:
- self.inputs.consumer_op11.connect(consumer_op11)
- if consumer_op12 is not None:
- self.inputs.consumer_op12.connect(consumer_op12)
-
- @staticmethod
- def _spec():
- description = """Splits a time freq support into chunks depending on evaluated result
- properties,mesh or field size and max number of bytes
- accepted and calls "make_for_each_range" to generate a
- range that can be consumed by the for_each operator"""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="target_time_freq_support",
- type_names=["time_freq_support"],
- optional=False,
- document="""List of time freq support to potentially
- split in chunks.""",
- ),
- 1: PinSpecification(
- name="operator_to_iterate",
- type_names=["operator"],
- optional=False,
- document="""Operator that must be reconnected with the
- range values.""",
- ),
- 2: PinSpecification(
- name="pin_index",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 7: PinSpecification(
- name="abstract_meshed_region",
- type_names=["abstract_meshed_region", "field"],
- optional=False,
- document="""When a mesh is provided, the number of nodes
- (for "nodal" results) or number of
- elements (for "elemental" results) is
- used to compute the chunk. when a
- field is provided, its scoping size
- is used to compute the chunk.""",
- ),
- 200: PinSpecification(
- name="chunk_config",
- type_names=["abstract_data_tree"],
- optional=False,
- document="""A data tree with an int attribute
- "max_num_bytes", an int attribute
- "dimensionality" (average result size
- by entity), a string attribute
- "location" ("nodal" or"elemental") is
- expected.""",
- ),
- 1000: PinSpecification(
- name="producer_op1",
- type_names=["operator"],
- optional=False,
- document="""""",
- ),
- 1001: PinSpecification(
- name="producer_op1",
- type_names=["operator"],
- optional=False,
- document="""""",
- ),
- 1001: PinSpecification(
- name="output_pin_of_producer_op1",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 1002: PinSpecification(
- name="output_pin_of_producer_op1",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 1002: PinSpecification(
- name="input_pin_of_consumer_op1",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 1003: PinSpecification(
- name="input_pin_of_consumer_op1",
- type_names=["int32"],
- optional=False,
- document="""""",
- ),
- 1003: PinSpecification(
- name="consumer_op1",
- type_names=["operator"],
- optional=False,
- document="""""",
- ),
- 1004: PinSpecification(
- name="consumer_op1",
- type_names=["operator"],
- optional=False,
- document="""""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="chunks",
- optional=False,
- document="""To connect to "producer_consumer_for_each"
- operator on pin 0""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(
- name="mechanical::make_time_freq_support_chunk_for_each", server=server
- )
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsMakeTimeFreqSupportChunkForEach
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsMakeTimeFreqSupportChunkForEach
- """
- return super().outputs
-
-
-class InputsMakeTimeFreqSupportChunkForEach(_Inputs):
- """Intermediate class used to connect user inputs to
- make_time_freq_support_chunk_for_each operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> my_target_time_freq_support = dpf.TimeFreqSupport()
- >>> op.inputs.target_time_freq_support.connect(my_target_time_freq_support)
- >>> my_operator_to_iterate = dpf.Operator()
- >>> op.inputs.operator_to_iterate.connect(my_operator_to_iterate)
- >>> my_pin_index = int()
- >>> op.inputs.pin_index.connect(my_pin_index)
- >>> my_abstract_meshed_region = dpf.MeshedRegion()
- >>> op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
- >>> my_chunk_config = dpf.DataTree()
- >>> op.inputs.chunk_config.connect(my_chunk_config)
- >>> my_producer_op11 = dpf.Operator()
- >>> op.inputs.producer_op11.connect(my_producer_op11)
- >>> my_producer_op12 = dpf.Operator()
- >>> op.inputs.producer_op12.connect(my_producer_op12)
- >>> my_output_pin_of_producer_op11 = int()
- >>> op.inputs.output_pin_of_producer_op11.connect(my_output_pin_of_producer_op11)
- >>> my_output_pin_of_producer_op12 = int()
- >>> op.inputs.output_pin_of_producer_op12.connect(my_output_pin_of_producer_op12)
- >>> my_input_pin_of_consumer_op11 = int()
- >>> op.inputs.input_pin_of_consumer_op11.connect(my_input_pin_of_consumer_op11)
- >>> my_input_pin_of_consumer_op12 = int()
- >>> op.inputs.input_pin_of_consumer_op12.connect(my_input_pin_of_consumer_op12)
- >>> my_consumer_op11 = dpf.Operator()
- >>> op.inputs.consumer_op11.connect(my_consumer_op11)
- >>> my_consumer_op12 = dpf.Operator()
- >>> op.inputs.consumer_op12.connect(my_consumer_op12)
- """
-
- def __init__(self, op: Operator):
- super().__init__(make_time_freq_support_chunk_for_each._spec().inputs, op)
- self._target_time_freq_support = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(0), 0, op, -1
- )
- self._inputs.append(self._target_time_freq_support)
- self._operator_to_iterate = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(1), 1, op, -1
- )
- self._inputs.append(self._operator_to_iterate)
- self._pin_index = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(2), 2, op, -1
- )
- self._inputs.append(self._pin_index)
- self._abstract_meshed_region = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(7), 7, op, -1
- )
- self._inputs.append(self._abstract_meshed_region)
- self._chunk_config = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(200), 200, op, -1
- )
- self._inputs.append(self._chunk_config)
- self._producer_op11 = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(1000), 1000, op, 0
- )
- self._inputs.append(self._producer_op11)
- self._producer_op12 = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(1001), 1001, op, 1
- )
- self._inputs.append(self._producer_op12)
- self._output_pin_of_producer_op11 = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(1001), 1001, op, 0
- )
- self._inputs.append(self._output_pin_of_producer_op11)
- self._output_pin_of_producer_op12 = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(1002), 1002, op, 1
- )
- self._inputs.append(self._output_pin_of_producer_op12)
- self._input_pin_of_consumer_op11 = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(1002), 1002, op, 0
- )
- self._inputs.append(self._input_pin_of_consumer_op11)
- self._input_pin_of_consumer_op12 = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(1003), 1003, op, 1
- )
- self._inputs.append(self._input_pin_of_consumer_op12)
- self._consumer_op11 = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(1003), 1003, op, 0
- )
- self._inputs.append(self._consumer_op11)
- self._consumer_op12 = Input(
- make_time_freq_support_chunk_for_each._spec().input_pin(1004), 1004, op, 1
- )
- self._inputs.append(self._consumer_op12)
-
- @property
- def target_time_freq_support(self):
- """Allows to connect target_time_freq_support input to the operator.
-
- List of time freq support to potentially
- split in chunks.
-
- Parameters
- ----------
- my_target_time_freq_support : TimeFreqSupport
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.target_time_freq_support.connect(my_target_time_freq_support)
- >>> # or
- >>> op.inputs.target_time_freq_support(my_target_time_freq_support)
- """
- return self._target_time_freq_support
-
- @property
- def operator_to_iterate(self):
- """Allows to connect operator_to_iterate input to the operator.
-
- Operator that must be reconnected with the
- range values.
-
- Parameters
- ----------
- my_operator_to_iterate : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.operator_to_iterate.connect(my_operator_to_iterate)
- >>> # or
- >>> op.inputs.operator_to_iterate(my_operator_to_iterate)
- """
- return self._operator_to_iterate
-
- @property
- def pin_index(self):
- """Allows to connect pin_index input to the operator.
-
- Parameters
- ----------
- my_pin_index : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.pin_index.connect(my_pin_index)
- >>> # or
- >>> op.inputs.pin_index(my_pin_index)
- """
- return self._pin_index
-
- @property
- def abstract_meshed_region(self):
- """Allows to connect abstract_meshed_region input to the operator.
-
- When a mesh is provided, the number of nodes
- (for "nodal" results) or number of
- elements (for "elemental" results) is
- used to compute the chunk. when a
- field is provided, its scoping size
- is used to compute the chunk.
-
- Parameters
- ----------
- my_abstract_meshed_region : MeshedRegion or Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
- >>> # or
- >>> op.inputs.abstract_meshed_region(my_abstract_meshed_region)
- """
- return self._abstract_meshed_region
-
- @property
- def chunk_config(self):
- """Allows to connect chunk_config input to the operator.
-
- A data tree with an int attribute
- "max_num_bytes", an int attribute
- "dimensionality" (average result size
- by entity), a string attribute
- "location" ("nodal" or"elemental") is
- expected.
-
- Parameters
- ----------
- my_chunk_config : DataTree
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.chunk_config.connect(my_chunk_config)
- >>> # or
- >>> op.inputs.chunk_config(my_chunk_config)
- """
- return self._chunk_config
-
- @property
- def producer_op11(self):
- """Allows to connect producer_op11 input to the operator.
-
- Parameters
- ----------
- my_producer_op11 : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.producer_op11.connect(my_producer_op11)
- >>> # or
- >>> op.inputs.producer_op11(my_producer_op11)
- """
- return self._producer_op11
-
- @property
- def producer_op12(self):
- """Allows to connect producer_op12 input to the operator.
-
- Parameters
- ----------
- my_producer_op12 : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.producer_op12.connect(my_producer_op12)
- >>> # or
- >>> op.inputs.producer_op12(my_producer_op12)
- """
- return self._producer_op12
-
- @property
- def output_pin_of_producer_op11(self):
- """Allows to connect output_pin_of_producer_op11 input to the operator.
-
- Parameters
- ----------
- my_output_pin_of_producer_op11 : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.output_pin_of_producer_op11.connect(my_output_pin_of_producer_op11)
- >>> # or
- >>> op.inputs.output_pin_of_producer_op11(my_output_pin_of_producer_op11)
- """
- return self._output_pin_of_producer_op11
-
- @property
- def output_pin_of_producer_op12(self):
- """Allows to connect output_pin_of_producer_op12 input to the operator.
-
- Parameters
- ----------
- my_output_pin_of_producer_op12 : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.output_pin_of_producer_op12.connect(my_output_pin_of_producer_op12)
- >>> # or
- >>> op.inputs.output_pin_of_producer_op12(my_output_pin_of_producer_op12)
- """
- return self._output_pin_of_producer_op12
-
- @property
- def input_pin_of_consumer_op11(self):
- """Allows to connect input_pin_of_consumer_op11 input to the operator.
-
- Parameters
- ----------
- my_input_pin_of_consumer_op11 : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.input_pin_of_consumer_op11.connect(my_input_pin_of_consumer_op11)
- >>> # or
- >>> op.inputs.input_pin_of_consumer_op11(my_input_pin_of_consumer_op11)
- """
- return self._input_pin_of_consumer_op11
-
- @property
- def input_pin_of_consumer_op12(self):
- """Allows to connect input_pin_of_consumer_op12 input to the operator.
-
- Parameters
- ----------
- my_input_pin_of_consumer_op12 : int
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.input_pin_of_consumer_op12.connect(my_input_pin_of_consumer_op12)
- >>> # or
- >>> op.inputs.input_pin_of_consumer_op12(my_input_pin_of_consumer_op12)
- """
- return self._input_pin_of_consumer_op12
-
- @property
- def consumer_op11(self):
- """Allows to connect consumer_op11 input to the operator.
-
- Parameters
- ----------
- my_consumer_op11 : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.consumer_op11.connect(my_consumer_op11)
- >>> # or
- >>> op.inputs.consumer_op11(my_consumer_op11)
- """
- return self._consumer_op11
-
- @property
- def consumer_op12(self):
- """Allows to connect consumer_op12 input to the operator.
-
- Parameters
- ----------
- my_consumer_op12 : Operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> op.inputs.consumer_op12.connect(my_consumer_op12)
- >>> # or
- >>> op.inputs.consumer_op12(my_consumer_op12)
- """
- return self._consumer_op12
-
-
-class OutputsMakeTimeFreqSupportChunkForEach(_Outputs):
- """Intermediate class used to get outputs from
- make_time_freq_support_chunk_for_each operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> # Connect inputs : op.inputs. ...
- >>> result_chunks = op.outputs.chunks()
- """
-
- def __init__(self, op: Operator):
- super().__init__(make_time_freq_support_chunk_for_each._spec().outputs, op)
- self._chunks = Output(
- make_time_freq_support_chunk_for_each._spec().output_pin(0), 0, op
- )
- self._outputs.append(self._chunks)
-
- @property
- def chunks(self):
- """Allows to get chunks output of the operator
-
- Returns
- ----------
- my_chunks :
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.make_time_freq_support_chunk_for_each()
- >>> # Connect inputs : op.inputs. ...
- >>> result_chunks = op.outputs.chunks()
- """ # noqa: E501
- return self._chunks
diff --git a/src/ansys/dpf/core/operators/utility/python_script_exec.py b/src/ansys/dpf/core/operators/utility/python_script_exec.py
deleted file mode 100644
index 4b7d5c0271..0000000000
--- a/src/ansys/dpf/core/operators/utility/python_script_exec.py
+++ /dev/null
@@ -1,133 +0,0 @@
-"""
-python_script_exec
-==================
-"""
-from ansys.dpf.core.dpf_operator import Operator
-from ansys.dpf.core.inputs import Input, _Inputs
-from ansys.dpf.core.outputs import Output, _Outputs, _modify_output_spec_with_one_type
-from ansys.dpf.core.operators.specification import PinSpecification, Specification
-
-"""Operators from "utility" category
-"""
-
-class python_script_exec(Operator):
- """Execute python input script.
-
- available inputs:
- - python_script (str)
-
- available outputs:
- - output ()
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.utility.python_script_exec()
-
- >>> # Make input connections
- >>> my_python_script = str()
- >>> op.inputs.python_script.connect(my_python_script)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.utility.python_script_exec(python_script=my_python_script)
-
- >>> # Get output data
- >>> result_output = op.outputs.output()"""
- def __init__(self, python_script=None, config=None, server=None):
- super().__init__(name="utility::python_script_exec", config = config, server = server)
- self._inputs = InputsPythonScriptExec(self)
- self._outputs = OutputsPythonScriptExec(self)
- if python_script !=None:
- self.inputs.python_script.connect(python_script)
-
- @staticmethod
- def _spec():
- spec = Specification(description="""Execute python input script.""",
- map_input_pin_spec={
- 0 : PinSpecification(name = "python_script", type_names=["string"], optional=False, document="""Input python script""")},
- map_output_pin_spec={
- 0 : PinSpecification(name = "output", type_names=[], optional=False, document="""The output can be of any supported type""")})
- return spec
-
-
- @staticmethod
- def default_config():
- return Operator.default_config(name = "utility::python_script_exec")
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator.
-
- Returns
- --------
- inputs : InputsPythonScriptExec
- """
- return super().inputs
-
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it.
-
- Returns
- --------
- outputs : OutputsPythonScriptExec
- """
- return super().outputs
-
-
-#internal name: utility::python_script_exec
-#scripting name: python_script_exec
-class InputsPythonScriptExec(_Inputs):
- """Intermediate class used to connect user inputs to python_script_exec operator
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.utility.python_script_exec()
- >>> my_python_script = str()
- >>> op.inputs.python_script.connect(my_python_script)
- """
- def __init__(self, op: Operator):
- super().__init__(python_script_exec._spec().inputs, op)
- self._python_script = Input(python_script_exec._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._python_script)
-
- @property
- def python_script(self):
- """Allows to connect python_script input to the operator
-
- - pindoc: Input python script
-
- Parameters
- ----------
- my_python_script : str,
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.utility.python_script_exec()
- >>> op.inputs.python_script.connect(my_python_script)
- >>> #or
- >>> op.inputs.python_script(my_python_script)
-
- """
- return self._python_script
-
-class OutputsPythonScriptExec(_Outputs):
- """Intermediate class used to get outputs from python_script_exec operator
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> op = dpf.operators.utility.python_script_exec()
- >>> # Connect inputs : op.inputs. ...
- """
- def __init__(self, op: Operator):
- super().__init__(python_script_exec._spec().outputs, op)
- pass
-
diff --git a/src/ansys/dpf/core/operators/utility/unitary_field.py b/src/ansys/dpf/core/operators/utility/unitary_field.py
deleted file mode 100644
index 9e40e480d0..0000000000
--- a/src/ansys/dpf/core/operators/utility/unitary_field.py
+++ /dev/null
@@ -1,189 +0,0 @@
-"""
-unitary_field
-=============
-Autogenerated DPF operator classes.
-"""
-
-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
-
-
-class unitary_field(Operator):
- """Takes a field and returns another field of scalars in the same
- location and scoping as the input field.
-
- Parameters
- ----------
- field : Field or FieldsContainer
- Field or fields container with only one field
- is expected
-
- Returns
- -------
- field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
-
- >>> # Instantiate operator
- >>> op = dpf.operators.utility.unitary_field()
-
- >>> # Make input connections
- >>> my_field = dpf.Field()
- >>> op.inputs.field.connect(my_field)
-
- >>> # Instantiate operator and connect inputs in one line
- >>> op = dpf.operators.utility.unitary_field(
- ... field=my_field,
- ... )
-
- >>> # Get output data
- >>> result_field = op.outputs.field()
- """
-
- def __init__(self, field=None, config=None, server=None):
- super().__init__(name="make_unit", config=config, server=server)
- self._inputs = InputsUnitaryField(self)
- self._outputs = OutputsUnitaryField(self)
- if field is not None:
- self.inputs.field.connect(field)
-
- @staticmethod
- def _spec():
- description = """Takes a field and returns another field of scalars in the same
- location and scoping as the input field."""
- spec = Specification(
- description=description,
- map_input_pin_spec={
- 0: PinSpecification(
- name="field",
- type_names=["field", "fields_container"],
- optional=False,
- document="""Field or fields container with only one field
- is expected""",
- ),
- },
- map_output_pin_spec={
- 0: PinSpecification(
- name="field",
- type_names=["field"],
- optional=False,
- document="""""",
- ),
- },
- )
- return spec
-
- @staticmethod
- def default_config(server=None):
- """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.DPFServer, optional
- Server with channel connected to the remote or local instance. When
- ``None``, attempts to use the global server.
- """
- return Operator.default_config(name="make_unit", server=server)
-
- @property
- def inputs(self):
- """Enables to connect inputs to the operator
-
- Returns
- --------
- inputs : InputsUnitaryField
- """
- return super().inputs
-
- @property
- def outputs(self):
- """Enables to get outputs of the operator by evaluating it
-
- Returns
- --------
- outputs : OutputsUnitaryField
- """
- return super().outputs
-
-
-class InputsUnitaryField(_Inputs):
- """Intermediate class used to connect user inputs to
- unitary_field operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.unitary_field()
- >>> my_field = dpf.Field()
- >>> op.inputs.field.connect(my_field)
- """
-
- def __init__(self, op: Operator):
- super().__init__(unitary_field._spec().inputs, op)
- self._field = Input(unitary_field._spec().input_pin(0), 0, op, -1)
- self._inputs.append(self._field)
-
- @property
- def field(self):
- """Allows to connect field input to the operator.
-
- Field or fields container with only one field
- is expected
-
- Parameters
- ----------
- my_field : Field or FieldsContainer
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.unitary_field()
- >>> op.inputs.field.connect(my_field)
- >>> # or
- >>> op.inputs.field(my_field)
- """
- return self._field
-
-
-class OutputsUnitaryField(_Outputs):
- """Intermediate class used to get outputs from
- unitary_field operator.
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.unitary_field()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """
-
- def __init__(self, op: Operator):
- super().__init__(unitary_field._spec().outputs, op)
- self._field = Output(unitary_field._spec().output_pin(0), 0, op)
- self._outputs.append(self._field)
-
- @property
- def field(self):
- """Allows to get field output of the operator
-
- Returns
- ----------
- my_field : Field
-
- Examples
- --------
- >>> from ansys.dpf import core as dpf
- >>> op = dpf.operators.utility.unitary_field()
- >>> # Connect inputs : op.inputs. ...
- >>> result_field = op.outputs.field()
- """ # noqa: E501
- return self._field
diff --git a/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll b/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll
index 806b479d27..a6bd910d55 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 d5a205cfa6..ba303a71fd 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 660f71c7e2..866deb8483 100644
Binary files a/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so and b/src/ansys/dpf/gatebin/libAns.Dpf.GrpcClient.so differ
diff --git a/src/ansys/dpf/gatebin/libDPFClientAPI.so b/src/ansys/dpf/gatebin/libDPFClientAPI.so
index 5c6af9d8cd..7a6b87709f 100644
Binary files a/src/ansys/dpf/gatebin/libDPFClientAPI.so and b/src/ansys/dpf/gatebin/libDPFClientAPI.so differ