diff --git a/docs/source/_static/dpf_operators.html b/docs/source/_static/dpf_operators.html
index c38e197302f..343a32414c7 100644
--- a/docs/source/_static/dpf_operators.html
+++ b/docs/source/_static/dpf_operators.html
@@ -2088,7 +2088,16 @@
Configurating operators
Euler Angles need to be included in the database.
Get the ZZ normal component (22 component).">Inputs
Outputs
Configurations
Scripting
result: structural temperature
Inputs
Outputs
Configurations
Scripting
result: beam torsional moment (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: equivalent stress parameter
Inputs
Outputs
Configurations
Scripting
filter: band pass (timescoping)
Inputs
Outputs
Configurations
Scripting
result: stress ratio
Inputs
Outputs
Configurations
Scripting
mesh: skin (tri mesh)
Inputs
Outputs
Configurations
Scripting
metadata: result info provider
Inputs
Outputs
Configurations
Scripting
result: accu eqv plastic strain
Inputs
Outputs
Configurations
Scripting
result: plastic state variable
Inputs
Outputs
Configurations
Scripting
math: average over label
Inputs
Outputs
Configurations
Scripting
result: accu eqv creep strain
Inputs
Outputs
Configurations
Scripting
result: plastic strain energy density
Inputs
Outputs
Configurations
Scripting
result: material property of element
Inputs
Outputs
Configurations
Scripting
result: creep strain energy density
Inputs
Outputs
Configurations
Scripting
result: erp radiation efficiency
Inputs
Outputs
Configurations
Scripting
result: elastic strain energy density
Inputs
Outputs
Configurations
Scripting
serialization: field to csv
Inputs
Outputs
Configurations
Scripting
utility: merge generic data container
Inputs
Outputs
Configurations
Scripting
result: global joint internal energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded element nodal forces
Inputs
Outputs
Configurations
Scripting
serialization: vtk to fields
Inputs
Outputs
Configurations
Scripting
utility: merge any objects
Inputs
Outputs
Configurations
Scripting
result: elemental volume
Inputs
Outputs
Configurations
Scripting
result: artificial hourglass energy
Inputs
Outputs
Configurations
Scripting
result: kinetic energy
Inputs
Outputs
Configurations
Scripting
result: thermal dissipation energy
Inputs
Outputs
Configurations
Scripting
result: nodal force
Inputs
Outputs
Configurations
Scripting
result: total mass
Inputs
Outputs
Configurations
Scripting
result: rms static pressure
Inputs
Outputs
Configurations
Scripting
result: swelling strains
Inputs
Outputs
Configurations
Scripting
result: temperature
Inputs
Outputs
Configurations
Scripting
result: compute stress
Inputs
Outputs
Configurations
Scripting
result: raw displacement
Inputs
Outputs
Configurations
Scripting
result: raw reaction force
Inputs
Outputs
Configurations
Scripting
result: turbulent kinetic energy (k)
Inputs
Outputs
Configurations
Scripting
result: electric potential
Inputs
Outputs
Configurations
Scripting
result: thickness
Inputs
Outputs
Configurations
Scripting
serialization: csv to field
Inputs
Outputs
Configurations
Scripting
result: mapdl run
Inputs
Outputs
Configurations
Scripting
result: equivalent mass
Inputs
Outputs
Configurations
Scripting
result: element orientations
Inputs
Outputs
Configurations
Scripting
serialization: serialize to hdf5
Inputs
Outputs
Configurations
Scripting
result: custom result
Inputs
Outputs
Configurations
Scripting
result: elemental heat generation
Inputs
Outputs
Configurations
Scripting
result: temperature gradient
Inputs
Outputs
Configurations
Scripting
result: joint force reaction
Inputs
Outputs
Configurations
Scripting
result: joint moment reaction
Inputs
Outputs
Configurations
Scripting
result: beam T shear force (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: joint relative displacement
Inputs
Outputs
Configurations
Scripting
result: joint relative rotation
Inputs
Outputs
Configurations
Scripting
result: joint relative velocity
Inputs
Outputs
Configurations
Scripting
result: joint relative acceleration
Inputs
Outputs
Configurations
Scripting
result: joint relative angular acceleration
Inputs
Outputs
Configurations
Scripting
result: thermal strains eqv
Inputs
Outputs
Configurations
Scripting
serialization: txt to data tree
Inputs
Outputs
Configurations
Scripting
result: global internal energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: stress von mises
Inputs
Outputs
Configurations
Scripting
utility: merge supports
Inputs
Outputs
Configurations
Scripting
result: global kinetic energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: global time step (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: matrix inverse
Inputs
Outputs
Configurations
Scripting
result: global rigid body stopper energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
geo: cartesian to spherical coordinates
Inputs
Outputs
Configurations
Scripting
result: global spring and damper energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: beam T bending moment (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: global hourglass energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: global system damping energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
mesh: mesh clipper
Inputs
Outputs
Configurations
Scripting
result: global eroded kinetic energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: global energy ratio (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: global added mass (LSDyna)
Inputs
Outputs
Configurations
Scripting
mapping: on reduced coordinates
Inputs
Outputs
Configurations
Scripting
result: global added mass (percentage) (LSDyna)
Inputs
Outputs
Configurations
Scripting
invariant: principal invariants (fields container)
Inputs
Outputs
Configurations
Scripting
result: global center of mass (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: beam S shear force (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: beam S bending moment (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: beam RS shear stress (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: beam TR shear stress (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: beam axial plastic strain (LSDyna)
Inputs
Outputs
Configurations
Scripting
invariant: von mises eqv (field)
Inputs
Outputs
Configurations
Scripting
invariant: segalman von mises eqv (field)
Inputs
Outputs
Configurations
Scripting
result: part eroded internal energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: part kinetic energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
scoping: on mesh property
Inputs
Outputs
Configurations
Scripting
serialization: string deserializer
Inputs
Outputs
Configurations
Scripting
result: compute stress Z
Inputs
Outputs
Configurations
Scripting
result: part eroded kinetic energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
scoping: from mesh
Inputs
Outputs
Configurations
Scripting
result: part added mass (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: part hourglass energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: part rigid body velocity (LSDyna)
Inputs
Outputs
Configurations
Scripting
min_max: time of max
Inputs
Outputs
Configurations
Scripting
metadata: cyclic support provider
Inputs
Outputs
Configurations
Scripting
result: density
Inputs
Outputs
Configurations
Scripting
averaging: elemental to elemental nodal (fields container)
Inputs
Outputs
Configurations
Scripting
result: total pressure
Inputs
Outputs
Configurations
Scripting
result: mean velocity
Inputs
Outputs
Configurations
Scripting
result: entropy
Inputs
Outputs
Configurations
Scripting
result: volume fraction
Inputs
Outputs
Configurations
Scripting
result: mass flow rate
Inputs
Outputs
Configurations
Scripting
result: mach number
Inputs
Outputs
Configurations
Scripting
result: rms temperature
Inputs
Outputs
Configurations
Scripting
result: mean temperature
Inputs
Outputs
Configurations
Scripting
scoping: scoping get attribute
Inputs
Outputs
Configurations
Scripting
min_max: over fields container
Inputs
Outputs
Configurations
Scripting
result: surface heat rate
Inputs
Outputs
Configurations
Scripting
result: thermal conductivity
Inputs
Outputs
Configurations
Scripting
result: specific heat
Inputs
Outputs
Configurations
Scripting
logic: enrich materials
Inputs
Outputs
Configurations
Scripting
result: turbulent dissipation rate (epsilon)
Inputs
Outputs
Configurations
Scripting
metadata: time freq provider
Inputs
Outputs
Configurations
Scripting
metadata: mesh info provider
Inputs
Outputs
Configurations
Scripting
metadata: material provider
Inputs
Outputs
Configurations
Scripting
result: von mises stresses as mechanical
Inputs
Outputs
Configurations
Scripting
metadata: streams provider
Inputs
Outputs
Configurations
Scripting
result: poynting vector surface
Inputs
Outputs
Configurations
Scripting
metadata: datasources provider
Inputs
Outputs
Configurations
Scripting
mesh: mesh provider
Inputs
Outputs
Configurations
Scripting
mesh: meshes provider
Inputs
Outputs
Configurations
Scripting
utility: for each
Inputs
Outputs
Configurations
Scripting
metadata: mesh selection manager provider
Inputs
Outputs
Configurations
Scripting
metadata: boundary condition provider
Inputs
Outputs
Configurations
Scripting
serialization: data tree to txt
Inputs
Outputs
Configurations
Scripting
utility: merge property fields
Inputs
Outputs
Configurations
Scripting
metadata: cyclic analysis?
Inputs
Outputs
Configurations
Scripting
metadata: material support provider
Inputs
Outputs
Configurations
Scripting
scoping: on named selection
Inputs
Outputs
Configurations
Scripting
scoping: reduce sampleing scoping
Inputs
Outputs
Configurations
Scripting
math: accumulation per scoping
Inputs
Outputs
Configurations
Scripting
logic: fields included?
Inputs
Outputs
Configurations
Scripting
mesh: beam properties
Inputs
Outputs
Configurations
Scripting
result: euler nodes
Inputs
Outputs
Configurations
Scripting
filter: low pass (timescoping)
Inputs
Outputs
Configurations
Scripting
scoping: rescope
Inputs
Outputs
Configurations
Scripting
utility: data sources get attribute
Inputs
Outputs
Configurations
Scripting
utility: remote workflow instantiate
Inputs
Outputs
Configurations
Scripting
mesh: make sphere levelset
Inputs
Outputs
Configurations
Scripting
utility: remote operator instantiate
Inputs
Outputs
Configurations
Scripting
result: add rigid body motion (fields container)
Inputs
Outputs
Configurations
Scripting
utility: merge time freq supports
Inputs
Outputs
Configurations
Scripting
scoping: split on property type
Inputs
Outputs
Configurations
Scripting
min_max: incremental over fields container
Inputs
Outputs
Configurations
Scripting
min_max: max over time
Inputs
Outputs
Configurations
Scripting
scoping: connectivity ids
Inputs
Outputs
Configurations
Scripting
utility: overlap fields
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal elemental (field)
Inputs
Outputs
Configurations
Scripting
metadata: property field provider by property name
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
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
result: erp accumulate results
Inputs
Outputs
Configurations
Scripting
logic: merge solid and shell fields
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity over time
Inputs
Outputs
Configurations
Scripting
result: global_to_nodal
Inputs
Outputs
Configurations
Scripting
min_max: min over time
Inputs
Outputs
Configurations
Scripting
geo: element nodal contribution
Inputs
Outputs
Configurations
Scripting
serialization: export symbolic workflow
Inputs
Outputs
Configurations
Scripting
result: write cms rbd file
Inputs
Outputs
Configurations
Scripting
logic: same meshes?
Inputs
Outputs
Configurations
Scripting
mesh: external layer
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
utility: split in for each range
Inputs
Outputs
Configurations
Scripting
mesh: skin
Inputs
Outputs
Configurations
Scripting
result: smisc
Inputs
Outputs
Configurations
Scripting
utility: incremental field
Inputs
Outputs
Configurations
Scripting
logic: descending sort
Inputs
Outputs
Configurations
Scripting
utility: incremental fields container
Inputs
Outputs
Configurations
Scripting
geo: rotate (fields container)
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
result: members in bending not certified
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
min_max: time of min
Inputs
Outputs
Configurations
Scripting
min_max: phase of max
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains
Inputs
Outputs
Configurations
Scripting
min_max: incremental over field
Inputs
Outputs
Configurations
Scripting
logic: same fields?
Inputs
Outputs
Configurations
Scripting
logic: same fields container?
Inputs
Outputs
Configurations
Scripting
math: window hanning
Inputs
Outputs
Configurations
Scripting
filter: high pass (field)
Inputs
Outputs
Configurations
Scripting
result: members in compression not certified
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: band pass (field)
Inputs
Outputs
Configurations
Scripting
filter: low pass (timefreq)
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
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
serialization: data tree to json
Inputs
Outputs
Configurations
Scripting
serialization: json to data tree
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (fields container)
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
metadata: integrate over time freq
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)
Inputs
Outputs
Configurations
Scripting
averaging: to nodal (field)
Inputs
Outputs
Configurations
Scripting
averaging: to nodal (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: elemental mean (field)
Inputs
Outputs
Configurations
Scripting
averaging: elemental mean (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: nodal to elemental (field)
Inputs
Outputs
Configurations
Scripting
averaging: nodal to elemental (fields container)
Inputs
Outputs
Configurations
Scripting
invariant: eigen values (field)
Inputs
Outputs
Configurations
Scripting
invariant: principal invariants (field)
Inputs
Outputs
Configurations
Scripting
invariant: von mises eqv (fields container)
Inputs
Outputs
Configurations
Scripting
invariant: segalman von mises eqv (fields container)
Inputs
Outputs
Configurations
Scripting
scoping: compute element centroids
Inputs
Outputs
Configurations
Scripting
metadata: cyclic mesh expansion
Inputs
Outputs
Configurations
Scripting
result: cyclic analytic stress eqv max
Inputs
Outputs
Configurations
Scripting
result: remove rigid body motion (fields container)
Inputs
Outputs
Configurations
Scripting
result: cyclic expansion
Inputs
Outputs
Configurations
Scripting
averaging: nodal fraction (fields container)
Inputs
Outputs
Configurations
Scripting
result: recombine cyclic harmonic indices
Inputs
Outputs
Configurations
Scripting
mapping: find reduced coordinates
Inputs
Outputs
Configurations
Scripting
mapping: on coordinates
Inputs
Outputs
Configurations
Scripting
mapping: scoping on coordinates
Inputs
Outputs
Configurations
Scripting
filter: abc weightings
Inputs
Outputs
Configurations
Scripting
math: fft filtering and cubic fitting
Outputs
Configurations
Scripting
mesh: meshes provider
Inputs
Outputs
Configurations
Scripting
utility: for each
Inputs
Outputs
Configurations
Scripting
metadata: mesh selection manager provider
Inputs
Outputs
Configurations
Scripting
metadata: boundary condition provider
Inputs
Outputs
Configurations
Scripting
serialization: data tree to txt
Inputs
Outputs
Configurations
Scripting
utility: merge property fields
Inputs
Outputs
Configurations
Scripting
metadata: cyclic analysis?
Inputs
Outputs
Configurations
Scripting
metadata: material support provider
Inputs
Outputs
Configurations
Scripting
scoping: on named selection
Inputs
Outputs
Configurations
Scripting
scoping: reduce sampleing scoping
Inputs
Outputs
Configurations
Scripting
math: accumulation per scoping
Inputs
Outputs
Configurations
Scripting
logic: fields included?
Inputs
Outputs
Configurations
Scripting
mesh: beam properties
Inputs
Outputs
Configurations
Scripting
result: euler nodes
Inputs
Outputs
Configurations
Scripting
filter: low pass (timescoping)
Inputs
Outputs
Configurations
Scripting
scoping: rescope
Inputs
Outputs
Configurations
Scripting
utility: data sources get attribute
Inputs
Outputs
Configurations
Scripting
utility: remote workflow instantiate
Inputs
Outputs
Configurations
Scripting
mesh: make sphere levelset
Inputs
Outputs
Configurations
Scripting
utility: remote operator instantiate
Inputs
Outputs
Configurations
Scripting
result: add rigid body motion (fields container)
Inputs
Outputs
Configurations
Scripting
utility: merge time freq supports
Inputs
Outputs
Configurations
Scripting
scoping: split on property type
Inputs
Outputs
Configurations
Scripting
min_max: incremental over fields container
Inputs
Outputs
Configurations
Scripting
min_max: max over time
Inputs
Outputs
Configurations
Scripting
scoping: connectivity ids
Inputs
Outputs
Configurations
Scripting
utility: overlap fields
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal elemental (field)
Inputs
Outputs
Configurations
Scripting
metadata: property field provider by property name
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
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
result: erp accumulate results
Inputs
Outputs
Configurations
Scripting
logic: merge solid and shell fields
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity over time
Inputs
Outputs
Configurations
Scripting
result: global_to_nodal
Inputs
Outputs
Configurations
Scripting
min_max: min over time
Inputs
Outputs
Configurations
Scripting
geo: element nodal contribution
Inputs
Outputs
Configurations
Scripting
serialization: export symbolic workflow
Inputs
Outputs
Configurations
Scripting
result: write cms rbd file
Inputs
Outputs
Configurations
Scripting
logic: same meshes?
Inputs
Outputs
Configurations
Scripting
mesh: external layer
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
utility: split in for each range
Inputs
Outputs
Configurations
Scripting
mesh: skin
Inputs
Outputs
Configurations
Scripting
result: smisc
Inputs
Outputs
Configurations
Scripting
utility: incremental field
Inputs
Outputs
Configurations
Scripting
logic: descending sort
Inputs
Outputs
Configurations
Scripting
utility: incremental fields container
Inputs
Outputs
Configurations
Scripting
geo: rotate (fields container)
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
result: members in bending not certified
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
min_max: time of min
Inputs
Outputs
Configurations
Scripting
min_max: phase of max
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains
Inputs
Outputs
Configurations
Scripting
min_max: incremental over field
Inputs
Outputs
Configurations
Scripting
logic: same fields?
Inputs
Outputs
Configurations
Scripting
logic: same fields container?
Inputs
Outputs
Configurations
Scripting
math: window hanning
Inputs
Outputs
Configurations
Scripting
filter: high pass (field)
Inputs
Outputs
Configurations
Scripting
result: members in compression not certified
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: band pass (field)
Inputs
Outputs
Configurations
Scripting
filter: low pass (timefreq)
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
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
serialization: data tree to json
Inputs
Outputs
Configurations
Scripting
serialization: json to data tree
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (fields container)
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
metadata: integrate over time freq
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)
Inputs
Outputs
Configurations
Scripting
averaging: to nodal (field)
Inputs
Outputs
Configurations
Scripting
averaging: to nodal (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: elemental mean (field)
Inputs
Outputs
Configurations
Scripting
averaging: elemental mean (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: nodal to elemental (field)
Inputs
Outputs
Configurations
Scripting
averaging: nodal to elemental (fields container)
Inputs
Outputs
Configurations
Scripting
invariant: eigen values (field)
Inputs
Outputs
Configurations
Scripting
invariant: principal invariants (field)
Inputs
Outputs
Configurations
Scripting
invariant: von mises eqv (fields container)
Inputs
Outputs
Configurations
Scripting
invariant: segalman von mises eqv (fields container)
Inputs
Outputs
Configurations
Scripting
scoping: compute element centroids
Inputs
Outputs
Configurations
Scripting
metadata: cyclic mesh expansion
Inputs
Outputs
Configurations
Scripting
result: cyclic analytic stress eqv max
Inputs
Outputs
Configurations
Scripting
result: remove rigid body motion (fields container)
Inputs
Outputs
Configurations
Scripting
result: cyclic expansion
Inputs
Outputs
Configurations
Scripting
averaging: nodal fraction (fields container)
Inputs
Outputs
Configurations
Scripting
result: recombine cyclic harmonic indices
Inputs
Outputs
Configurations
Scripting
mapping: find reduced coordinates
Inputs
Outputs
Configurations
Scripting
mapping: on coordinates
Inputs
Outputs
Configurations
Scripting
mapping: scoping on coordinates
Inputs
Outputs
Configurations
Scripting
filter: abc weightings
Inputs
Outputs
Configurations
Scripting
math: fft filtering and cubic fitting
Inputs
Outputs
Configurations
Scripting
mapping: solid to skin
Inputs
Outputs
Configurations
Scripting
mapping: solid to skin (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (field)
Inputs
Outputs
Configurations
Scripting
averaging: elemental difference (field)
Inputs
Outputs
Configurations
Scripting
averaging: elemental fraction (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: extend to mid nodes (fields container)
Inputs
Outputs
Configurations
Scripting
geo: rotate cylindrical coordinates
Inputs
Outputs
Configurations
Scripting
geo: rotate in cylindrical coordinates (fields container)
Inputs
Outputs
Configurations
Scripting
geo: spherical to cartesian coordinates (fields container)
Inputs
Outputs
Configurations
Scripting
geo: spherical to cartesian coordinates
Inputs
Outputs
Configurations
Scripting
mesh: change cs (meshes)
Inputs
Outputs
Configurations
Scripting
geo: normals provider nl (nodes or elements)
Inputs
Outputs
Configurations
Scripting
geo: elements volumes over time
Inputs
Outputs
Configurations
Scripting
geo: elements facets surfaces over time
Inputs
Outputs
Configurations
Scripting
math: window bartlett
Inputs
Outputs
Configurations
Scripting
mesh: from scoping
Inputs
Outputs
Configurations
Scripting
mesh: split field wrt mesh regions
Inputs
Outputs
Configurations
Scripting
mesh: split mesh wrt property
Inputs
Outputs
Configurations
Scripting
result: torque
Inputs
Outputs
Configurations
Scripting
result: euler load buckling
Inputs
Outputs
Configurations
Scripting
result: compute stress 3
Inputs
Outputs
Configurations
Scripting
geo: gauss to node (field)
Inputs
Outputs
Configurations
Scripting
averaging: gauss to node (fields container)
Inputs
Outputs
Configurations
Scripting
math: correlation
Inputs
Outputs
Configurations
Scripting
result: workflow energy per component
Inputs
Outputs
Configurations
Scripting
result: add rigid body motion (field)
Inputs
Outputs
Configurations
Scripting
math: window hamming
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded temperature
Inputs
Outputs
Configurations
Scripting
result: nodal_to_global
Inputs
Outputs
Configurations
Scripting
mesh: mesh_to_graphics
Inputs
Outputs
Configurations
Scripting
result: enf solution to global cs
Inputs
Outputs
Configurations
Scripting
result: cms matrices provider
Inputs
Outputs
Configurations
Scripting
result: coordinate system
Inputs
Outputs
Configurations
Scripting
serialization: hdf5dpf custom read
Inputs
Outputs
Configurations
Scripting
result: nmisc
Inputs
Outputs
Configurations
Scripting
result: stress solution to global cs
Inputs
Outputs
Configurations
Scripting
result: elastic strain solution to global cs
Inputs
Outputs
Configurations
Scripting
result: plastic strain to global cs
Inputs
Outputs
Configurations
Scripting
result: prns to field
Inputs
Outputs
Configurations
Scripting
mesh: mesh cutter
Inputs
Outputs
Configurations
Scripting
result: remove rigid body motion (field)
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded displacement
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded acceleration
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded stress
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded el strain
Inputs
Outputs
Configurations
Scripting
result: cms subfile info provider
Inputs
Outputs
Configurations
Scripting
result: cyclic volume
Inputs
Outputs
Configurations
Scripting
math: window triangular
Inputs
Outputs
Configurations
Scripting
result: compute total strain XZ
Configurating operators
Only linear analysis are supported without On Demand Expansion.
All coordinates are global coordinates.
Euler Angles need to be included in the database.
-Get the XZ shear component (02 component).">Inputs
Outputs
Configurations
Scripting
result: cms dst table provider
Inputs
Outputs
Configurations
Scripting
invariant: eigen vectors (on field)
Inputs
Outputs
Configurations
Scripting
result: mapdl material properties
Inputs
Outputs
Configurations
Scripting
result: mapdl_section
Inputs
Outputs
Configurations
Scripting
result: rom data provider
Inputs
Outputs
Configurations
Scripting
result: compute invariant terms motion
Inputs
Outputs
Configurations
Scripting
result: write motion dfmf file
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded element heat flux
Inputs
Outputs
Configurations
Scripting
mesh: mesh plan clipper
Inputs
Outputs
Configurations
Scripting
mesh: mesh_to_graphics_edges
Inputs
Outputs
Configurations
Scripting
serialization: migrate to vtk
Inputs
Outputs
Configurations
Scripting
mesh: combine levelset
Inputs
Outputs
Configurations
Scripting
mesh: exclude levelset
Inputs
Outputs
Configurations
Scripting
mesh: make plane levelset
Inputs
Outputs
Configurations
Scripting
mapping: fft
Inputs
Outputs
Configurations
Scripting
math: fft gradient evaluation
Inputs
Outputs
Configurations
Scripting
math: fft multi harmonic solution minmax
Inputs
Outputs
Configurations
Scripting
math: qr solve
Inputs
Outputs
Configurations
Scripting
math: svd
Inputs
Outputs
Configurations
Scripting
mapping: prep sampling fft
Inputs
Outputs
Configurations
Scripting
math: window welch
Inputs
Outputs
Configurations
Scripting
serialization: hdf5dpf generate result file
Inputs
Outputs
Configurations
Scripting
result: migrate to h5dpf
Inputs
Outputs
Configurations
Scripting
utility: hdf5dpf workflow provider
Inputs
Outputs
Configurations
Scripting
serialization: vtu export
Inputs
Outputs
Configurations
Scripting
result: compute total strain
Inputs
Outputs
Configurations
Scripting
result: cms dst table provider
Inputs
Outputs
Configurations
Scripting
invariant: eigen vectors (on field)
Inputs
Outputs
Configurations
Scripting
result: mapdl material properties
Inputs
Outputs
Configurations
Scripting
result: mapdl_section
Inputs
Outputs
Configurations
Scripting
result: rom data provider
Inputs
Outputs
Configurations
Scripting
result: compute invariant terms motion
Inputs
Outputs
Configurations
Scripting
result: write motion dfmf file
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded element heat flux
Inputs
Outputs
Configurations
Scripting
mesh: mesh plan clipper
Inputs
Outputs
Configurations
Scripting
mesh: mesh_to_graphics_edges
Inputs
Outputs
Configurations
Scripting
serialization: migrate to vtk
Inputs
Outputs
Configurations
Scripting
mesh: combine levelset
Inputs
Outputs
Configurations
Scripting
mesh: exclude levelset
Inputs
Outputs
Configurations
Scripting
mesh: make plane levelset
Inputs
Outputs
Configurations
Scripting
mapping: fft
Inputs
Outputs
Configurations
Scripting
math: fft gradient evaluation
Inputs
Outputs
Configurations
Scripting
math: fft multi harmonic solution minmax
Inputs
Outputs
Configurations
Scripting
math: qr solve
Inputs
Outputs
Configurations
Scripting
math: svd
Inputs
Outputs
Configurations
Scripting
mapping: prep sampling fft
Inputs
Outputs
Configurations
Scripting
math: window welch
Inputs
Outputs
Configurations
Scripting
serialization: hdf5dpf generate result file
Inputs
Outputs
Configurations
Scripting
result: migrate to h5dpf
Inputs
Outputs
Configurations
Scripting
utility: hdf5dpf workflow provider
Inputs
Outputs
Configurations
Scripting
serialization: vtu export
Inputs
Outputs
Configurations
Scripting
result: compute total strain
>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
>>> my_force_averaging = int()
>>> op.inputs.force_averaging.connect(my_force_averaging)
+ >>> my_algorithm = int()
+ >>> op.inputs.algorithm.connect(my_algorithm)
>>> # Instantiate operator and connect inputs in one line
>>> op = dpf.operators.averaging.elemental_to_nodal(
... field=my_field,
... mesh_scoping=my_mesh_scoping,
... force_averaging=my_force_averaging,
+ ... algorithm=my_algorithm,
... )
>>> # Get output data
@@ -57,6 +74,7 @@ def __init__(
field=None,
mesh_scoping=None,
force_averaging=None,
+ algorithm=None,
config=None,
server=None,
):
@@ -69,11 +87,24 @@ def __init__(
self.inputs.mesh_scoping.connect(mesh_scoping)
if force_averaging is not None:
self.inputs.force_averaging.connect(force_averaging)
+ if algorithm is not None:
+ self.inputs.algorithm.connect(algorithm)
@staticmethod
def _spec():
- description = """Transforms an Elemental Nodal field to a Nodal field. The result is
- computed on a given node's scoping."""
+ description = """Transforms an Elemental field to a Nodal field. 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 volume 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={
@@ -98,6 +129,14 @@ def _spec():
to 1 (default is 1 for integrated
results and 0 for discrete ones).""",
),
+ 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(
@@ -161,6 +200,8 @@ class InputsElementalToNodal(_Inputs):
>>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
>>> my_force_averaging = int()
>>> op.inputs.force_averaging.connect(my_force_averaging)
+ >>> my_algorithm = int()
+ >>> op.inputs.algorithm.connect(my_algorithm)
"""
def __init__(self, op: Operator):
@@ -173,6 +214,8 @@ def __init__(self, op: Operator):
elemental_to_nodal._spec().input_pin(2), 2, op, -1
)
self._inputs.append(self._force_averaging)
+ self._algorithm = Input(elemental_to_nodal._spec().input_pin(200), 200, op, -1)
+ self._inputs.append(self._algorithm)
@property
def field(self):
@@ -235,6 +278,28 @@ def force_averaging(self):
"""
return self._force_averaging
+ @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()
+ >>> op.inputs.algorithm.connect(my_algorithm)
+ >>> # or
+ >>> op.inputs.algorithm(my_algorithm)
+ """
+ return self._algorithm
+
class OutputsElementalToNodal(_Outputs):
"""Intermediate class used to get outputs from
diff --git a/src/ansys/dpf/core/operators/averaging/elemental_to_nodal_fc.py b/src/ansys/dpf/core/operators/averaging/elemental_to_nodal_fc.py
index 1fc13137d43..c13d11a8c0a 100644
--- a/src/ansys/dpf/core/operators/averaging/elemental_to_nodal_fc.py
+++ b/src/ansys/dpf/core/operators/averaging/elemental_to_nodal_fc.py
@@ -12,7 +12,17 @@
class elemental_to_nodal_fc(Operator):
"""Transforms Elemental Nodal fields to Nodal fields. The result is
- computed on a given node's scoping.
+ 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.
Parameters
----------
@@ -23,6 +33,10 @@ class elemental_to_nodal_fc(Operator):
to 1 (default is 1 for integrated
results and 0 for discrete ones).
mesh_scoping : Scoping or ScopingsContainer, optional
+ algorithm : int, optional
+ Forces the usage of algorithm 1, 2 or 3
+ (default is chosen based on the type
+ of mesh).
Examples
@@ -41,6 +55,8 @@ class elemental_to_nodal_fc(Operator):
>>> 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(
@@ -48,6 +64,7 @@ class elemental_to_nodal_fc(Operator):
... mesh=my_mesh,
... force_averaging=my_force_averaging,
... mesh_scoping=my_mesh_scoping,
+ ... algorithm=my_algorithm,
... )
>>> # Get output data
@@ -60,6 +77,7 @@ def __init__(
mesh=None,
force_averaging=None,
mesh_scoping=None,
+ algorithm=None,
config=None,
server=None,
):
@@ -74,11 +92,24 @@ def __init__(
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."""
+ 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={
@@ -108,6 +139,14 @@ def _spec():
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(
@@ -173,6 +212,8 @@ class InputsElementalToNodalFc(_Inputs):
>>> 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):
@@ -191,6 +232,10 @@ def __init__(self, op: Operator):
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):
@@ -268,6 +313,28 @@ def mesh_scoping(self):
"""
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
diff --git a/src/ansys/dpf/core/operators/build.py b/src/ansys/dpf/core/operators/build.py
index 6cd42d2d97d..fb7af4fc33a 100644
--- a/src/ansys/dpf/core/operators/build.py
+++ b/src/ansys/dpf/core/operators/build.py
@@ -75,7 +75,7 @@ def build_pin_data(pins, output=False):
pin_name = pin_name.replace(">", "_")
main_type = docstring_types[0] if len(docstring_types) >= 1 else ""
- built_in_types = ("int", "double", "string", "bool", "float", "str")
+ built_in_types = ("int", "double", "string", "bool", "float", "str", "dict")
# Case where output pin has multiple types.
multiple_types = len(type_names) >= 2
diff --git a/src/ansys/dpf/core/operators/geo/__init__.py b/src/ansys/dpf/core/operators/geo/__init__.py
index af5d256c512..2956c822566 100644
--- a/src/ansys/dpf/core/operators/geo/__init__.py
+++ b/src/ansys/dpf/core/operators/geo/__init__.py
@@ -15,3 +15,4 @@
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 .transform_invariant_terms_rbd import transform_invariant_terms_rbd
diff --git a/src/ansys/dpf/core/operators/geo/transform_invariant_terms_rbd.py b/src/ansys/dpf/core/operators/geo/transform_invariant_terms_rbd.py
new file mode 100644
index 00000000000..642ed162ce4
--- /dev/null
+++ b/src/ansys/dpf/core/operators/geo/transform_invariant_terms_rbd.py
@@ -0,0 +1,290 @@
+"""
+transform_invariant_terms_rbd
+=============================
+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 _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class transform_invariant_terms_rbd(Operator):
+ """Transform invariant terms rbd based on a coordinate system
+ (translation + rotation).
+
+ Parameters
+ ----------
+ rotation_matrix : Field
+ 3-3 rotation matrix.
+ coordinate_system : Field
+ Origin of the new coordinate system.
+ in_cms_rbd_file_path : str
+ File name with cms_rbd extension where to
+ read the input cms_rbd file.
+ out_cms_rbd_file_path : str
+ File name with cms_rbd extension where to
+ create the new cms_rbd file.
+
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.geo.transform_invariant_terms_rbd()
+
+ >>> # Make input connections
+ >>> my_rotation_matrix = dpf.Field()
+ >>> op.inputs.rotation_matrix.connect(my_rotation_matrix)
+ >>> my_coordinate_system = dpf.Field()
+ >>> op.inputs.coordinate_system.connect(my_coordinate_system)
+ >>> my_in_cms_rbd_file_path = str()
+ >>> op.inputs.in_cms_rbd_file_path.connect(my_in_cms_rbd_file_path)
+ >>> my_out_cms_rbd_file_path = str()
+ >>> op.inputs.out_cms_rbd_file_path.connect(my_out_cms_rbd_file_path)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.geo.transform_invariant_terms_rbd(
+ ... rotation_matrix=my_rotation_matrix,
+ ... coordinate_system=my_coordinate_system,
+ ... in_cms_rbd_file_path=my_in_cms_rbd_file_path,
+ ... out_cms_rbd_file_path=my_out_cms_rbd_file_path,
+ ... )
+
+ """
+
+ def __init__(
+ self,
+ rotation_matrix=None,
+ coordinate_system=None,
+ in_cms_rbd_file_path=None,
+ out_cms_rbd_file_path=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(
+ name="transform_invariant_terms_rbd", config=config, server=server
+ )
+ self._inputs = InputsTransformInvariantTermsRbd(self)
+ self._outputs = OutputsTransformInvariantTermsRbd(self)
+ if rotation_matrix is not None:
+ self.inputs.rotation_matrix.connect(rotation_matrix)
+ if coordinate_system is not None:
+ self.inputs.coordinate_system.connect(coordinate_system)
+ if in_cms_rbd_file_path is not None:
+ self.inputs.in_cms_rbd_file_path.connect(in_cms_rbd_file_path)
+ if out_cms_rbd_file_path is not None:
+ self.inputs.out_cms_rbd_file_path.connect(out_cms_rbd_file_path)
+
+ @staticmethod
+ def _spec():
+ description = """Transform invariant terms rbd based on a coordinate system
+ (translation + rotation)."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="rotation_matrix",
+ type_names=["field"],
+ optional=False,
+ document="""3-3 rotation matrix.""",
+ ),
+ 1: PinSpecification(
+ name="coordinate_system",
+ type_names=["field"],
+ optional=False,
+ document="""Origin of the new coordinate system.""",
+ ),
+ 2: PinSpecification(
+ name="in_cms_rbd_file_path",
+ type_names=["string"],
+ optional=False,
+ document="""File name with cms_rbd extension where to
+ read the input cms_rbd file.""",
+ ),
+ 3: PinSpecification(
+ name="out_cms_rbd_file_path",
+ type_names=["string"],
+ optional=False,
+ document="""File name with cms_rbd extension where to
+ create the new cms_rbd file.""",
+ ),
+ },
+ map_output_pin_spec={},
+ )
+ 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="transform_invariant_terms_rbd", server=server
+ )
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsTransformInvariantTermsRbd
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsTransformInvariantTermsRbd
+ """
+ return super().outputs
+
+
+class InputsTransformInvariantTermsRbd(_Inputs):
+ """Intermediate class used to connect user inputs to
+ transform_invariant_terms_rbd operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.geo.transform_invariant_terms_rbd()
+ >>> my_rotation_matrix = dpf.Field()
+ >>> op.inputs.rotation_matrix.connect(my_rotation_matrix)
+ >>> my_coordinate_system = dpf.Field()
+ >>> op.inputs.coordinate_system.connect(my_coordinate_system)
+ >>> my_in_cms_rbd_file_path = str()
+ >>> op.inputs.in_cms_rbd_file_path.connect(my_in_cms_rbd_file_path)
+ >>> my_out_cms_rbd_file_path = str()
+ >>> op.inputs.out_cms_rbd_file_path.connect(my_out_cms_rbd_file_path)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(transform_invariant_terms_rbd._spec().inputs, op)
+ self._rotation_matrix = Input(
+ transform_invariant_terms_rbd._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._rotation_matrix)
+ self._coordinate_system = Input(
+ transform_invariant_terms_rbd._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._coordinate_system)
+ self._in_cms_rbd_file_path = Input(
+ transform_invariant_terms_rbd._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._in_cms_rbd_file_path)
+ self._out_cms_rbd_file_path = Input(
+ transform_invariant_terms_rbd._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._out_cms_rbd_file_path)
+
+ @property
+ def rotation_matrix(self):
+ """Allows to connect rotation_matrix input to the operator.
+
+ 3-3 rotation matrix.
+
+ Parameters
+ ----------
+ my_rotation_matrix : Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.geo.transform_invariant_terms_rbd()
+ >>> op.inputs.rotation_matrix.connect(my_rotation_matrix)
+ >>> # or
+ >>> op.inputs.rotation_matrix(my_rotation_matrix)
+ """
+ return self._rotation_matrix
+
+ @property
+ def coordinate_system(self):
+ """Allows to connect coordinate_system input to the operator.
+
+ Origin of the new coordinate system.
+
+ Parameters
+ ----------
+ my_coordinate_system : Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.geo.transform_invariant_terms_rbd()
+ >>> op.inputs.coordinate_system.connect(my_coordinate_system)
+ >>> # or
+ >>> op.inputs.coordinate_system(my_coordinate_system)
+ """
+ return self._coordinate_system
+
+ @property
+ def in_cms_rbd_file_path(self):
+ """Allows to connect in_cms_rbd_file_path input to the operator.
+
+ File name with cms_rbd extension where to
+ read the input cms_rbd file.
+
+ Parameters
+ ----------
+ my_in_cms_rbd_file_path : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.geo.transform_invariant_terms_rbd()
+ >>> op.inputs.in_cms_rbd_file_path.connect(my_in_cms_rbd_file_path)
+ >>> # or
+ >>> op.inputs.in_cms_rbd_file_path(my_in_cms_rbd_file_path)
+ """
+ return self._in_cms_rbd_file_path
+
+ @property
+ def out_cms_rbd_file_path(self):
+ """Allows to connect out_cms_rbd_file_path input to the operator.
+
+ File name with cms_rbd extension where to
+ create the new cms_rbd file.
+
+ Parameters
+ ----------
+ my_out_cms_rbd_file_path : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.geo.transform_invariant_terms_rbd()
+ >>> op.inputs.out_cms_rbd_file_path.connect(my_out_cms_rbd_file_path)
+ >>> # or
+ >>> op.inputs.out_cms_rbd_file_path(my_out_cms_rbd_file_path)
+ """
+ return self._out_cms_rbd_file_path
+
+
+class OutputsTransformInvariantTermsRbd(_Outputs):
+ """Intermediate class used to get outputs from
+ transform_invariant_terms_rbd operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.geo.transform_invariant_terms_rbd()
+ >>> # Connect inputs : op.inputs. ...
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(transform_invariant_terms_rbd._spec().outputs, op)
diff --git a/src/ansys/dpf/core/operators/math/modal_participation.py b/src/ansys/dpf/core/operators/math/modal_participation.py
index 2abf5774765..6f9f41ab1be 100644
--- a/src/ansys/dpf/core/operators/math/modal_participation.py
+++ b/src/ansys/dpf/core/operators/math/modal_participation.py
@@ -22,7 +22,7 @@ class modal_participation(Operator):
Imag part of field v
mode_shapes : FieldsContainer
ponderation : Field, optional
- force_label_space : LabelSpace, optional
+ force_label_space : dict, optional
If set, will force a label space for output
result.
@@ -43,7 +43,7 @@ class modal_participation(Operator):
>>> op.inputs.mode_shapes.connect(my_mode_shapes)
>>> my_ponderation = dpf.Field()
>>> op.inputs.ponderation.connect(my_ponderation)
- >>> my_force_label_space = dpf.LabelSpace()
+ >>> my_force_label_space = dict()
>>> op.inputs.force_label_space.connect(my_force_label_space)
>>> # Instantiate operator and connect inputs in one line
@@ -190,7 +190,7 @@ class InputsModalParticipation(_Inputs):
>>> op.inputs.mode_shapes.connect(my_mode_shapes)
>>> my_ponderation = dpf.Field()
>>> op.inputs.ponderation.connect(my_ponderation)
- >>> my_force_label_space = dpf.LabelSpace()
+ >>> my_force_label_space = dict()
>>> op.inputs.force_label_space.connect(my_force_label_space)
"""
@@ -294,7 +294,7 @@ def force_label_space(self):
Parameters
----------
- my_force_label_space : LabelSpace
+ my_force_label_space : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/density.py b/src/ansys/dpf/core/operators/result/density.py
index 2764bb0b3b7..39ea42f1089 100644
--- a/src/ansys/dpf/core/operators/result/density.py
+++ b/src/ansys/dpf/core/operators/result/density.py
@@ -58,11 +58,11 @@ class density(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class density(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsDensity(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/dynamic_viscosity.py b/src/ansys/dpf/core/operators/result/dynamic_viscosity.py
index 6bb85fe9437..500501c34e0 100644
--- a/src/ansys/dpf/core/operators/result/dynamic_viscosity.py
+++ b/src/ansys/dpf/core/operators/result/dynamic_viscosity.py
@@ -59,11 +59,11 @@ class dynamic_viscosity(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class dynamic_viscosity(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsDynamicViscosity(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -503,7 +503,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -525,7 +525,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/enthalpy.py b/src/ansys/dpf/core/operators/result/enthalpy.py
index 76eaa0d4741..76c9001d572 100644
--- a/src/ansys/dpf/core/operators/result/enthalpy.py
+++ b/src/ansys/dpf/core/operators/result/enthalpy.py
@@ -58,11 +58,11 @@ class enthalpy(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class enthalpy(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsEnthalpy(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/entropy.py b/src/ansys/dpf/core/operators/result/entropy.py
index d9185faf058..e8632499232 100644
--- a/src/ansys/dpf/core/operators/result/entropy.py
+++ b/src/ansys/dpf/core/operators/result/entropy.py
@@ -58,11 +58,11 @@ class entropy(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class entropy(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsEntropy(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/epsilon.py b/src/ansys/dpf/core/operators/result/epsilon.py
index 446762fb4bc..d06ce27d1a7 100644
--- a/src/ansys/dpf/core/operators/result/epsilon.py
+++ b/src/ansys/dpf/core/operators/result/epsilon.py
@@ -59,11 +59,11 @@ class epsilon(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class epsilon(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsEpsilon(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/mach_number.py b/src/ansys/dpf/core/operators/result/mach_number.py
index 1669224eabf..5affa69ddae 100644
--- a/src/ansys/dpf/core/operators/result/mach_number.py
+++ b/src/ansys/dpf/core/operators/result/mach_number.py
@@ -58,11 +58,11 @@ class mach_number(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class mach_number(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsMachNumber(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/mass_flow_rate.py b/src/ansys/dpf/core/operators/result/mass_flow_rate.py
index 9fee8389066..1bf9ddb5693 100644
--- a/src/ansys/dpf/core/operators/result/mass_flow_rate.py
+++ b/src/ansys/dpf/core/operators/result/mass_flow_rate.py
@@ -58,11 +58,11 @@ class mass_flow_rate(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class mass_flow_rate(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsMassFlowRate(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/mass_fraction.py b/src/ansys/dpf/core/operators/result/mass_fraction.py
index 72c8d7e4505..a2f631c7fe7 100644
--- a/src/ansys/dpf/core/operators/result/mass_fraction.py
+++ b/src/ansys/dpf/core/operators/result/mass_fraction.py
@@ -58,11 +58,11 @@ class mass_fraction(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class mass_fraction(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsMassFraction(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/mean_static_pressure.py b/src/ansys/dpf/core/operators/result/mean_static_pressure.py
index eb1bd9d76a7..7ad2ff5a368 100644
--- a/src/ansys/dpf/core/operators/result/mean_static_pressure.py
+++ b/src/ansys/dpf/core/operators/result/mean_static_pressure.py
@@ -59,11 +59,11 @@ class mean_static_pressure(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class mean_static_pressure(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsMeanStaticPressure(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -503,7 +503,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -525,7 +525,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/mean_temperature.py b/src/ansys/dpf/core/operators/result/mean_temperature.py
index 2f49d7cf0a3..f4473499bea 100644
--- a/src/ansys/dpf/core/operators/result/mean_temperature.py
+++ b/src/ansys/dpf/core/operators/result/mean_temperature.py
@@ -59,11 +59,11 @@ class mean_temperature(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class mean_temperature(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsMeanTemperature(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -497,7 +497,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -519,7 +519,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/mean_velocity.py b/src/ansys/dpf/core/operators/result/mean_velocity.py
index 588a7f3bc34..de76d5f1b79 100644
--- a/src/ansys/dpf/core/operators/result/mean_velocity.py
+++ b/src/ansys/dpf/core/operators/result/mean_velocity.py
@@ -58,11 +58,11 @@ class mean_velocity(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class mean_velocity(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsMeanVelocity(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/omega.py b/src/ansys/dpf/core/operators/result/omega.py
index 502239bf97c..08788bd5d79 100644
--- a/src/ansys/dpf/core/operators/result/omega.py
+++ b/src/ansys/dpf/core/operators/result/omega.py
@@ -59,11 +59,11 @@ class omega(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class omega(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsOmega(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/rms_static_pressure.py b/src/ansys/dpf/core/operators/result/rms_static_pressure.py
index 0514810539d..503da1fef5f 100644
--- a/src/ansys/dpf/core/operators/result/rms_static_pressure.py
+++ b/src/ansys/dpf/core/operators/result/rms_static_pressure.py
@@ -59,11 +59,11 @@ class rms_static_pressure(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class rms_static_pressure(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsRmsStaticPressure(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -503,7 +503,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -525,7 +525,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/rms_temperature.py b/src/ansys/dpf/core/operators/result/rms_temperature.py
index 372492504b1..5143a80997e 100644
--- a/src/ansys/dpf/core/operators/result/rms_temperature.py
+++ b/src/ansys/dpf/core/operators/result/rms_temperature.py
@@ -59,11 +59,11 @@ class rms_temperature(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class rms_temperature(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsRmsTemperature(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/rms_velocity.py b/src/ansys/dpf/core/operators/result/rms_velocity.py
index 8d759f277e5..6d909c3440f 100644
--- a/src/ansys/dpf/core/operators/result/rms_velocity.py
+++ b/src/ansys/dpf/core/operators/result/rms_velocity.py
@@ -58,11 +58,11 @@ class rms_velocity(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class rms_velocity(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsRmsVelocity(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/specific_heat.py b/src/ansys/dpf/core/operators/result/specific_heat.py
index d4bf31af2a4..2096111116e 100644
--- a/src/ansys/dpf/core/operators/result/specific_heat.py
+++ b/src/ansys/dpf/core/operators/result/specific_heat.py
@@ -58,11 +58,11 @@ class specific_heat(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class specific_heat(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsSpecificHeat(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/static_pressure.py b/src/ansys/dpf/core/operators/result/static_pressure.py
index c8b81bd6063..173a63ec2eb 100644
--- a/src/ansys/dpf/core/operators/result/static_pressure.py
+++ b/src/ansys/dpf/core/operators/result/static_pressure.py
@@ -59,11 +59,11 @@ class static_pressure(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class static_pressure(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsStaticPressure(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/superficial_velocity.py b/src/ansys/dpf/core/operators/result/superficial_velocity.py
index 35897933f1a..0e8a81fa08b 100644
--- a/src/ansys/dpf/core/operators/result/superficial_velocity.py
+++ b/src/ansys/dpf/core/operators/result/superficial_velocity.py
@@ -59,11 +59,11 @@ class superficial_velocity(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class superficial_velocity(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsSuperficialVelocity(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -503,7 +503,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -525,7 +525,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/surface_heat_rate.py b/src/ansys/dpf/core/operators/result/surface_heat_rate.py
index 8b204573432..a5537f3162b 100644
--- a/src/ansys/dpf/core/operators/result/surface_heat_rate.py
+++ b/src/ansys/dpf/core/operators/result/surface_heat_rate.py
@@ -59,11 +59,11 @@ class surface_heat_rate(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class surface_heat_rate(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsSurfaceHeatRate(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -503,7 +503,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -525,7 +525,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/temperature.py b/src/ansys/dpf/core/operators/result/temperature.py
index 8a5f46a43bd..26caa79eb7a 100644
--- a/src/ansys/dpf/core/operators/result/temperature.py
+++ b/src/ansys/dpf/core/operators/result/temperature.py
@@ -71,11 +71,11 @@ class temperature(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -107,9 +107,9 @@ class temperature(Operator):
>>> op.inputs.read_cyclic.connect(my_read_cyclic)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -369,9 +369,9 @@ class InputsTemperature(_Inputs):
>>> op.inputs.read_cyclic.connect(my_read_cyclic)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -627,7 +627,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -649,7 +649,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/thermal_conductivity.py b/src/ansys/dpf/core/operators/result/thermal_conductivity.py
index d2ebec7a32a..b5dc3afae6d 100644
--- a/src/ansys/dpf/core/operators/result/thermal_conductivity.py
+++ b/src/ansys/dpf/core/operators/result/thermal_conductivity.py
@@ -59,11 +59,11 @@ class thermal_conductivity(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class thermal_conductivity(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsThermalConductivity(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -503,7 +503,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -525,7 +525,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/total_pressure.py b/src/ansys/dpf/core/operators/result/total_pressure.py
index 8cc1f8b7e05..8c76bf94e54 100644
--- a/src/ansys/dpf/core/operators/result/total_pressure.py
+++ b/src/ansys/dpf/core/operators/result/total_pressure.py
@@ -58,11 +58,11 @@ class total_pressure(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class total_pressure(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsTotalPressure(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/total_temperature.py b/src/ansys/dpf/core/operators/result/total_temperature.py
index cf97712b6a0..a10eda3b312 100644
--- a/src/ansys/dpf/core/operators/result/total_temperature.py
+++ b/src/ansys/dpf/core/operators/result/total_temperature.py
@@ -59,11 +59,11 @@ class total_temperature(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class total_temperature(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsTotalTemperature(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -503,7 +503,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -525,7 +525,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/turbulent_kinetic_energy.py b/src/ansys/dpf/core/operators/result/turbulent_kinetic_energy.py
index f7703cdd61c..bfd94ca35c8 100644
--- a/src/ansys/dpf/core/operators/result/turbulent_kinetic_energy.py
+++ b/src/ansys/dpf/core/operators/result/turbulent_kinetic_energy.py
@@ -59,11 +59,11 @@ class turbulent_kinetic_energy(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class turbulent_kinetic_energy(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsTurbulentKineticEnergy(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -509,7 +509,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -531,7 +531,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/turbulent_viscosity.py b/src/ansys/dpf/core/operators/result/turbulent_viscosity.py
index 0278bc8fd55..8cd5272d163 100644
--- a/src/ansys/dpf/core/operators/result/turbulent_viscosity.py
+++ b/src/ansys/dpf/core/operators/result/turbulent_viscosity.py
@@ -59,11 +59,11 @@ class turbulent_viscosity(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class turbulent_viscosity(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsTurbulentViscosity(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -503,7 +503,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -525,7 +525,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/velocity.py b/src/ansys/dpf/core/operators/result/velocity.py
index e665e67d352..911964eb6e7 100644
--- a/src/ansys/dpf/core/operators/result/velocity.py
+++ b/src/ansys/dpf/core/operators/result/velocity.py
@@ -71,11 +71,11 @@ class velocity(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -107,9 +107,9 @@ class velocity(Operator):
>>> op.inputs.read_cyclic.connect(my_read_cyclic)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -369,9 +369,9 @@ class InputsVelocity(_Inputs):
>>> op.inputs.read_cyclic.connect(my_read_cyclic)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -627,7 +627,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -649,7 +649,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/volume_fraction.py b/src/ansys/dpf/core/operators/result/volume_fraction.py
index fd7f1a44e04..5f16a3b52d9 100644
--- a/src/ansys/dpf/core/operators/result/volume_fraction.py
+++ b/src/ansys/dpf/core/operators/result/volume_fraction.py
@@ -59,11 +59,11 @@ class volume_fraction(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class volume_fraction(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsVolumeFraction(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/wall_shear_stress.py b/src/ansys/dpf/core/operators/result/wall_shear_stress.py
index a99b4cef354..44b9f470cf8 100644
--- a/src/ansys/dpf/core/operators/result/wall_shear_stress.py
+++ b/src/ansys/dpf/core/operators/result/wall_shear_stress.py
@@ -59,11 +59,11 @@ class wall_shear_stress(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -89,9 +89,9 @@ class wall_shear_stress(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsWallShearStress(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -503,7 +503,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -525,7 +525,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/write_cms_rbd_file.py b/src/ansys/dpf/core/operators/result/write_cms_rbd_file.py
index 15c516a9d06..2a547015f21 100644
--- a/src/ansys/dpf/core/operators/result/write_cms_rbd_file.py
+++ b/src/ansys/dpf/core/operators/result/write_cms_rbd_file.py
@@ -21,7 +21,7 @@ class write_cms_rbd_file(Operator):
Center of mass of the body
inertia_relief : Field
Inertia matrix
- model_size : PropertyField
+ model_size : float
Size of the diagonal box containing the body
master_node_coordinates :
v_trsf :
@@ -62,7 +62,7 @@ class write_cms_rbd_file(Operator):
>>> op.inputs.center_of_mass.connect(my_center_of_mass)
>>> my_inertia_relief = dpf.Field()
>>> op.inputs.inertia_relief.connect(my_inertia_relief)
- >>> my_model_size = dpf.PropertyField()
+ >>> my_model_size = float()
>>> op.inputs.model_size.connect(my_model_size)
>>> my_master_node_coordinates = dpf.()
>>> op.inputs.master_node_coordinates.connect(my_master_node_coordinates)
@@ -244,7 +244,7 @@ def _spec():
),
3: PinSpecification(
name="model_size",
- type_names=["property_field"],
+ type_names=["double"],
optional=False,
document="""Size of the diagonal box containing the body""",
),
@@ -425,7 +425,7 @@ class InputsWriteCmsRbdFile(_Inputs):
>>> op.inputs.center_of_mass.connect(my_center_of_mass)
>>> my_inertia_relief = dpf.Field()
>>> op.inputs.inertia_relief.connect(my_inertia_relief)
- >>> my_model_size = dpf.PropertyField()
+ >>> my_model_size = float()
>>> op.inputs.model_size.connect(my_model_size)
>>> my_master_node_coordinates = dpf.()
>>> op.inputs.master_node_coordinates.connect(my_master_node_coordinates)
@@ -590,7 +590,7 @@ def model_size(self):
Parameters
----------
- my_model_size : PropertyField
+ my_model_size : float
Examples
--------
diff --git a/src/ansys/dpf/core/operators/result/y_plus.py b/src/ansys/dpf/core/operators/result/y_plus.py
index 49cd4c9ada3..10be3739b62 100644
--- a/src/ansys/dpf/core/operators/result/y_plus.py
+++ b/src/ansys/dpf/core/operators/result/y_plus.py
@@ -58,11 +58,11 @@ class y_plus(Operator):
of the model (region corresponds to
zone for fluid results or part for
lsdyna results).
- qualifiers1 : LabelSpace, optional
+ qualifiers1 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
- qualifiers2 : LabelSpace, optional
+ qualifiers2 : dict, optional
(for fluid results only) labelspace with
combination of zone, phases or
species ids
@@ -88,9 +88,9 @@ class y_plus(Operator):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
>>> # Instantiate operator and connect inputs in one line
@@ -309,9 +309,9 @@ class InputsYPlus(_Inputs):
>>> op.inputs.mesh.connect(my_mesh)
>>> my_region_scoping = dpf.Scoping()
>>> op.inputs.region_scoping.connect(my_region_scoping)
- >>> my_qualifiers1 = dpf.LabelSpace()
+ >>> my_qualifiers1 = dict()
>>> op.inputs.qualifiers1.connect(my_qualifiers1)
- >>> my_qualifiers2 = dpf.LabelSpace()
+ >>> my_qualifiers2 = dict()
>>> op.inputs.qualifiers2.connect(my_qualifiers2)
"""
@@ -495,7 +495,7 @@ def qualifiers1(self):
Parameters
----------
- my_qualifiers1 : LabelSpace
+ my_qualifiers1 : dict
Examples
--------
@@ -517,7 +517,7 @@ def qualifiers2(self):
Parameters
----------
- my_qualifiers2 : LabelSpace
+ my_qualifiers2 : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/utility/extract_sub_fc.py b/src/ansys/dpf/core/operators/utility/extract_sub_fc.py
index fba2f785f9f..e9967089237 100644
--- a/src/ansys/dpf/core/operators/utility/extract_sub_fc.py
+++ b/src/ansys/dpf/core/operators/utility/extract_sub_fc.py
@@ -18,7 +18,7 @@ class extract_sub_fc(Operator):
----------
fields_container : FieldsContainer
Fields_container
- label_space : LabelSpace
+ label_space : dict
Label_space
@@ -32,7 +32,7 @@ class extract_sub_fc(Operator):
>>> # Make input connections
>>> my_fields_container = dpf.FieldsContainer()
>>> op.inputs.fields_container.connect(my_fields_container)
- >>> my_label_space = dpf.LabelSpace()
+ >>> my_label_space = dict()
>>> op.inputs.label_space.connect(my_label_space)
>>> # Instantiate operator and connect inputs in one line
@@ -134,7 +134,7 @@ class InputsExtractSubFc(_Inputs):
>>> op = dpf.operators.utility.extract_sub_fc()
>>> my_fields_container = dpf.FieldsContainer()
>>> op.inputs.fields_container.connect(my_fields_container)
- >>> my_label_space = dpf.LabelSpace()
+ >>> my_label_space = dict()
>>> op.inputs.label_space.connect(my_label_space)
"""
@@ -173,7 +173,7 @@ def label_space(self):
Parameters
----------
- my_label_space : LabelSpace
+ my_label_space : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/utility/extract_sub_mc.py b/src/ansys/dpf/core/operators/utility/extract_sub_mc.py
index 206d9b1d05e..3febce818c4 100644
--- a/src/ansys/dpf/core/operators/utility/extract_sub_mc.py
+++ b/src/ansys/dpf/core/operators/utility/extract_sub_mc.py
@@ -18,7 +18,7 @@ class extract_sub_mc(Operator):
----------
meshes : MeshesContainer
Meshes
- label_space : LabelSpace
+ label_space : dict
Label_space
@@ -32,7 +32,7 @@ class extract_sub_mc(Operator):
>>> # Make input connections
>>> my_meshes = dpf.MeshesContainer()
>>> op.inputs.meshes.connect(my_meshes)
- >>> my_label_space = dpf.LabelSpace()
+ >>> my_label_space = dict()
>>> op.inputs.label_space.connect(my_label_space)
>>> # Instantiate operator and connect inputs in one line
@@ -132,7 +132,7 @@ class InputsExtractSubMc(_Inputs):
>>> op = dpf.operators.utility.extract_sub_mc()
>>> my_meshes = dpf.MeshesContainer()
>>> op.inputs.meshes.connect(my_meshes)
- >>> my_label_space = dpf.LabelSpace()
+ >>> my_label_space = dict()
>>> op.inputs.label_space.connect(my_label_space)
"""
@@ -171,7 +171,7 @@ def label_space(self):
Parameters
----------
- my_label_space : LabelSpace
+ my_label_space : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/utility/extract_sub_sc.py b/src/ansys/dpf/core/operators/utility/extract_sub_sc.py
index 5b3727e0777..f75d871203b 100644
--- a/src/ansys/dpf/core/operators/utility/extract_sub_sc.py
+++ b/src/ansys/dpf/core/operators/utility/extract_sub_sc.py
@@ -18,7 +18,7 @@ class extract_sub_sc(Operator):
----------
scopings_container : ScopingsContainer
Scopings_container
- label_space : LabelSpace
+ label_space : dict
Label_space
@@ -32,7 +32,7 @@ class extract_sub_sc(Operator):
>>> # Make input connections
>>> my_scopings_container = dpf.ScopingsContainer()
>>> op.inputs.scopings_container.connect(my_scopings_container)
- >>> my_label_space = dpf.LabelSpace()
+ >>> my_label_space = dict()
>>> op.inputs.label_space.connect(my_label_space)
>>> # Instantiate operator and connect inputs in one line
@@ -134,7 +134,7 @@ class InputsExtractSubSc(_Inputs):
>>> op = dpf.operators.utility.extract_sub_sc()
>>> my_scopings_container = dpf.ScopingsContainer()
>>> op.inputs.scopings_container.connect(my_scopings_container)
- >>> my_label_space = dpf.LabelSpace()
+ >>> my_label_space = dict()
>>> op.inputs.label_space.connect(my_label_space)
"""
@@ -173,7 +173,7 @@ def label_space(self):
Parameters
----------
- my_label_space : LabelSpace
+ my_label_space : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/utility/field_to_fc.py b/src/ansys/dpf/core/operators/utility/field_to_fc.py
index 67a95cae331..044421ffd2c 100644
--- a/src/ansys/dpf/core/operators/utility/field_to_fc.py
+++ b/src/ansys/dpf/core/operators/utility/field_to_fc.py
@@ -18,7 +18,7 @@ class field_to_fc(Operator):
field : Field or FieldsContainer
If a fields container is set in input, it is
passed on as an output.
- label : LabelSpace
+ label : dict
Sets a label space.
@@ -32,7 +32,7 @@ class field_to_fc(Operator):
>>> # Make input connections
>>> my_field = dpf.Field()
>>> op.inputs.field.connect(my_field)
- >>> my_label = dpf.LabelSpace()
+ >>> my_label = dict()
>>> op.inputs.label.connect(my_label)
>>> # Instantiate operator and connect inputs in one line
@@ -134,7 +134,7 @@ class InputsFieldToFc(_Inputs):
>>> op = dpf.operators.utility.field_to_fc()
>>> my_field = dpf.Field()
>>> op.inputs.field.connect(my_field)
- >>> my_label = dpf.LabelSpace()
+ >>> my_label = dict()
>>> op.inputs.label.connect(my_label)
"""
@@ -174,7 +174,7 @@ def label(self):
Parameters
----------
- my_label : LabelSpace
+ my_label : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/utility/incremental_concatenate_as_fc.py b/src/ansys/dpf/core/operators/utility/incremental_concatenate_as_fc.py
index eca10fd4418..e3f1f6839d4 100644
--- a/src/ansys/dpf/core/operators/utility/incremental_concatenate_as_fc.py
+++ b/src/ansys/dpf/core/operators/utility/incremental_concatenate_as_fc.py
@@ -16,7 +16,7 @@ class incremental_concatenate_as_fc(Operator):
Parameters
----------
field : Field
- label : LabelSpace, optional
+ label : dict, optional
Label space value that must be applied to the
added field.
@@ -31,7 +31,7 @@ class incremental_concatenate_as_fc(Operator):
>>> # Make input connections
>>> my_field = dpf.Field()
>>> op.inputs.field.connect(my_field)
- >>> my_label = dpf.LabelSpace()
+ >>> my_label = dict()
>>> op.inputs.label.connect(my_label)
>>> # Instantiate operator and connect inputs in one line
@@ -135,7 +135,7 @@ class InputsIncrementalConcatenateAsFc(_Inputs):
>>> op = dpf.operators.utility.incremental_concatenate_as_fc()
>>> my_field = dpf.Field()
>>> op.inputs.field.connect(my_field)
- >>> my_label = dpf.LabelSpace()
+ >>> my_label = dict()
>>> op.inputs.label.connect(my_label)
"""
@@ -177,7 +177,7 @@ def label(self):
Parameters
----------
- my_label : LabelSpace
+ my_label : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/utility/make_label_space.py b/src/ansys/dpf/core/operators/utility/make_label_space.py
index dd15fed7d63..1f2c108464d 100644
--- a/src/ansys/dpf/core/operators/utility/make_label_space.py
+++ b/src/ansys/dpf/core/operators/utility/make_label_space.py
@@ -15,7 +15,7 @@ class make_label_space(Operator):
Parameters
----------
- base_label : LabelSpace or FieldsContainer or ScopingsContainer, optional
+ base_label : dict or FieldsContainer or ScopingsContainer, optional
Used as a base label (extracted from
fields/scoping container, or directly
from label space) that is
@@ -33,7 +33,7 @@ class make_label_space(Operator):
>>> op = dpf.operators.utility.make_label_space()
>>> # Make input connections
- >>> my_base_label = dpf.LabelSpace()
+ >>> my_base_label = dict()
>>> op.inputs.base_label.connect(my_base_label)
>>> my_label_name = str()
>>> op.inputs.label_name.connect(my_label_name)
@@ -169,7 +169,7 @@ class InputsMakeLabelSpace(_Inputs):
--------
>>> from ansys.dpf import core as dpf
>>> op = dpf.operators.utility.make_label_space()
- >>> my_base_label = dpf.LabelSpace()
+ >>> my_base_label = dict()
>>> op.inputs.base_label.connect(my_base_label)
>>> my_label_name = str()
>>> op.inputs.label_name.connect(my_label_name)
@@ -201,7 +201,7 @@ def base_label(self):
Parameters
----------
- my_base_label : LabelSpace or FieldsContainer or ScopingsContainer
+ my_base_label : dict or FieldsContainer or ScopingsContainer
Examples
--------
@@ -291,7 +291,7 @@ def label(self):
Returns
----------
- my_label : LabelSpace
+ my_label : dict
Examples
--------
diff --git a/src/ansys/dpf/core/operators/utility/set_attribute.py b/src/ansys/dpf/core/operators/utility/set_attribute.py
index 550594435a1..1fab28c31ca 100644
--- a/src/ansys/dpf/core/operators/utility/set_attribute.py
+++ b/src/ansys/dpf/core/operators/utility/set_attribute.py
@@ -18,7 +18,7 @@ class set_attribute(Operator):
fields_container : FieldsContainer
property_name : str
Supported property names are: "labels".
- property_identifier : LabelSpace, optional
+ property_identifier : dict, optional
Value of the property to be set : vector of
string or labelspace for "labels".
@@ -35,7 +35,7 @@ class set_attribute(Operator):
>>> op.inputs.fields_container.connect(my_fields_container)
>>> my_property_name = str()
>>> op.inputs.property_name.connect(my_property_name)
- >>> my_property_identifier = dpf.LabelSpace()
+ >>> my_property_identifier = dict()
>>> op.inputs.property_identifier.connect(my_property_identifier)
>>> # Instantiate operator and connect inputs in one line
@@ -157,7 +157,7 @@ class InputsSetAttribute(_Inputs):
>>> op.inputs.fields_container.connect(my_fields_container)
>>> my_property_name = str()
>>> op.inputs.property_name.connect(my_property_name)
- >>> my_property_identifier = dpf.LabelSpace()
+ >>> my_property_identifier = dict()
>>> op.inputs.property_identifier.connect(my_property_identifier)
"""
@@ -217,7 +217,7 @@ def property_identifier(self):
Parameters
----------
- my_property_identifier : LabelSpace
+ my_property_identifier : dict
Examples
--------