From 26803a486f31cac72415bf29b9058862098f3b3b Mon Sep 17 00:00:00 2001
From: PProfizi <100710998+PProfizi@users.noreply.github.com>
Date: Wed, 22 Jan 2025 16:02:05 +0000
Subject: [PATCH] update generated code
---
doc/source/_static/dpf_operators.html | 14 +-
src/ansys/dpf/core/operators/math/__init__.py | 1 +
.../dpf/core/operators/math/expansion_psd.py | 399 +++++++++++
.../dpf/core/operators/metadata/__init__.py | 3 +
.../coordinate_system_data_provider.py | 323 +++++++++
.../metadata/element_types_provider.py | 312 ++++++++
.../metadata/real_constants_provider.py | 315 +++++++++
.../dpf/core/operators/result/__init__.py | 15 +
.../result/cyclic_expanded_heat_flux.py | 8 +-
.../result/cyclic_expanded_temperature.py | 4 +-
.../core/operators/result/electric_field_X.py | 653 +++++++++++++++++
.../core/operators/result/electric_field_Y.py | 653 +++++++++++++++++
.../core/operators/result/electric_field_Z.py | 653 +++++++++++++++++
.../result/electric_flux_density_X.py | 667 ++++++++++++++++++
.../result/electric_flux_density_Y.py | 667 ++++++++++++++++++
.../result/electric_flux_density_Z.py | 667 ++++++++++++++++++
.../core/operators/result/magnetic_field_X.py | 653 +++++++++++++++++
.../core/operators/result/magnetic_field_Y.py | 653 +++++++++++++++++
.../core/operators/result/magnetic_field_Z.py | 653 +++++++++++++++++
.../result/magnetic_flux_density_X.py | 667 ++++++++++++++++++
.../result/magnetic_flux_density_Y.py | 667 ++++++++++++++++++
.../result/magnetic_flux_density_Z.py | 667 ++++++++++++++++++
.../operators/result/temperature_grad_X.py | 655 +++++++++++++++++
.../operators/result/temperature_grad_Y.py | 655 +++++++++++++++++
.../operators/result/temperature_grad_Z.py | 655 +++++++++++++++++
src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll | Bin 11718144 -> 11721216 bytes
src/ansys/dpf/gatebin/DPFClientAPI.dll | Bin 882688 -> 882688 bytes
.../dpf/gatebin/libAns.Dpf.GrpcClient.so | Bin 30220888 -> 30221640 bytes
src/ansys/dpf/gatebin/libDPFClientAPI.so | Bin 2209584 -> 2209584 bytes
src/ansys/grpc/dpf/dpf_any_pb2.py | 16 +-
30 files changed, 11274 insertions(+), 21 deletions(-)
create mode 100644 src/ansys/dpf/core/operators/math/expansion_psd.py
create mode 100644 src/ansys/dpf/core/operators/metadata/coordinate_system_data_provider.py
create mode 100644 src/ansys/dpf/core/operators/metadata/element_types_provider.py
create mode 100644 src/ansys/dpf/core/operators/metadata/real_constants_provider.py
create mode 100644 src/ansys/dpf/core/operators/result/electric_field_X.py
create mode 100644 src/ansys/dpf/core/operators/result/electric_field_Y.py
create mode 100644 src/ansys/dpf/core/operators/result/electric_field_Z.py
create mode 100644 src/ansys/dpf/core/operators/result/electric_flux_density_X.py
create mode 100644 src/ansys/dpf/core/operators/result/electric_flux_density_Y.py
create mode 100644 src/ansys/dpf/core/operators/result/electric_flux_density_Z.py
create mode 100644 src/ansys/dpf/core/operators/result/magnetic_field_X.py
create mode 100644 src/ansys/dpf/core/operators/result/magnetic_field_Y.py
create mode 100644 src/ansys/dpf/core/operators/result/magnetic_field_Z.py
create mode 100644 src/ansys/dpf/core/operators/result/magnetic_flux_density_X.py
create mode 100644 src/ansys/dpf/core/operators/result/magnetic_flux_density_Y.py
create mode 100644 src/ansys/dpf/core/operators/result/magnetic_flux_density_Z.py
create mode 100644 src/ansys/dpf/core/operators/result/temperature_grad_X.py
create mode 100644 src/ansys/dpf/core/operators/result/temperature_grad_Y.py
create mode 100644 src/ansys/dpf/core/operators/result/temperature_grad_Z.py
diff --git a/doc/source/_static/dpf_operators.html b/doc/source/_static/dpf_operators.html
index d9cf9e841a7..000f81ba888 100644
--- a/doc/source/_static/dpf_operators.html
+++ b/doc/source/_static/dpf_operators.html
@@ -2070,7 +2070,7 @@
Configurating operators
0 0 0
0 0 0
0 0 0
-">Example of workflows and their scripts
math: imaginary part
Inputs
Outputs
Configurations
Scripting
math: amplitude (fields container)
Inputs
Outputs
Configurations
Scripting
metadata: mesh support provider
Inputs
Outputs
Configurations
Scripting
result: beam axial stress (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: unit convert (fields container)
Inputs
Outputs
Configurations
Scripting
result: element orientations X
Inputs
Outputs
Configurations
Scripting
math: norm (fields container)
Inputs
Outputs
Configurations
Scripting
mapping: prepare mapping workflow
Inputs
Outputs
Configurations
Scripting
math: sqrt (fields container)
Inputs
Outputs
Configurations
Scripting
math: conjugate
Inputs
Outputs
Configurations
Scripting
utility: html doc
Inputs
Outputs
Configurations
Scripting
math: real part
Inputs
Outputs
Configurations
Scripting
result: current density
Inputs
Outputs
Configurations
Scripting
math: multiply (complex fields)
Inputs
Outputs
Configurations
Scripting
utility: merge result infos
Inputs
Outputs
Configurations
Scripting
result: cyclic kinetic energy
Inputs
Outputs
Configurations
Scripting
result: global total mass (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: unit convert
Inputs
Outputs
Configurations
Scripting
math: norm (field)
Inputs
Outputs
Configurations
Scripting
utility: make label space
Inputs
Outputs
Configurations
Scripting
math: sqrt (field)
Inputs
Outputs
Configurations
Scripting
math: accumulate min over label
Inputs
Outputs
Configurations
Scripting
result: y plus (y+)
Inputs
Outputs
Configurations
Scripting
math: +
Inputs
Outputs
Configurations
Scripting
server: grpc shutdown server
Inputs
Outputs
Configurations
Scripting
result: magnetic scalar potential
Inputs
Outputs
Configurations
Scripting
min_max: min max over time
Inputs
Outputs
Configurations
Scripting
math: time freq interpolation
Inputs
Outputs
Configurations
Scripting
math: + (fields container)
Inputs
Outputs
Configurations
Scripting
math: sin (fields container)
Inputs
Outputs
Configurations
Scripting
math: + constant (field)
Inputs
Outputs
Configurations
Scripting
math: / (component-wise field)
Inputs
Outputs
Configurations
Scripting
math: + constant (fields container)
Inputs
Outputs
Configurations
Scripting
math: cross product (fields container)
Inputs
Outputs
Configurations
Scripting
result: cyclic strain energy
Inputs
Outputs
Configurations
Scripting
invariant: scalar invariants (fields container)
Inputs
Outputs
Configurations
Scripting
mapping: find reduced coordinates
Inputs
Outputs
Configurations
Scripting
scoping: rescope property field
Inputs
Outputs
Configurations
Scripting
result: plastic strain principal 1
Inputs
Outputs
Configurations
Scripting
math: -
Inputs
Outputs
Configurations
Scripting
math: total sum
Inputs
Outputs
Configurations
Scripting
math: - (fields container)
Inputs
Outputs
Configurations
Scripting
scoping: intersect scopings
Inputs
Outputs
Configurations
Scripting
math: ^ (field)
Inputs
Outputs
Configurations
Scripting
scoping: elements in mesh
Inputs
Outputs
Configurations
Scripting
math: scale (field)
Inputs
Outputs
Configurations
Scripting
result: enthalpy
Inputs
Outputs
Configurations
Scripting
math: ^ (fields container)
Inputs
Outputs
Configurations
Scripting
result: global eroded internal energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: scale fields container
Inputs
Outputs
Configurations
Scripting
math: sweeping phase
Inputs
Outputs
Configurations
Scripting
math: centroid
Inputs
Outputs
Configurations
Scripting
math: sweeping phase (fields container)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (field)
Inputs
Outputs
Configurations
Scripting
math: centroid (fields container)
Inputs
Outputs
Configurations
Scripting
math: ^2 (field)
Inputs
Outputs
Configurations
Scripting
utility: remove unnecessary labels
Inputs
Outputs
Configurations
Scripting
result: velocity Z
Inputs
Outputs
Configurations
Scripting
result: reaction force Z
Inputs
Outputs
Configurations
Scripting
math: sin (field)
Inputs
Outputs
Configurations
Scripting
math: cos (field)
Inputs
Outputs
Configurations
Scripting
math: cos (fields container)
Inputs
Outputs
Configurations
Scripting
logic: ascending sort
Inputs
Outputs
Configurations
Scripting
result: initial coordinates (LSDyna)
Inputs
Outputs
Configurations
Scripting
utility: convert to fields container
Inputs
Outputs
Configurations
Scripting
math: linear combination
Inputs
Outputs
Configurations
Scripting
math: ^2 (fields container)
Inputs
Outputs
Configurations
Scripting
result: mean static pressure
Inputs
Outputs
Configurations
Scripting
math: exp (field)
Inputs
Outputs
Configurations
Scripting
math: exp (fields container)
Inputs
Outputs
Configurations
Scripting
math: * (component-wise field)
Inputs
Outputs
Configurations
Scripting
result: stress max_shear
Inputs
Outputs
Configurations
Scripting
result: euler nodes
Inputs
Outputs
Configurations
Scripting
math: * (component-wise field) (fields container)
Inputs
Outputs
Configurations
Scripting
result: beam TR shear stress (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: num surface status changes
Inputs
Outputs
Configurations
Scripting
math: ln (field)
Inputs
Outputs
Configurations
Scripting
mesh: mesh to pyvista
Inputs
Outputs
Configurations
Scripting
math: ln (fields container)
Inputs
Outputs
Configurations
Scripting
invariant: scalar invariants (field)
Inputs
Outputs
Configurations
Scripting
math: cross product
Inputs
Outputs
Configurations
Scripting
filter: high pass (timefreq)
Inputs
Outputs
Configurations
Scripting
math: / (component-wise fields container)
Inputs
Outputs
Configurations
Scripting
result: global sliding interface energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: kronecker product
Inputs
Outputs
Configurations
Scripting
math: modulus (fields container)
Inputs
Outputs
Configurations
Scripting
result: joint relative angular velocity
Inputs
Outputs
Configurations
Scripting
math: dot (complex fields)
Inputs
Outputs
Configurations
Scripting
result: gasket stress XZ
Inputs
Outputs
Configurations
Scripting
math: / (complex fields)
Inputs
Outputs
Configurations
Scripting
utility: unitary field
Inputs
Outputs
Configurations
Scripting
utility: server path
Inputs
Outputs
Configurations
Scripting
result: beam axial force (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: derivate (complex fields)
Inputs
Outputs
Configurations
Scripting
math: polar to complex fields
Inputs
Outputs
Configurations
Scripting
utility: merge data tree
Inputs
Outputs
Configurations
Scripting
math: dot (fields container)
Inputs
Outputs
Configurations
Scripting
result: nodal moment
Inputs
Outputs
Configurations
Scripting
math: phase (field)
Inputs
Outputs
Configurations
Scripting
math: phase (fields container)
Inputs
Outputs
Configurations
Scripting
math: modulus (field)
Inputs
Outputs
Configurations
Scripting
result: elemental mass
Inputs
Outputs
Configurations
Scripting
result: heat flux
Inputs
Outputs
Configurations
Scripting
math: total sum (fields container)
Inputs
Outputs
Configurations
Scripting
result: co-energy
Inputs
Outputs
Configurations
Scripting
math: dot
Inputs
Outputs
Configurations
Scripting
math: outer product
Inputs
Outputs
Configurations
Scripting
math: overall dot
Inputs
Outputs
Configurations
Scripting
math: relative error
Inputs
Outputs
Configurations
Scripting
result: velocity Y
Inputs
Outputs
Configurations
Scripting
result: reaction force Y
Inputs
Outputs
Configurations
Scripting
result: global velocity (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: superficial velocity
Inputs
Outputs
Configurations
Scripting
math: absolute value by component (field)
Inputs
Outputs
Configurations
Scripting
result: incremental energy
Inputs
Outputs
Configurations
Scripting
result: thermal strain
Inputs
Outputs
Configurations
Scripting
result: stiffness matrix energy
Inputs
Outputs
Configurations
Scripting
math: absolute value by component (fields container)
Inputs
Outputs
Configurations
Scripting
result: total temperature
Inputs
Outputs
Configurations
Scripting
result: cyclic equivalent mass
Inputs
Outputs
Configurations
Scripting
result: acceleration Y
Inputs
Outputs
Configurations
Scripting
utility: delegate to operator
Inputs
Outputs
Configurations
Scripting
logic: component selector (fields container)
Inputs
Outputs
Configurations
Scripting
logic: component selector (field)
Inputs
Outputs
Configurations
Scripting
scoping: on property
Inputs
Outputs
Configurations
Scripting
result: stress intensity
Inputs
Outputs
Configurations
Scripting
min_max: over field
Inputs
Outputs
Configurations
Scripting
result: transient rayleigh integration
Inputs
Outputs
Configurations
Scripting
logic: same property fields?
Inputs
Outputs
Configurations
Scripting
logic: elementary data selector (fields container)
Inputs
Outputs
Configurations
Scripting
utility: convert to scoping
Inputs
Outputs
Configurations
Scripting
logic: elementary data selector (field)
Inputs
Outputs
Configurations
Scripting
utility: change location
Inputs
Outputs
Configurations
Scripting
mesh: node coordinates
Inputs
Outputs
Configurations
Scripting
mesh: stl export
Inputs
Outputs
Configurations
Scripting
utility: bind support
Inputs
Outputs
Configurations
Scripting
utility: convert to meshes container
Inputs
Outputs
Configurations
Scripting
result: beam torsional moment (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: equivalent stress parameter
Inputs
Outputs
Configurations
Scripting
utility: convert to field
Inputs
Outputs
Configurations
Scripting
result: beam axial total strain (LSDyna)
Inputs
Outputs
Configurations
Scripting
utility: set property
Inputs
Outputs
Configurations
Scripting
utility: forward field
Inputs
Outputs
Configurations
Scripting
utility: forward fields container
Inputs
Outputs
Configurations
Scripting
result: electric flux density
Inputs
Outputs
Configurations
Scripting
geo: integrate over elements
Inputs
Outputs
Configurations
Scripting
result: plastic strain principal 2
Inputs
Outputs
Configurations
Scripting
utility: forward meshes container
Inputs
Outputs
Configurations
Scripting
result: compute total strain X
Example of workflows and their scripts
math: imaginary part
Inputs
Outputs
Configurations
Scripting
math: amplitude (fields container)
Inputs
Outputs
Configurations
Scripting
metadata: mesh support provider
Inputs
Outputs
Configurations
Scripting
result: beam axial stress (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: unit convert (fields container)
Inputs
Outputs
Configurations
Scripting
result: element orientations X
Inputs
Outputs
Configurations
Scripting
math: norm (fields container)
Inputs
Outputs
Configurations
Scripting
mapping: prepare mapping workflow
Inputs
Outputs
Configurations
Scripting
math: sqrt (fields container)
Inputs
Outputs
Configurations
Scripting
math: conjugate
Inputs
Outputs
Configurations
Scripting
utility: html doc
Inputs
Outputs
Configurations
Scripting
math: real part
Inputs
Outputs
Configurations
Scripting
result: current density
Inputs
Outputs
Configurations
Scripting
math: multiply (complex fields)
Inputs
Outputs
Configurations
Scripting
utility: merge result infos
Inputs
Outputs
Configurations
Scripting
result: cyclic kinetic energy
Inputs
Outputs
Configurations
Scripting
result: global total mass (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: unit convert
Inputs
Outputs
Configurations
Scripting
math: norm (field)
Inputs
Outputs
Configurations
Scripting
utility: make label space
Inputs
Outputs
Configurations
Scripting
math: sqrt (field)
Inputs
Outputs
Configurations
Scripting
result: y plus (y+)
Inputs
Outputs
Configurations
Scripting
math: accumulate min over label
Inputs
Outputs
Configurations
Scripting
math: +
Inputs
Outputs
Configurations
Scripting
server: grpc shutdown server
Inputs
Outputs
Configurations
Scripting
result: magnetic scalar potential
Inputs
Outputs
Configurations
Scripting
min_max: min max over time
Inputs
Outputs
Configurations
Scripting
math: time freq interpolation
Inputs
Outputs
Configurations
Scripting
math: + (fields container)
Inputs
Outputs
Configurations
Scripting
math: sin (fields container)
Inputs
Outputs
Configurations
Scripting
math: + constant (field)
Inputs
Outputs
Configurations
Scripting
math: / (component-wise field)
Inputs
Outputs
Configurations
Scripting
math: + constant (fields container)
Inputs
Outputs
Configurations
Scripting
math: cross product (fields container)
Inputs
Outputs
Configurations
Scripting
result: cyclic strain energy
Inputs
Outputs
Configurations
Scripting
invariant: scalar invariants (fields container)
Inputs
Outputs
Configurations
Scripting
mapping: find reduced coordinates
Inputs
Outputs
Configurations
Scripting
scoping: rescope property field
Inputs
Outputs
Configurations
Scripting
result: plastic strain principal 1
Inputs
Outputs
Configurations
Scripting
math: -
Inputs
Outputs
Configurations
Scripting
math: total sum
Inputs
Outputs
Configurations
Scripting
math: - (fields container)
Inputs
Outputs
Configurations
Scripting
scoping: intersect scopings
Inputs
Outputs
Configurations
Scripting
math: ^ (field)
Inputs
Outputs
Configurations
Scripting
scoping: elements in mesh
Inputs
Outputs
Configurations
Scripting
math: scale (field)
Inputs
Outputs
Configurations
Scripting
result: enthalpy
Inputs
Outputs
Configurations
Scripting
math: ^ (fields container)
Inputs
Outputs
Configurations
Scripting
result: global eroded internal energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: scale fields container
Inputs
Outputs
Configurations
Scripting
math: sweeping phase
Inputs
Outputs
Configurations
Scripting
math: centroid
Inputs
Outputs
Configurations
Scripting
math: sweeping phase (fields container)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (field)
Inputs
Outputs
Configurations
Scripting
math: centroid (fields container)
Inputs
Outputs
Configurations
Scripting
math: ^2 (field)
Inputs
Outputs
Configurations
Scripting
utility: remove unnecessary labels
Inputs
Outputs
Configurations
Scripting
result: velocity Z
Inputs
Outputs
Configurations
Scripting
result: reaction force Z
Inputs
Outputs
Configurations
Scripting
math: sin (field)
Inputs
Outputs
Configurations
Scripting
math: cos (field)
Inputs
Outputs
Configurations
Scripting
math: cos (fields container)
Inputs
Outputs
Configurations
Scripting
logic: ascending sort
Inputs
Outputs
Configurations
Scripting
result: initial coordinates (LSDyna)
Inputs
Outputs
Configurations
Scripting
utility: convert to fields container
Inputs
Outputs
Configurations
Scripting
math: linear combination
Inputs
Outputs
Configurations
Scripting
math: ^2 (fields container)
Inputs
Outputs
Configurations
Scripting
result: mean static pressure
Inputs
Outputs
Configurations
Scripting
math: exp (field)
Inputs
Outputs
Configurations
Scripting
math: exp (fields container)
Inputs
Outputs
Configurations
Scripting
math: * (component-wise field)
Inputs
Outputs
Configurations
Scripting
result: stress max_shear
Inputs
Outputs
Configurations
Scripting
result: euler nodes
Inputs
Outputs
Configurations
Scripting
math: * (component-wise field) (fields container)
Inputs
Outputs
Configurations
Scripting
result: beam TR shear stress (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: num surface status changes
Inputs
Outputs
Configurations
Scripting
math: ln (field)
Inputs
Outputs
Configurations
Scripting
mesh: mesh to pyvista
Inputs
Outputs
Configurations
Scripting
math: ln (fields container)
Inputs
Outputs
Configurations
Scripting
invariant: scalar invariants (field)
Inputs
Outputs
Configurations
Scripting
math: cross product
Inputs
Outputs
Configurations
Scripting
filter: high pass (timefreq)
Inputs
Outputs
Configurations
Scripting
math: / (component-wise fields container)
Inputs
Outputs
Configurations
Scripting
result: global sliding interface energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: kronecker product
Inputs
Outputs
Configurations
Scripting
math: modulus (fields container)
Inputs
Outputs
Configurations
Scripting
result: joint relative angular velocity
Inputs
Outputs
Configurations
Scripting
math: dot (complex fields)
Inputs
Outputs
Configurations
Scripting
result: gasket stress XZ
Inputs
Outputs
Configurations
Scripting
math: / (complex fields)
Inputs
Outputs
Configurations
Scripting
utility: unitary field
Inputs
Outputs
Configurations
Scripting
utility: server path
Inputs
Outputs
Configurations
Scripting
result: beam axial force (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: derivate (complex fields)
Inputs
Outputs
Configurations
Scripting
math: polar to complex fields
Inputs
Outputs
Configurations
Scripting
utility: merge data tree
Inputs
Outputs
Configurations
Scripting
math: dot (fields container)
Inputs
Outputs
Configurations
Scripting
result: nodal moment
Inputs
Outputs
Configurations
Scripting
math: phase (field)
Inputs
Outputs
Configurations
Scripting
math: phase (fields container)
Inputs
Outputs
Configurations
Scripting
math: modulus (field)
Inputs
Outputs
Configurations
Scripting
result: elemental mass
Inputs
Outputs
Configurations
Scripting
result: heat flux
Inputs
Outputs
Configurations
Scripting
math: total sum (fields container)
Inputs
Outputs
Configurations
Scripting
result: co-energy
Inputs
Outputs
Configurations
Scripting
math: dot
Inputs
Outputs
Configurations
Scripting
math: outer product
Inputs
Outputs
Configurations
Scripting
math: overall dot
Inputs
Outputs
Configurations
Scripting
math: relative error
Inputs
Outputs
Configurations
Scripting
result: velocity Y
Inputs
Outputs
Configurations
Scripting
result: reaction force Y
Inputs
Outputs
Configurations
Scripting
result: global velocity (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: superficial velocity
Inputs
Outputs
Configurations
Scripting
math: absolute value by component (field)
Inputs
Outputs
Configurations
Scripting
result: incremental energy
Inputs
Outputs
Configurations
Scripting
result: thermal strain
Inputs
Outputs
Configurations
Scripting
result: stiffness matrix energy
Inputs
Outputs
Configurations
Scripting
math: absolute value by component (fields container)
Inputs
Outputs
Configurations
Scripting
metadata: element types provider
Inputs
Outputs
Configurations
Scripting
result: total temperature
Inputs
Outputs
Configurations
Scripting
result: cyclic equivalent mass
Inputs
Outputs
Configurations
Scripting
result: acceleration Y
Inputs
Outputs
Configurations
Scripting
utility: delegate to operator
Inputs
Outputs
Configurations
Scripting
logic: component selector (fields container)
Inputs
Outputs
Configurations
Scripting
logic: component selector (field)
Inputs
Outputs
Configurations
Scripting
scoping: on property
Inputs
Outputs
Configurations
Scripting
result: stress intensity
Inputs
Outputs
Configurations
Scripting
logic: same property fields?
Inputs
Outputs
Configurations
Scripting
logic: elementary data selector (fields container)
Inputs
Outputs
Configurations
Scripting
utility: convert to scoping
Inputs
Outputs
Configurations
Scripting
logic: elementary data selector (field)
Inputs
Outputs
Configurations
Scripting
utility: change location
Inputs
Outputs
Configurations
Scripting
mesh: node coordinates
Inputs
Outputs
Configurations
Scripting
mesh: stl export
Inputs
Outputs
Configurations
Scripting
utility: bind support
Inputs
Outputs
Configurations
Scripting
utility: convert to meshes container
Inputs
Outputs
Configurations
Scripting
result: beam torsional moment (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: equivalent stress parameter
Inputs
Outputs
Configurations
Scripting
utility: convert to field
Inputs
Outputs
Configurations
Scripting
result: beam axial total strain (LSDyna)
Inputs
Outputs
Configurations
Scripting
utility: set property
Inputs
Outputs
Configurations
Scripting
result: electric flux density Y
Inputs
Outputs
Configurations
Scripting
utility: forward field
Inputs
Outputs
Configurations
Scripting
utility: forward fields container
Inputs
Outputs
Configurations
Scripting
result: electric flux density
Inputs
Outputs
Configurations
Scripting
geo: integrate over elements
Inputs
Outputs
Configurations
Scripting
result: plastic strain principal 2
Inputs
Outputs
Configurations
Scripting
utility: forward meshes container
Inputs
Outputs
Configurations
Scripting
result: compute total strain X
Configurating operators
Get the XX normal component (00 component).">Inputs
Outputs
Configurations
Scripting
utility: forward
Inputs
Outputs
Configurations
Scripting
utility: incremental meshes container
Inputs
Outputs
Configurations
Scripting
utility: txt file to dpf
Inputs
Outputs
Configurations
Scripting
utility: bind support (fields container)
Inputs
Outputs
Configurations
Scripting
utility: fields container get attribute
Inputs
Outputs
Configurations
Scripting
result: thermal strain XZ
Inputs
Outputs
Configurations
Scripting
utility: assemble scalars to vector
Inputs
Outputs
Configurations
Scripting
result: global eroded hourglass energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
utility: assemble scalars to vector fc
Inputs
Outputs
Configurations
Scripting
utility: assemble scalars to matrix
Inputs
Outputs
Configurations
Scripting
math: make one on component
Inputs
Outputs
Configurations
Scripting
mesh: from scopings
Inputs
Outputs
Configurations
Scripting
utility: assemble scalars to matrix fc
Inputs
Outputs
Configurations
Scripting
result: pres to field
Inputs
Outputs
Configurations
Scripting
result: part internal energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: part momentum (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: compute invariant terms rbd
Inputs
Outputs
Configurations
Scripting
utility: default value
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal elemental (fields container)
Inputs
Outputs
Configurations
Scripting
result: rms velocity
Inputs
Outputs
Configurations
Scripting
result: acceleration X
Inputs
Outputs
Configurations
Scripting
result: poynting vector
Inputs
Outputs
Configurations
Scripting
result: total strain (LSDyna)
Inputs
Outputs
Configurations
Scripting
averaging: elemental difference (fields container)
Inputs
Outputs
Configurations
Scripting
utility: compute time scoping
Inputs
Outputs
Configurations
Scripting
result: static pressure
Inputs
Outputs
Configurations
Scripting
result: elastic strain
Inputs
Outputs
Configurations
Scripting
math: window bartlett (fields container)
Inputs
Outputs
Configurations
Scripting
result: turbulent viscosity
Inputs
Outputs
Configurations
Scripting
utility: python generator
Inputs
Outputs
Configurations
Scripting
utility: make overall
Inputs
Outputs
Configurations
Scripting
geo: elements volume
Inputs
Outputs
Configurations
Scripting
result: pressure
Inputs
Outputs
Configurations
Scripting
result: stress
Inputs
Outputs
Configurations
Scripting
result: stress X
Inputs
Outputs
Configurations
Scripting
result: gasket thermal closure XZ
Inputs
Outputs
Configurations
Scripting
result: stress Y
Inputs
Outputs
Configurations
Scripting
result: stress Z
Inputs
Outputs
Configurations
Scripting
result: gasket thermal closure XY
Inputs
Outputs
Configurations
Scripting
result: stress XY
Inputs
Outputs
Configurations
Scripting
compression: kMeans clustering
Inputs
Outputs
Configurations
Scripting
result: stress YZ
Inputs
Outputs
Configurations
Scripting
result: modal basis
Inputs
Outputs
Configurations
Scripting
result: stress XZ
Inputs
Outputs
Configurations
Scripting
utility: merge string fields
Inputs
Outputs
Configurations
Scripting
result: stress principal 1
Inputs
Outputs
Configurations
Scripting
result: stress principal 2
Inputs
Outputs
Configurations
Scripting
invariant: convertnum bcs to nod
Inputs
Outputs
Configurations
Scripting
result: stress principal 3
Inputs
Outputs
Configurations
Scripting
result: stress von mises
Inputs
Outputs
Configurations
Scripting
result: gasket stress
Inputs
Outputs
Configurations
Scripting
result: gasket stress X
Inputs
Outputs
Configurations
Scripting
result: gasket stress XY
Inputs
Outputs
Configurations
Scripting
geo: elements facets surfaces over time
Inputs
Outputs
Configurations
Scripting
metadata: property field provider by property name
Inputs
Outputs
Configurations
Scripting
mesh: mesh provider
Inputs
Outputs
Configurations
Scripting
result: gasket inelastic closure
Inputs
Outputs
Configurations
Scripting
result: gasket inelastic closure X
Inputs
Outputs
Configurations
Scripting
result: write cms rbd file
Inputs
Outputs
Configurations
Scripting
serialization: export symbolic workflow
Inputs
Outputs
Configurations
Scripting
result: gasket inelastic closure XY
Inputs
Outputs
Configurations
Scripting
result: plastic strain eqv
Inputs
Outputs
Configurations
Scripting
mesh: beam properties
Inputs
Outputs
Configurations
Scripting
result: gasket inelastic closure XZ
Inputs
Outputs
Configurations
Scripting
result: gasket thermal closure
Inputs
Outputs
Configurations
Scripting
result: gasket thermal closure X
Inputs
Outputs
Configurations
Scripting
result: elastic strain X
Inputs
Outputs
Configurations
Scripting
result: elastic strain Y
Inputs
Outputs
Configurations
Scripting
result: elastic strain Z
Inputs
Outputs
Configurations
Scripting
math: min/max over time
Inputs
Outputs
Configurations
Scripting
utility: merge fields containers
Inputs
Outputs
Configurations
Scripting
result: global energy ratio without eroded energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
utility: merge weighted fields containers
Inputs
Outputs
Configurations
Scripting
result: elastic strain XY
Inputs
Outputs
Configurations
Scripting
result: elastic strain YZ
Inputs
Outputs
Configurations
Scripting
invariant: eigen values (fields container)
Inputs
Outputs
Configurations
Scripting
result: elastic strain XZ
Inputs
Outputs
Configurations
Scripting
metadata: mesh property provider
Inputs
Outputs
Configurations
Scripting
result: elastic strain principal 1
Inputs
Outputs
Configurations
Scripting
result: elastic strain principal 2
Inputs
Outputs
Configurations
Scripting
utility: merge scopings
Inputs
Outputs
Configurations
Scripting
result: elastic strain principal 3
Inputs
Outputs
Configurations
Scripting
result: cyclic analytic disp max
Inputs
Outputs
Configurations
Scripting
result: elastic strain eqv
Inputs
Outputs
Configurations
Scripting
result: elastic strain intensity
Inputs
Outputs
Configurations
Scripting
result: elastic strain max_shear
Inputs
Outputs
Configurations
Scripting
result: turbulent dissipation rate (omega)
Inputs
Outputs
Configurations
Scripting
averaging: to elemental (fields container)
Inputs
Outputs
Configurations
Scripting
result: plastic strain
Inputs
Outputs
Configurations
Scripting
scoping: transpose
Inputs
Outputs
Configurations
Scripting
result: mass fraction
Inputs
Outputs
Configurations
Scripting
result: plastic strain X
Inputs
Outputs
Configurations
Scripting
result: coordinates (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: plastic strain Y
Inputs
Outputs
Configurations
Scripting
filter: band pass (fields container)
Inputs
Outputs
Configurations
Scripting
geo: to polar coordinates
Inputs
Outputs
Configurations
Scripting
math: fft evaluation
Inputs
Outputs
Configurations
Scripting
result: global total energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: plastic strain Z
Inputs
Outputs
Configurations
Scripting
utility: merge materials
Inputs
Outputs
Configurations
Scripting
serialization: vtk export
Inputs
Outputs
Configurations
Scripting
result: dynamic viscosity
Inputs
Outputs
Configurations
Scripting
result: plastic strain XY
Inputs
Outputs
Configurations
Scripting
result: hydrostatic pressure
Inputs
Outputs
Configurations
Scripting
result: compute stress von mises
Inputs
Outputs
Configurations
Scripting
filter: low pass (scoping)
Inputs
Outputs
Configurations
Scripting
mesh: iso surfaces
Inputs
Outputs
Configurations
Scripting
result: plastic strain YZ
Inputs
Outputs
Configurations
Scripting
result: plastic strain XZ
Inputs
Outputs
Configurations
Scripting
result: workflow energy per harmonic
Inputs
Outputs
Configurations
Scripting
result: plastic strain principal 3
Inputs
Outputs
Configurations
Scripting
result: plastic strain intensity
Inputs
Outputs
Configurations
Scripting
result: plastic strain max_shear
Inputs
Outputs
Configurations
Scripting
filter: low pass (timefreq)
Inputs
Outputs
Configurations
Scripting
filter: band pass (field)
Inputs
Outputs
Configurations
Scripting
math: modal damping ratio
Inputs
Outputs
Configurations
Scripting
result: thermal strain X
Inputs
Outputs
Configurations
Scripting
result: thermal strain Y
Inputs
Outputs
Configurations
Scripting
math: accumulate level over label
Inputs
Outputs
Configurations
Scripting
result: equivalent radiated power
Inputs
Outputs
Configurations
Scripting
result: thermal strain Z
Inputs
Outputs
Configurations
Scripting
result: thermal strain XY
Inputs
Outputs
Configurations
Scripting
math: accumulate over label
Inputs
Outputs
Configurations
Scripting
utility: merge scopings containers
Inputs
Outputs
Configurations
Scripting
result: thermal strain YZ
Inputs
Outputs
Configurations
Scripting
result: thermal strain principal 1
Inputs
Outputs
Configurations
Scripting
result: thermal strain principal 2
Inputs
Outputs
Configurations
Scripting
result: thermal strain principal 3
Inputs
Outputs
Configurations
Scripting
result: wall shear stress
Inputs
Outputs
Configurations
Scripting
result: velocity
Inputs
Outputs
Configurations
Scripting
result: reaction force
Inputs
Outputs
Configurations
Scripting
serialization: serializer
Inputs
Outputs
Configurations
Scripting
result: velocity X
Inputs
Outputs
Configurations
Scripting
result: reaction force X
Inputs
Outputs
Configurations
Scripting
geo: cartesian to spherical coordinates (fields container)
Inputs
Outputs
Configurations
Scripting
result: global external work (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: acceleration
Inputs
Outputs
Configurations
Scripting
result: element centroids
Inputs
Outputs
Configurations
Scripting
result: acceleration Z
Inputs
Outputs
Configurations
Scripting
scoping: rescope (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: workflow to workflow_topology
Inputs
Outputs
Configurations
Scripting
result: displacement
Inputs
Outputs
Configurations
Scripting
result: displacement X
Inputs
Outputs
Configurations
Scripting
averaging: force_summation
Inputs
Outputs
Configurations
Scripting
result: displacement Y
Inputs
Outputs
Configurations
Scripting
result: displacement Z
Inputs
Outputs
Configurations
Scripting
result: heat flux X
Inputs
Outputs
Configurations
Scripting
result: heat flux Y
Inputs
Outputs
Configurations
Scripting
result: electric field
Inputs
Outputs
Configurations
Scripting
result: heat flux Z
Inputs
Outputs
Configurations
Scripting
serialization: serialize to hdf5
Inputs
Outputs
Configurations
Scripting
result: element orientations
Inputs
Outputs
Configurations
Scripting
result: element orientations Y
Inputs
Outputs
Configurations
Scripting
mesh: split mesh wrt property
Inputs
Outputs
Configurations
Scripting
result: element orientations Z
Inputs
Outputs
Configurations
Scripting
result: element nodal forces
Inputs
Outputs
Configurations
Scripting
result: compute total strain Z
Outputs
Configurations
Scripting
result: gasket inelastic closure
Inputs
Outputs
Configurations
Scripting
result: gasket inelastic closure X
Inputs
Outputs
Configurations
Scripting
result: write cms rbd file
Inputs
Outputs
Configurations
Scripting
serialization: export symbolic workflow
Inputs
Outputs
Configurations
Scripting
result: gasket inelastic closure XY
Inputs
Outputs
Configurations
Scripting
result: plastic strain eqv
Inputs
Outputs
Configurations
Scripting
mesh: beam properties
Inputs
Outputs
Configurations
Scripting
result: gasket inelastic closure XZ
Inputs
Outputs
Configurations
Scripting
result: gasket thermal closure
Inputs
Outputs
Configurations
Scripting
result: gasket thermal closure X
Inputs
Outputs
Configurations
Scripting
result: elastic strain X
Inputs
Outputs
Configurations
Scripting
result: elastic strain Y
Inputs
Outputs
Configurations
Scripting
result: elastic strain Z
Inputs
Outputs
Configurations
Scripting
math: min/max over time
Inputs
Outputs
Configurations
Scripting
utility: merge fields containers
Inputs
Outputs
Configurations
Scripting
result: global energy ratio without eroded energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
utility: merge weighted fields containers
Inputs
Outputs
Configurations
Scripting
result: elastic strain XY
Inputs
Outputs
Configurations
Scripting
result: elastic strain YZ
Inputs
Outputs
Configurations
Scripting
invariant: eigen values (fields container)
Inputs
Outputs
Configurations
Scripting
result: elastic strain XZ
Inputs
Outputs
Configurations
Scripting
metadata: mesh property provider
Inputs
Outputs
Configurations
Scripting
result: elastic strain principal 1
Inputs
Outputs
Configurations
Scripting
result: elastic strain principal 2
Inputs
Outputs
Configurations
Scripting
utility: merge scopings
Inputs
Outputs
Configurations
Scripting
result: elastic strain principal 3
Inputs
Outputs
Configurations
Scripting
result: cyclic analytic disp max
Inputs
Outputs
Configurations
Scripting
result: elastic strain eqv
Inputs
Outputs
Configurations
Scripting
result: electric flux density X
Inputs
Outputs
Configurations
Scripting
result: elastic strain intensity
Inputs
Outputs
Configurations
Scripting
result: elastic strain max_shear
Inputs
Outputs
Configurations
Scripting
result: turbulent dissipation rate (omega)
Inputs
Outputs
Configurations
Scripting
averaging: to elemental (fields container)
Inputs
Outputs
Configurations
Scripting
result: plastic strain
Inputs
Outputs
Configurations
Scripting
scoping: transpose
Inputs
Outputs
Configurations
Scripting
result: mass fraction
Inputs
Outputs
Configurations
Scripting
result: plastic strain X
Inputs
Outputs
Configurations
Scripting
result: coordinates (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: plastic strain Y
Inputs
Outputs
Configurations
Scripting
filter: band pass (fields container)
Inputs
Outputs
Configurations
Scripting
geo: to polar coordinates
Inputs
Outputs
Configurations
Scripting
math: fft evaluation
Inputs
Outputs
Configurations
Scripting
result: global total energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: plastic strain Z
Inputs
Outputs
Configurations
Scripting
utility: merge materials
Inputs
Outputs
Configurations
Scripting
serialization: vtk export
Inputs
Outputs
Configurations
Scripting
result: dynamic viscosity
Inputs
Outputs
Configurations
Scripting
result: plastic strain XY
Inputs
Outputs
Configurations
Scripting
result: hydrostatic pressure
Inputs
Outputs
Configurations
Scripting
result: compute stress von mises
Inputs
Outputs
Configurations
Scripting
filter: low pass (scoping)
Inputs
Outputs
Configurations
Scripting
mesh: iso surfaces
Inputs
Outputs
Configurations
Scripting
result: plastic strain YZ
Inputs
Outputs
Configurations
Scripting
result: plastic strain XZ
Inputs
Outputs
Configurations
Scripting
result: workflow energy per harmonic
Inputs
Outputs
Configurations
Scripting
result: plastic strain principal 3
Inputs
Outputs
Configurations
Scripting
result: plastic strain intensity
Inputs
Outputs
Configurations
Scripting
result: plastic strain max_shear
Inputs
Outputs
Configurations
Scripting
filter: low pass (timefreq)
Inputs
Outputs
Configurations
Scripting
filter: band pass (field)
Inputs
Outputs
Configurations
Scripting
math: modal damping ratio
Inputs
Outputs
Configurations
Scripting
result: thermal strain X
Inputs
Outputs
Configurations
Scripting
result: thermal strain Y
Inputs
Outputs
Configurations
Scripting
result: equivalent radiated power
Inputs
Outputs
Configurations
Scripting
result: thermal strain Z
Inputs
Outputs
Configurations
Scripting
utility: merge scopings containers
Inputs
Outputs
Configurations
Scripting
math: accumulate over label
Inputs
Outputs
Configurations
Scripting
result: thermal strain XY
Inputs
Outputs
Configurations
Scripting
result: thermal strain YZ
Inputs
Outputs
Configurations
Scripting
result: thermal strain principal 1
Inputs
Outputs
Configurations
Scripting
result: thermal strain principal 2
Inputs
Outputs
Configurations
Scripting
result: thermal strain principal 3
Inputs
Outputs
Configurations
Scripting
serialization: serializer
Inputs
Outputs
Configurations
Scripting
result: wall shear stress
Inputs
Outputs
Configurations
Scripting
result: velocity
Inputs
Outputs
Configurations
Scripting
result: reaction force
Inputs
Outputs
Configurations
Scripting
result: velocity X
Inputs
Outputs
Configurations
Scripting
result: reaction force X
Inputs
Outputs
Configurations
Scripting
geo: cartesian to spherical coordinates (fields container)
Inputs
Outputs
Configurations
Scripting
result: global external work (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: acceleration
Inputs
Outputs
Configurations
Scripting
result: element centroids
Inputs
Outputs
Configurations
Scripting
result: acceleration Z
Inputs
Outputs
Configurations
Scripting
scoping: rescope (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: workflow to workflow_topology
Inputs
Outputs
Configurations
Scripting
result: displacement
Inputs
Outputs
Configurations
Scripting
result: electric field Z
Inputs
Outputs
Configurations
Scripting
result: displacement X
Inputs
Outputs
Configurations
Scripting
averaging: force_summation
Inputs
Outputs
Configurations
Scripting
result: displacement Y
Inputs
Outputs
Configurations
Scripting
result: electric field X
Inputs
Outputs
Configurations
Scripting
result: displacement Z
Inputs
Outputs
Configurations
Scripting
result: heat flux X
Inputs
Outputs
Configurations
Scripting
result: heat flux Y
Inputs
Outputs
Configurations
Scripting
result: electric field
Inputs
Outputs
Configurations
Scripting
result: heat flux Z
Inputs
Outputs
Configurations
Scripting
serialization: serialize to hdf5
Inputs
Outputs
Configurations
Scripting
result: element orientations
Inputs
Outputs
Configurations
Scripting
result: element orientations Y
Inputs
Outputs
Configurations
Scripting
result: magnetic field Z
Inputs
Outputs
Configurations
Scripting
averaging: elemental mean (fields container)
Inputs
Outputs
Configurations
Scripting
result: magnetic field Y
Inputs
Outputs
Configurations
Scripting
mesh: split mesh wrt property
Inputs
Outputs
Configurations
Scripting
result: element orientations Z
Inputs
Outputs
Configurations
Scripting
result: temperature gradient
Inputs
Outputs
Configurations
Scripting
result: cgns result provider
Inputs
Outputs
Configurations
Scripting
result: temperature gradient X
Inputs
Outputs
Configurations
Scripting
result: entropy
Inputs
Outputs
Configurations
Scripting
result: volume fraction
Inputs
Outputs
Configurations
Scripting
result: temperature gradient Y
Inputs
Outputs
Configurations
Scripting
result: temperature gradient Z
Inputs
Outputs
Configurations
Scripting
result: elemental summable miscellaneous data
Inputs
Outputs
Configurations
Scripting
result: magnetic field
Inputs
Outputs
Configurations
Scripting
result: compute stress Z
Inputs
Outputs
Configurations
Scripting
result: part eroded kinetic energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
result: magnetic field X
Inputs
Outputs
Configurations
Scripting
serialization: string deserializer
Inputs
Outputs
Configurations
Scripting
utility: merge meshes containers
Inputs
Outputs
Configurations
Scripting
result: magnetic flux density
Inputs
Outputs
Configurations
Scripting
result: magnetic flux density X
Inputs
Outputs
Configurations
Scripting
result: magnetic flux density Y
Inputs
Outputs
Configurations
Scripting
result: nodal force
Inputs
Outputs
Configurations
Scripting
result: magnetic flux density Z
Inputs
Outputs
Configurations
Scripting
result: electric field Y
Inputs
Outputs
Configurations
Scripting
result: electric flux density Z
Inputs
Outputs
Configurations
Scripting
result: element nodal forces
Inputs
Outputs
Configurations
Scripting
result: compute total strain Z
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 ZZ normal component (22 component).">Inputs
Outputs
Configurations
Scripting
result: structural temperature
Inputs
Outputs
Configurations
Scripting
metadata: result info provider
Inputs
Outputs
Configurations
Scripting
mesh: skin (tri mesh)
Inputs
Outputs
Configurations
Scripting
result: stress ratio
Inputs
Outputs
Configurations
Scripting
filter: band pass (timescoping)
Inputs
Outputs
Configurations
Scripting
compression: sketch matrix
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
result: mapdl run
Inputs
Outputs
Configurations
Scripting
result: equivalent mass
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: elemental summable miscellaneous data
Inputs
Outputs
Configurations
Scripting
result: magnetic field
Inputs
Outputs
Configurations
Scripting
utility: merge meshes containers
Inputs
Outputs
Configurations
Scripting
result: magnetic flux density
Inputs
Outputs
Configurations
Scripting
result: magnetic vector potential
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: global internal energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
serialization: txt to data tree
Inputs
Outputs
Configurations
Scripting
result: thermal strains eqv
Inputs
Outputs
Configurations
Scripting
result: elemental non summable miscellaneous data
Inputs
Outputs
Configurations
Scripting
utility: merge supports
Inputs
Outputs
Configurations
Scripting
result: global kinetic energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: matrix inverse
Inputs
Outputs
Configurations
Scripting
result: global time step (LSDyna)
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
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
invariant: principal invariants (fields container)
Inputs
Outputs
Configurations
Scripting
result: global added mass (percentage) (LSDyna)
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
utility: merge fields into field matrix
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
scoping: nodes in mesh
Inputs
Outputs
Configurations
Scripting
metadata: cyclic support provider
Inputs
Outputs
Configurations
Scripting
result: density
Inputs
Outputs
Configurations
Scripting
result: spectrum data
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: Lighthill tensor divergence
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
scoping: scoping get attribute
Inputs
Outputs
Configurations
Scripting
result: read cms_rbd file
Inputs
Outputs
Configurations
Scripting
result: mean temperature
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
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
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
scoping: rescope
Inputs
Outputs
Configurations
Scripting
filter: low pass (timescoping)
Inputs
Outputs
Configurations
Scripting
utility: data sources get attribute
Inputs
Outputs
Configurations
Scripting
mesh: meshes provider
Inputs
Outputs
Configurations
Scripting
metadata: mesh selection manager provider
Inputs
Outputs
Configurations
Scripting
utility: for each
Inputs
Outputs
Configurations
Scripting
metadata: boundary condition provider
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 sampling scoping
Inputs
Outputs
Configurations
Scripting
math: accumulation per scoping
Inputs
Outputs
Configurations
Scripting
result: coordinate system
Inputs
Outputs
Configurations
Scripting
logic: splitter::streams
Inputs
Outputs
Configurations
Scripting
serialization: hdf5dpf custom read
Inputs
Outputs
Configurations
Scripting
result: nodal_to_global
Inputs
Outputs
Configurations
Scripting
scoping: rescope custom type field
Inputs
Outputs
Configurations
Scripting
result: global_to_nodal
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity over time
Inputs
Outputs
Configurations
Scripting
min_max: max over time
Inputs
Outputs
Configurations
Scripting
scoping: connectivity ids
Inputs
Outputs
Configurations
Scripting
utility: remote workflow instantiate
Inputs
Outputs
Configurations
Scripting
utility: remote operator instantiate
Inputs
Outputs
Configurations
Scripting
math: compute residual and error
Inputs
Outputs
Configurations
Scripting
result: structural temperature
Inputs
Outputs
Configurations
Scripting
metadata: result info provider
Inputs
Outputs
Configurations
Scripting
mesh: skin (tri mesh)
Inputs
Outputs
Configurations
Scripting
result: stress ratio
Inputs
Outputs
Configurations
Scripting
filter: band pass (timescoping)
Inputs
Outputs
Configurations
Scripting
compression: sketch matrix
Inputs
Outputs
Configurations
Scripting
result: accu eqv plastic strain
Inputs
Outputs
Configurations
Scripting
result: plastic state variable
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: 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
result: mapdl run
Inputs
Outputs
Configurations
Scripting
result: equivalent mass
Inputs
Outputs
Configurations
Scripting
result: custom result
Inputs
Outputs
Configurations
Scripting
result: elemental heat generation
Inputs
Outputs
Configurations
Scripting
result: magnetic vector potential
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: global internal energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
serialization: txt to data tree
Inputs
Outputs
Configurations
Scripting
result: thermal strains eqv
Inputs
Outputs
Configurations
Scripting
result: elemental non summable miscellaneous data
Inputs
Outputs
Configurations
Scripting
utility: merge supports
Inputs
Outputs
Configurations
Scripting
result: global kinetic energy (LSDyna)
Inputs
Outputs
Configurations
Scripting
math: matrix inverse
Inputs
Outputs
Configurations
Scripting
result: global time step (LSDyna)
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
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
invariant: principal invariants (fields container)
Inputs
Outputs
Configurations
Scripting
result: global added mass (percentage) (LSDyna)
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
utility: merge fields into field matrix
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
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
scoping: nodes in mesh
Inputs
Outputs
Configurations
Scripting
metadata: cyclic support provider
Inputs
Outputs
Configurations
Scripting
result: density
Inputs
Outputs
Configurations
Scripting
result: spectrum data
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: Lighthill tensor divergence
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
scoping: scoping get attribute
Inputs
Outputs
Configurations
Scripting
result: read cms_rbd file
Inputs
Outputs
Configurations
Scripting
result: mean temperature
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
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
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
scoping: rescope
Inputs
Outputs
Configurations
Scripting
filter: low pass (timescoping)
Inputs
Outputs
Configurations
Scripting
utility: data sources get attribute
Inputs
Outputs
Configurations
Scripting
mesh: meshes provider
Inputs
Outputs
Configurations
Scripting
metadata: mesh selection manager provider
Inputs
Outputs
Configurations
Scripting
utility: for each
Inputs
Outputs
Configurations
Scripting
metadata: boundary condition provider
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 sampling scoping
Inputs
Outputs
Configurations
Scripting
math: accumulation per scoping
Inputs
Outputs
Configurations
Scripting
metadata: real constants provider
Inputs
Outputs
Configurations
Scripting
metadata: coordinate system data provider
Inputs
Outputs
Configurations
Scripting
result: coordinate system
Inputs
Outputs
Configurations
Scripting
logic: splitter::streams
Inputs
Outputs
Configurations
Scripting
serialization: hdf5dpf custom read
Inputs
Outputs
Configurations
Scripting
result: nodal_to_global
Inputs
Outputs
Configurations
Scripting
scoping: rescope custom type field
Inputs
Outputs
Configurations
Scripting
result: global_to_nodal
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity over time
Inputs
Outputs
Configurations
Scripting
min_max: max over time
Inputs
Outputs
Configurations
Scripting
scoping: connectivity ids
Inputs
Outputs
Configurations
Scripting
utility: remote workflow instantiate
Inputs
Outputs
Configurations
Scripting
utility: remote operator instantiate
Inputs
Outputs
Configurations
Scripting
math: compute residual and error
Configurating operators
2 for normalized by the max at a given time step of the first entry or residuals depending on the reference field option,
3 for normalized by the max over all time steps of the first entry or residuals depending on the reference field option" types="int32" optional="true"ellipsis="false"inplace="false">Outputs
Configurations
Scripting
result: add rigid body motion (fields container)
Inputs
Outputs
Configurations
Scripting
utility: merge time freq supports
Inputs
Outputs
Configurations
Scripting
min_max: incremental over fields container
Inputs
Outputs
Configurations
Scripting
scoping: split on property type
Inputs
Outputs
Configurations
Scripting
utility: overlap fields
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal elemental (field)
Inputs
Outputs
Configurations
Scripting
scoping: adapt with scopings container
Inputs
Outputs
Configurations
Scripting
utility: change shell layers
Inputs
Outputs
Configurations
Scripting
utility: merge meshes
Inputs
Outputs
Configurations
Scripting
utility: merge fields
Inputs
Outputs
Configurations
Scripting
utility: merge weighted fields
Inputs
Outputs
Configurations
Scripting
utility: merge fc to fc field matrices
Inputs
Outputs
Configurations
Scripting
filter: high pass (field)
Inputs
Outputs
Configurations
Scripting
min_max: max by component
Inputs
Outputs
Configurations
Scripting
utility: weighted merge fields by label
Inputs
Outputs
Configurations
Scripting
utility: merge fields by label
Inputs
Outputs
Configurations
Scripting
averaging: elemental to elemental nodal (field)
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity
Inputs
Outputs
Configurations
Scripting
utility: merge collections
Inputs
Outputs
Configurations
Scripting
logic: merge solid and shell fields
Inputs
Outputs
Configurations
Scripting
min_max: min over time
Inputs
Outputs
Configurations
Scripting
geo: element nodal contribution
Inputs
Outputs
Configurations
Scripting
min_max: over label
Inputs
Outputs
Configurations
Scripting
min_max: min by component
Inputs
Outputs
Configurations
Scripting
serialization: serializer to string
Inputs
Outputs
Configurations
Scripting
serialization: deserializer
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded velocity
Inputs
Outputs
Configurations
Scripting
mesh: skin
Inputs
Outputs
Configurations
Scripting
utility: split in for each range
Inputs
Outputs
Configurations
Scripting
utility: make for each range
Inputs
Outputs
Configurations
Scripting
utility: incremental field
Inputs
Outputs
Configurations
Scripting
utility: incremental fields container
Inputs
Outputs
Configurations
Scripting
geo: rotate (fields container)
Inputs
Outputs
Configurations
Scripting
utility: incremental property field
Inputs
Outputs
Configurations
Scripting
utility: incremental mesh
Inputs
Outputs
Configurations
Scripting
mesh: points from coordinates
Inputs
Outputs
Configurations
Scripting
utility: incremental concantenate as fields container.
Inputs
Outputs
Configurations
Scripting
utility: make producer consumer for each iterator
Inputs
Outputs
Configurations
Scripting
utility: producer consumer for each
Inputs
Outputs
Configurations
Scripting
averaging: extend to mid nodes (field)
Inputs
Outputs
Configurations
Scripting
invariant: eigen vectors (on fields container)
Inputs
Outputs
Configurations
Scripting
mesh: mesh get attribute
Inputs
Outputs
Configurations
Scripting
metadata: time freq support get attribute
Inputs
Outputs
Configurations
Scripting
utility: set attribute
Inputs
Outputs
Configurations
Scripting
utility: field get attribute
Inputs
Outputs
Configurations
Scripting
min_max: time of min
Inputs
Outputs
Configurations
Scripting
min_max: max over phase
Inputs
Outputs
Configurations
Scripting
min_max: phase of max
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains (fields container)
Inputs
Outputs
Configurations
Scripting
min_max: incremental over field
Inputs
Outputs
Configurations
Scripting
utility: workflow to pydpf generator
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (timefreq)
Inputs
Outputs
Configurations
Scripting
logic: same string fields?
Inputs
Outputs
Configurations
Scripting
logic: same meshes?
Inputs
Outputs
Configurations
Scripting
logic: same fields?
Inputs
Outputs
Configurations
Scripting
logic: fields included?
Inputs
Outputs
Configurations
Scripting
logic: same fields container?
Inputs
Outputs
Configurations
Scripting
filter: high pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: high pass (timescoping)
Inputs
Outputs
Configurations
Scripting
filter: high pass (fields container)
Inputs
Outputs
Configurations
Scripting
filter: low pass (field)
Inputs
Outputs
Configurations
Scripting
filter: low pass (fields container)
Inputs
Outputs
Configurations
Scripting
filter: band pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: band pass (timefreq)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (timescoping)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: csv to field
Inputs
Outputs
Configurations
Scripting
result: members in compression not certified
Inputs
Outputs
Configurations
Scripting
result: members in bending not certified
Inputs
Outputs
Configurations
Scripting
result: members in linear compression bending not certified
Inputs
Outputs
Configurations
Scripting
invariant: convertnum nod to bcs
Inputs
Outputs
Configurations
Scripting
geo: rotate
Inputs
Outputs
Configurations
Scripting
logic: enrich materials
Inputs
Outputs
Configurations
Scripting
serialization: data tree to json
Inputs
Outputs
Configurations
Scripting
serialization: data tree to txt
Inputs
Outputs
Configurations
Scripting
serialization: json to data tree
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (fields container)
Inputs
Outputs
Configurations
Scripting
logic: descending sort
Inputs
Outputs
Configurations
Scripting
logic: ascending sort (fields container)
Inputs
Outputs
Configurations
Scripting
logic: descending sort (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: import symbolic workflow
Inputs
Outputs
Configurations
Scripting
filter: filtering max over time workflow
Inputs
Outputs
Configurations
Scripting
metadata: integrate over time freq
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (field)
Inputs
Outputs
Configurations
Scripting
result: compute stress YZ
Inputs
Outputs
Configurations
Scripting
logic: splitter::data_sources
Inputs
Outputs
Configurations
Scripting
averaging: to elemental nodal (fields container)
Inputs
Outputs
Configurations
Scripting
server: grpc start server
Inputs
Outputs
Configurations
Scripting
result: compute stress XY
Inputs
Outputs
Configurations
Scripting
utility: operator id
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal (field)
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: elemental to nodal (field)
Outputs
Configurations
Scripting
result: add rigid body motion (fields container)
Inputs
Outputs
Configurations
Scripting
utility: merge time freq supports
Inputs
Outputs
Configurations
Scripting
min_max: incremental over fields container
Inputs
Outputs
Configurations
Scripting
scoping: split on property type
Inputs
Outputs
Configurations
Scripting
utility: overlap fields
Inputs
Outputs
Configurations
Scripting
averaging: elemental nodal to nodal elemental (field)
Inputs
Outputs
Configurations
Scripting
scoping: adapt with scopings container
Inputs
Outputs
Configurations
Scripting
utility: change shell layers
Inputs
Outputs
Configurations
Scripting
utility: merge meshes
Inputs
Outputs
Configurations
Scripting
utility: merge fields
Inputs
Outputs
Configurations
Scripting
utility: merge weighted fields
Inputs
Outputs
Configurations
Scripting
utility: merge fc to fc field matrices
Inputs
Outputs
Configurations
Scripting
filter: high pass (field)
Inputs
Outputs
Configurations
Scripting
utility: weighted merge fields by label
Inputs
Outputs
Configurations
Scripting
min_max: max by component
Inputs
Outputs
Configurations
Scripting
utility: merge fields by label
Inputs
Outputs
Configurations
Scripting
averaging: elemental to elemental nodal (field)
Inputs
Outputs
Configurations
Scripting
min_max: min max by entity
Inputs
Outputs
Configurations
Scripting
utility: merge collections
Inputs
Outputs
Configurations
Scripting
logic: merge solid and shell fields
Inputs
Outputs
Configurations
Scripting
min_max: min over time
Inputs
Outputs
Configurations
Scripting
geo: element nodal contribution
Inputs
Outputs
Configurations
Scripting
min_max: over field
Inputs
Outputs
Configurations
Scripting
result: transient rayleigh integration
Inputs
Outputs
Configurations
Scripting
min_max: over fields container
Inputs
Outputs
Configurations
Scripting
min_max: over label
Inputs
Outputs
Configurations
Scripting
min_max: min by component
Inputs
Outputs
Configurations
Scripting
math: average over label
Inputs
Outputs
Configurations
Scripting
math: accumulate level over label
Inputs
Outputs
Configurations
Scripting
serialization: serializer to string
Inputs
Outputs
Configurations
Scripting
serialization: deserializer
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded velocity
Inputs
Outputs
Configurations
Scripting
mesh: skin
Inputs
Outputs
Configurations
Scripting
utility: split in for each range
Inputs
Outputs
Configurations
Scripting
utility: make for each range
Inputs
Outputs
Configurations
Scripting
utility: incremental field
Inputs
Outputs
Configurations
Scripting
utility: incremental fields container
Inputs
Outputs
Configurations
Scripting
geo: rotate (fields container)
Inputs
Outputs
Configurations
Scripting
utility: incremental property field
Inputs
Outputs
Configurations
Scripting
utility: incremental mesh
Inputs
Outputs
Configurations
Scripting
mesh: points from coordinates
Inputs
Outputs
Configurations
Scripting
utility: incremental concantenate as fields container.
Inputs
Outputs
Configurations
Scripting
utility: make producer consumer for each iterator
Inputs
Outputs
Configurations
Scripting
utility: producer consumer for each
Inputs
Outputs
Configurations
Scripting
averaging: extend to mid nodes (field)
Inputs
Outputs
Configurations
Scripting
invariant: eigen vectors (on fields container)
Inputs
Outputs
Configurations
Scripting
mesh: mesh get attribute
Inputs
Outputs
Configurations
Scripting
metadata: time freq support get attribute
Inputs
Outputs
Configurations
Scripting
utility: set attribute
Inputs
Outputs
Configurations
Scripting
utility: field get attribute
Inputs
Outputs
Configurations
Scripting
min_max: time of min
Inputs
Outputs
Configurations
Scripting
min_max: max over phase
Inputs
Outputs
Configurations
Scripting
min_max: phase of max
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains
Inputs
Outputs
Configurations
Scripting
utility: voigt to standard strains (fields container)
Inputs
Outputs
Configurations
Scripting
min_max: incremental over field
Inputs
Outputs
Configurations
Scripting
utility: workflow to pydpf generator
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (timefreq)
Inputs
Outputs
Configurations
Scripting
logic: same string fields?
Inputs
Outputs
Configurations
Scripting
logic: same meshes?
Inputs
Outputs
Configurations
Scripting
logic: same fields?
Inputs
Outputs
Configurations
Scripting
logic: fields included?
Inputs
Outputs
Configurations
Scripting
logic: same fields container?
Inputs
Outputs
Configurations
Scripting
filter: high pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: high pass (timescoping)
Inputs
Outputs
Configurations
Scripting
filter: high pass (fields container)
Inputs
Outputs
Configurations
Scripting
filter: low pass (field)
Inputs
Outputs
Configurations
Scripting
filter: low pass (fields container)
Inputs
Outputs
Configurations
Scripting
filter: band pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: band pass (timefreq)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (scoping)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (timescoping)
Inputs
Outputs
Configurations
Scripting
filter: signed high pass (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: csv to field
Inputs
Outputs
Configurations
Scripting
result: members in compression not certified
Inputs
Outputs
Configurations
Scripting
result: members in bending not certified
Inputs
Outputs
Configurations
Scripting
result: members in linear compression bending not certified
Inputs
Outputs
Configurations
Scripting
invariant: convertnum nod to bcs
Inputs
Outputs
Configurations
Scripting
geo: rotate
Inputs
Outputs
Configurations
Scripting
logic: enrich materials
Inputs
Outputs
Configurations
Scripting
serialization: data tree to json
Inputs
Outputs
Configurations
Scripting
serialization: data tree to txt
Inputs
Outputs
Configurations
Scripting
serialization: json to data tree
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (fields container)
Inputs
Outputs
Configurations
Scripting
logic: descending sort
Inputs
Outputs
Configurations
Scripting
logic: ascending sort (fields container)
Inputs
Outputs
Configurations
Scripting
logic: descending sort (fields container)
Inputs
Outputs
Configurations
Scripting
serialization: import symbolic workflow
Inputs
Outputs
Configurations
Scripting
filter: filtering max over time workflow
Inputs
Outputs
Configurations
Scripting
metadata: integrate over time freq
Inputs
Outputs
Configurations
Scripting
averaging: nodal difference (field)
Inputs
Outputs
Configurations
Scripting
result: compute stress YZ
Inputs
Outputs
Configurations
Scripting
logic: splitter::data_sources
Inputs
Outputs
Configurations
Scripting
averaging: to elemental nodal (fields container)
Inputs
Outputs
Configurations
Scripting
server: grpc start server
Inputs
Outputs
Configurations
Scripting
result: compute stress XY
Inputs
Outputs
Configurations
Scripting
utility: operator id
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)
Configurating operators
- 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.">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
averaging: nodal to elemental nodal (field)
Inputs
Outputs
Configurations
Scripting
averaging: nodal to elemental nodal (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: on coordinates
Inputs
Outputs
Configurations
Scripting
mapping: scoping on coordinates
Inputs
Outputs
Configurations
Scripting
filter: abc weightings
Inputs
Outputs
Configurations
Scripting
mapping: solid to skin
Inputs
Outputs
Configurations
Scripting
mapping: solid to skin (fields container)
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, faces, or elements)
Inputs
Outputs
Configurations
Scripting
geo: elements volumes 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
result: torque
Inputs
Outputs
Configurations
Scripting
result: euler load buckling
Inputs
Outputs
Configurations
Scripting
geo: faces area
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
math: mac
Inputs
Outputs
Configurations
Scripting
result: workflow energy per component
Inputs
Outputs
Configurations
Scripting
result: add rigid body motion (field)
Inputs
Outputs
Configurations
Scripting
result: split on facet indices
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded temperature
Inputs
Outputs
Configurations
Scripting
result: enf solution to global cs
Inputs
Outputs
Configurations
Scripting
result: cms matrices provider
Inputs
Outputs
Configurations
Scripting
result: rom data provider
Inputs
Outputs
Configurations
Scripting
result: prns to field
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
result: cyclic nmisc
Inputs
Outputs
Configurations
Scripting
invariant: convertnum operator
Inputs
Outputs
Configurations
Scripting
result: compute total strain XZ
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: nodal to elemental (field)
Inputs
Outputs
Configurations
Scripting
averaging: nodal to elemental (fields container)
Inputs
Outputs
Configurations
Scripting
averaging: nodal to elemental nodal (field)
Inputs
Outputs
Configurations
Scripting
averaging: nodal to elemental nodal (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: on coordinates
Inputs
Outputs
Configurations
Scripting
mapping: scoping on coordinates
Inputs
Outputs
Configurations
Scripting
filter: abc weightings
Inputs
Outputs
Configurations
Scripting
mapping: solid to skin
Inputs
Outputs
Configurations
Scripting
mapping: solid to skin (fields container)
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, faces, or elements)
Inputs
Outputs
Configurations
Scripting
geo: elements volumes 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
result: torque
Inputs
Outputs
Configurations
Scripting
result: euler load buckling
Inputs
Outputs
Configurations
Scripting
geo: faces area
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
math: mac
Inputs
Outputs
Configurations
Scripting
result: workflow energy per component
Inputs
Outputs
Configurations
Scripting
result: add rigid body motion (field)
Inputs
Outputs
Configurations
Scripting
result: split on facet indices
Inputs
Outputs
Configurations
Scripting
result: enf solution to global cs
Inputs
Outputs
Configurations
Scripting
result: cms matrices provider
Inputs
Outputs
Configurations
Scripting
result: rom data provider
Inputs
Outputs
Configurations
Scripting
result: prns to field
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
result: cyclic nmisc
Inputs
Outputs
Configurations
Scripting
invariant: convertnum operator
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
result: write motion dfmf file
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: compute invariant terms motion
Inputs
Outputs
Configurations
Scripting
result: split to acmo facet indices
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
math: qr solve
Inputs
Outputs
Configurations
Scripting
result: von mises strains as mechanical workflow
Inputs
Outputs
Configurations
Scripting
mesh: mesh clipper
Inputs
Outputs
Configurations
Scripting
serialization: migrate to vtk
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded element heat flux
Inputs
Outputs
Configurations
Scripting
mesh: external layer
Inputs
Outputs
Configurations
Scripting
mesh: mesh cutter
Inputs
Outputs
Configurations
Scripting
mesh: mesh plan clipper
Inputs
Outputs
Configurations
Scripting
mesh: mesh_to_graphics
Inputs
Outputs
Configurations
Scripting
mesh: mesh_to_graphics_edges
Inputs
Outputs
Configurations
Scripting
geo: scoping normals
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
mesh: make sphere levelset
Inputs
Outputs
Configurations
Scripting
mesh: wireframe
Inputs
Outputs
Configurations
Scripting
mesh: mesh to tetra
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: svd
Inputs
Outputs
Configurations
Scripting
math: time integration
Inputs
Outputs
Configurations
Scripting
math: time derivation
Inputs
Outputs
Configurations
Scripting
mapping: prep sampling fft
Inputs
Outputs
Configurations
Scripting
math: fft filtering and cubic fitting
Inputs
Outputs
Configurations
Scripting
math: window triangular
Inputs
Outputs
Configurations
Scripting
math: window hanning
Inputs
Outputs
Configurations
Scripting
math: window hamming
Inputs
Outputs
Configurations
Scripting
math: window welch
Inputs
Outputs
Configurations
Scripting
math: window blackman
Inputs
Outputs
Configurations
Scripting
math: window triangular (fields container)
Inputs
Outputs
Configurations
Scripting
math: window hanning (fields container)
Inputs
Outputs
Configurations
Scripting
math: window hamming (fields container)
Inputs
Outputs
Configurations
Scripting
math: window welch (fields container)
Inputs
Outputs
Configurations
Scripting
math: window blackman (fields container)
Inputs
Outputs
Configurations
Scripting
math: modal superposition
Inputs
Outputs
Configurations
Scripting
serialization: hdf5dpf generate result file
Inputs
Outputs
Configurations
Scripting
result: migrate to h5dpf
Inputs
Outputs
Configurations
Scripting
result: cgns result provider
Inputs
Outputs
Configurations
Scripting
result: von mises stresses as mechanical workflow
Inputs
Outputs
Configurations
Scripting
utility: hdf5dpf workflow provider
Inputs
Outputs
Configurations
Scripting
other: hdf5dpf mesh property provider
Inputs
Outputs
Configurations
Scripting
serialization: migrate to vtu
Inputs
Outputs
Configurations
Scripting
serialization: vtu export
Inputs
Outputs
Configurations
Scripting
result: compute total strain Y
Inputs
Outputs
Configurations
Scripting
result: cms dst table provider
Inputs
Outputs
Configurations
Scripting
result: write motion dfmf file
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: compute invariant terms motion
Inputs
Outputs
Configurations
Scripting
result: split to acmo facet indices
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded element heat flux
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
math: qr solve
Inputs
Outputs
Configurations
Scripting
result: von mises strains as mechanical workflow
Inputs
Outputs
Configurations
Scripting
mesh: mesh clipper
Inputs
Outputs
Configurations
Scripting
serialization: migrate to vtk
Inputs
Outputs
Configurations
Scripting
result: cyclic expanded temperature
Inputs
Outputs
Configurations
Scripting
mesh: external layer
Inputs
Outputs
Configurations
Scripting
mesh: mesh cutter
Inputs
Outputs
Configurations
Scripting
mesh: mesh plan clipper
Inputs
Outputs
Configurations
Scripting
mesh: mesh_to_graphics
Inputs
Outputs
Configurations
Scripting
mesh: mesh_to_graphics_edges
Inputs
Outputs
Configurations
Scripting
geo: scoping normals
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
mesh: make sphere levelset
Inputs
Outputs
Configurations
Scripting
mesh: wireframe
Inputs
Outputs
Configurations
Scripting
mesh: mesh to tetra
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: svd
Inputs
Outputs
Configurations
Scripting
math: time integration
Inputs
Outputs
Configurations
Scripting
math: time derivation
Inputs
Outputs
Configurations
Scripting
mapping: prep sampling fft
Inputs
Outputs
Configurations
Scripting
math: fft filtering and cubic fitting
Inputs
Outputs
Configurations
Scripting
math: window triangular
Inputs
Outputs
Configurations
Scripting
math: window hanning
Inputs
Outputs
Configurations
Scripting
math: window hamming
Inputs
Outputs
Configurations
Scripting
math: window welch
Inputs
Outputs
Configurations
Scripting
math: window blackman
Inputs
Outputs
Configurations
Scripting
math: window triangular (fields container)
Inputs
Outputs
Configurations
Scripting
math: window hanning (fields container)
Inputs
Outputs
Configurations
Scripting
math: window hamming (fields container)
Inputs
Outputs
Configurations
Scripting
math: window welch (fields container)
Inputs
Outputs
Configurations
Scripting
math: window blackman (fields container)
Inputs
Outputs
Configurations
Scripting
math: modal superposition
Inputs
Outputs
Configurations
Scripting
math: expansion psd
Inputs
Outputs
Configurations
Scripting
serialization: hdf5dpf generate result file
Inputs
Outputs
Configurations
Scripting
result: migrate to h5dpf
Inputs
Outputs
Configurations
Scripting
result: von mises stresses as mechanical workflow
Inputs
Outputs
Configurations
Scripting
utility: hdf5dpf workflow provider
Inputs
Outputs
Configurations
Scripting
other: hdf5dpf mesh property provider
Inputs
Outputs
Configurations
Scripting
serialization: migrate to vtu
Inputs
Outputs
Configurations
Scripting
serialization: vtu export
Inputs
Outputs
Configurations
Scripting
result: compute total strain Y
>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.math.expansion_psd()
+
+ >>> # Make input connections
+ >>> my_mode_shapes = dpf.FieldsContainer()
+ >>> op.inputs.mode_shapes.connect(my_mode_shapes)
+ >>> my_static_shapes = dpf.FieldsContainer()
+ >>> op.inputs.static_shapes.connect(my_static_shapes)
+ >>> my_rel_rel_covar_matrix = dpf.FieldsContainer()
+ >>> op.inputs.rel_rel_covar_matrix.connect(my_rel_rel_covar_matrix)
+ >>> my_stat_stat_covar_matrix = dpf.FieldsContainer()
+ >>> op.inputs.stat_stat_covar_matrix.connect(my_stat_stat_covar_matrix)
+ >>> my_rel_stat_covar_matrix = dpf.FieldsContainer()
+ >>> op.inputs.rel_stat_covar_matrix.connect(my_rel_stat_covar_matrix)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.math.expansion_psd(
+ ... mode_shapes=my_mode_shapes,
+ ... static_shapes=my_static_shapes,
+ ... rel_rel_covar_matrix=my_rel_rel_covar_matrix,
+ ... stat_stat_covar_matrix=my_stat_stat_covar_matrix,
+ ... rel_stat_covar_matrix=my_rel_stat_covar_matrix,
+ ... )
+
+ >>> # Get output data
+ >>> result_psd = op.outputs.psd()
+ """
+
+ def __init__(
+ self,
+ mode_shapes=None,
+ static_shapes=None,
+ rel_rel_covar_matrix=None,
+ stat_stat_covar_matrix=None,
+ rel_stat_covar_matrix=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="expansion::psd", config=config, server=server)
+ self._inputs = InputsExpansionPsd(self)
+ self._outputs = OutputsExpansionPsd(self)
+ if mode_shapes is not None:
+ self.inputs.mode_shapes.connect(mode_shapes)
+ if static_shapes is not None:
+ self.inputs.static_shapes.connect(static_shapes)
+ if rel_rel_covar_matrix is not None:
+ self.inputs.rel_rel_covar_matrix.connect(rel_rel_covar_matrix)
+ if stat_stat_covar_matrix is not None:
+ self.inputs.stat_stat_covar_matrix.connect(stat_stat_covar_matrix)
+ if rel_stat_covar_matrix is not None:
+ self.inputs.rel_stat_covar_matrix.connect(rel_stat_covar_matrix)
+
+ @staticmethod
+ def _spec():
+ description = """Computes the PSD response for one-sigma solution."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="mode_shapes",
+ type_names=["fields_container"],
+ optional=False,
+ document="""Fields container containing the mode shapes
+ from modal analysis file: mode shapes
+ for dynamic and pseudo-static
+ displacements""",
+ ),
+ 1: PinSpecification(
+ name="static_shapes",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fields container containing the static shapes
+ (base excitations) from spectral
+ analysis file""",
+ ),
+ 2: PinSpecification(
+ name="rel_rel_covar_matrix",
+ type_names=["fields_container"],
+ optional=False,
+ document="""Fields container containing covariance
+ matrices from a psd file: covariance
+ matrix terms for
+ displacement/velocity/acceleration
+ mode-mode shapes""",
+ ),
+ 3: PinSpecification(
+ name="stat_stat_covar_matrix",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fields container containing covariance
+ matrices from a psd file: covariance
+ matrix terms for
+ displacement/velocity/acceleration
+ static-static shapes""",
+ ),
+ 4: PinSpecification(
+ name="rel_stat_covar_matrix",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fields container containing covariance
+ matrices from a psd file: covariance
+ matrix terms for
+ displacement/velocity/acceleration
+ mode-static shapes""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="psd",
+ type_names=["fields_container"],
+ optional=False,
+ document="""Psd solution per label""",
+ ),
+ },
+ )
+ 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="expansion::psd", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsExpansionPsd
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsExpansionPsd
+ """
+ return super().outputs
+
+
+class InputsExpansionPsd(_Inputs):
+ """Intermediate class used to connect user inputs to
+ expansion_psd operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.math.expansion_psd()
+ >>> my_mode_shapes = dpf.FieldsContainer()
+ >>> op.inputs.mode_shapes.connect(my_mode_shapes)
+ >>> my_static_shapes = dpf.FieldsContainer()
+ >>> op.inputs.static_shapes.connect(my_static_shapes)
+ >>> my_rel_rel_covar_matrix = dpf.FieldsContainer()
+ >>> op.inputs.rel_rel_covar_matrix.connect(my_rel_rel_covar_matrix)
+ >>> my_stat_stat_covar_matrix = dpf.FieldsContainer()
+ >>> op.inputs.stat_stat_covar_matrix.connect(my_stat_stat_covar_matrix)
+ >>> my_rel_stat_covar_matrix = dpf.FieldsContainer()
+ >>> op.inputs.rel_stat_covar_matrix.connect(my_rel_stat_covar_matrix)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(expansion_psd._spec().inputs, op)
+ self._mode_shapes = Input(expansion_psd._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._mode_shapes)
+ self._static_shapes = Input(expansion_psd._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._static_shapes)
+ self._rel_rel_covar_matrix = Input(
+ expansion_psd._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._rel_rel_covar_matrix)
+ self._stat_stat_covar_matrix = Input(
+ expansion_psd._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._stat_stat_covar_matrix)
+ self._rel_stat_covar_matrix = Input(
+ expansion_psd._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._rel_stat_covar_matrix)
+
+ @property
+ def mode_shapes(self):
+ """Allows to connect mode_shapes input to the operator.
+
+ Fields container containing the mode shapes
+ from modal analysis file: mode shapes
+ for dynamic and pseudo-static
+ displacements
+
+ Parameters
+ ----------
+ my_mode_shapes : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.math.expansion_psd()
+ >>> op.inputs.mode_shapes.connect(my_mode_shapes)
+ >>> # or
+ >>> op.inputs.mode_shapes(my_mode_shapes)
+ """
+ return self._mode_shapes
+
+ @property
+ def static_shapes(self):
+ """Allows to connect static_shapes input to the operator.
+
+ Fields container containing the static shapes
+ (base excitations) from spectral
+ analysis file
+
+ Parameters
+ ----------
+ my_static_shapes : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.math.expansion_psd()
+ >>> op.inputs.static_shapes.connect(my_static_shapes)
+ >>> # or
+ >>> op.inputs.static_shapes(my_static_shapes)
+ """
+ return self._static_shapes
+
+ @property
+ def rel_rel_covar_matrix(self):
+ """Allows to connect rel_rel_covar_matrix input to the operator.
+
+ Fields container containing covariance
+ matrices from a psd file: covariance
+ matrix terms for
+ displacement/velocity/acceleration
+ mode-mode shapes
+
+ Parameters
+ ----------
+ my_rel_rel_covar_matrix : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.math.expansion_psd()
+ >>> op.inputs.rel_rel_covar_matrix.connect(my_rel_rel_covar_matrix)
+ >>> # or
+ >>> op.inputs.rel_rel_covar_matrix(my_rel_rel_covar_matrix)
+ """
+ return self._rel_rel_covar_matrix
+
+ @property
+ def stat_stat_covar_matrix(self):
+ """Allows to connect stat_stat_covar_matrix input to the operator.
+
+ Fields container containing covariance
+ matrices from a psd file: covariance
+ matrix terms for
+ displacement/velocity/acceleration
+ static-static shapes
+
+ Parameters
+ ----------
+ my_stat_stat_covar_matrix : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.math.expansion_psd()
+ >>> op.inputs.stat_stat_covar_matrix.connect(my_stat_stat_covar_matrix)
+ >>> # or
+ >>> op.inputs.stat_stat_covar_matrix(my_stat_stat_covar_matrix)
+ """
+ return self._stat_stat_covar_matrix
+
+ @property
+ def rel_stat_covar_matrix(self):
+ """Allows to connect rel_stat_covar_matrix input to the operator.
+
+ Fields container containing covariance
+ matrices from a psd file: covariance
+ matrix terms for
+ displacement/velocity/acceleration
+ mode-static shapes
+
+ Parameters
+ ----------
+ my_rel_stat_covar_matrix : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.math.expansion_psd()
+ >>> op.inputs.rel_stat_covar_matrix.connect(my_rel_stat_covar_matrix)
+ >>> # or
+ >>> op.inputs.rel_stat_covar_matrix(my_rel_stat_covar_matrix)
+ """
+ return self._rel_stat_covar_matrix
+
+
+class OutputsExpansionPsd(_Outputs):
+ """Intermediate class used to get outputs from
+ expansion_psd operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.math.expansion_psd()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_psd = op.outputs.psd()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(expansion_psd._spec().outputs, op)
+ self._psd = Output(expansion_psd._spec().output_pin(0), 0, op)
+ self._outputs.append(self._psd)
+
+ @property
+ def psd(self):
+ """Allows to get psd output of the operator
+
+ Returns
+ ----------
+ my_psd : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.math.expansion_psd()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_psd = op.outputs.psd()
+ """ # noqa: E501
+ return self._psd
diff --git a/src/ansys/dpf/core/operators/metadata/__init__.py b/src/ansys/dpf/core/operators/metadata/__init__.py
index 9355e95dce3..ff6641e6ec7 100644
--- a/src/ansys/dpf/core/operators/metadata/__init__.py
+++ b/src/ansys/dpf/core/operators/metadata/__init__.py
@@ -1,7 +1,9 @@
from .boundary_condition_provider import boundary_condition_provider
+from .coordinate_system_data_provider import coordinate_system_data_provider
from .cyclic_mesh_expansion import cyclic_mesh_expansion
from .cyclic_support_provider import cyclic_support_provider
from .datasources_provider import datasources_provider
+from .element_types_provider import element_types_provider
from .integrate_over_time_freq import integrate_over_time_freq
from .is_cyclic import is_cyclic
from .material_support_provider import material_support_provider
@@ -10,6 +12,7 @@
from .mesh_selection_manager_provider import mesh_selection_manager_provider
from .mesh_support_provider import mesh_support_provider
from .property_field_provider_by_name import property_field_provider_by_name
+from .real_constants_provider import real_constants_provider
from .result_info_provider import result_info_provider
from .streams_provider import streams_provider
from .time_freq_provider import time_freq_provider
diff --git a/src/ansys/dpf/core/operators/metadata/coordinate_system_data_provider.py b/src/ansys/dpf/core/operators/metadata/coordinate_system_data_provider.py
new file mode 100644
index 00000000000..246db091dd8
--- /dev/null
+++ b/src/ansys/dpf/core/operators/metadata/coordinate_system_data_provider.py
@@ -0,0 +1,323 @@
+"""
+coordinate_system_data_provider
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class coordinate_system_data_provider(Operator):
+ """Reads coordinate systems data from the result files contained in the
+ streams or data sources.
+
+ Parameters
+ ----------
+ solver_coordinate_system_ids : int, optional
+ Coorfinate system ids to recover used by the
+ solver. if not set, all available
+ materials to be recovered.
+ streams : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data.
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set.
+
+ Returns
+ -------
+ coordinate_system_data1 : GenericDataContainer
+ coordinate_system_data2 : GenericDataContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.metadata.coordinate_system_data_provider()
+
+ >>> # Make input connections
+ >>> my_solver_coordinate_system_ids = int()
+ >>> op.inputs.solver_coordinate_system_ids.connect(my_solver_coordinate_system_ids)
+ >>> my_streams = dpf.StreamsContainer()
+ >>> op.inputs.streams.connect(my_streams)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.metadata.coordinate_system_data_provider(
+ ... solver_coordinate_system_ids=my_solver_coordinate_system_ids,
+ ... streams=my_streams,
+ ... data_sources=my_data_sources,
+ ... )
+
+ >>> # Get output data
+ >>> result_coordinate_system_data1 = op.outputs.coordinate_system_data1()
+ >>> result_coordinate_system_data2 = op.outputs.coordinate_system_data2()
+ """
+
+ def __init__(
+ self,
+ solver_coordinate_system_ids=None,
+ streams=None,
+ data_sources=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(
+ name="coordinate_systems_data_provider", config=config, server=server
+ )
+ self._inputs = InputsCoordinateSystemDataProvider(self)
+ self._outputs = OutputsCoordinateSystemDataProvider(self)
+ if solver_coordinate_system_ids is not None:
+ self.inputs.solver_coordinate_system_ids.connect(
+ solver_coordinate_system_ids
+ )
+ if streams is not None:
+ self.inputs.streams.connect(streams)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+
+ @staticmethod
+ def _spec():
+ description = """Reads coordinate systems data from the result files contained in the
+ streams or data sources."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 1: PinSpecification(
+ name="solver_coordinate_system_ids",
+ type_names=["int32", "vector"],
+ optional=True,
+ document="""Coorfinate system ids to recover used by the
+ solver. if not set, all available
+ materials to be recovered.""",
+ ),
+ 3: PinSpecification(
+ name="streams",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data.""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set.""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="coordinate_system_data1",
+ type_names=["generic_data_container"],
+ optional=False,
+ document="""""",
+ ),
+ 1: PinSpecification(
+ name="coordinate_system_data2",
+ type_names=["generic_data_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(
+ name="coordinate_systems_data_provider", server=server
+ )
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsCoordinateSystemDataProvider
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsCoordinateSystemDataProvider
+ """
+ return super().outputs
+
+
+class InputsCoordinateSystemDataProvider(_Inputs):
+ """Intermediate class used to connect user inputs to
+ coordinate_system_data_provider operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.coordinate_system_data_provider()
+ >>> my_solver_coordinate_system_ids = int()
+ >>> op.inputs.solver_coordinate_system_ids.connect(my_solver_coordinate_system_ids)
+ >>> my_streams = dpf.StreamsContainer()
+ >>> op.inputs.streams.connect(my_streams)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(coordinate_system_data_provider._spec().inputs, op)
+ self._solver_coordinate_system_ids = Input(
+ coordinate_system_data_provider._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._solver_coordinate_system_ids)
+ self._streams = Input(
+ coordinate_system_data_provider._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams)
+ self._data_sources = Input(
+ coordinate_system_data_provider._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+
+ @property
+ def solver_coordinate_system_ids(self):
+ """Allows to connect solver_coordinate_system_ids input to the operator.
+
+ Coorfinate system ids to recover used by the
+ solver. if not set, all available
+ materials to be recovered.
+
+ Parameters
+ ----------
+ my_solver_coordinate_system_ids : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.coordinate_system_data_provider()
+ >>> op.inputs.solver_coordinate_system_ids.connect(my_solver_coordinate_system_ids)
+ >>> # or
+ >>> op.inputs.solver_coordinate_system_ids(my_solver_coordinate_system_ids)
+ """
+ return self._solver_coordinate_system_ids
+
+ @property
+ def streams(self):
+ """Allows to connect streams input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data.
+
+ Parameters
+ ----------
+ my_streams : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.coordinate_system_data_provider()
+ >>> op.inputs.streams.connect(my_streams)
+ >>> # or
+ >>> op.inputs.streams(my_streams)
+ """
+ return self._streams
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set.
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.coordinate_system_data_provider()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+
+class OutputsCoordinateSystemDataProvider(_Outputs):
+ """Intermediate class used to get outputs from
+ coordinate_system_data_provider operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.coordinate_system_data_provider()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_coordinate_system_data1 = op.outputs.coordinate_system_data1()
+ >>> result_coordinate_system_data2 = op.outputs.coordinate_system_data2()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(coordinate_system_data_provider._spec().outputs, op)
+ self._coordinate_system_data1 = Output(
+ coordinate_system_data_provider._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._coordinate_system_data1)
+ self._coordinate_system_data2 = Output(
+ coordinate_system_data_provider._spec().output_pin(1), 1, op
+ )
+ self._outputs.append(self._coordinate_system_data2)
+
+ @property
+ def coordinate_system_data1(self):
+ """Allows to get coordinate_system_data1 output of the operator
+
+ Returns
+ ----------
+ my_coordinate_system_data1 : GenericDataContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.coordinate_system_data_provider()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_coordinate_system_data1 = op.outputs.coordinate_system_data1()
+ """ # noqa: E501
+ return self._coordinate_system_data1
+
+ @property
+ def coordinate_system_data2(self):
+ """Allows to get coordinate_system_data2 output of the operator
+
+ Returns
+ ----------
+ my_coordinate_system_data2 : GenericDataContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.coordinate_system_data_provider()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_coordinate_system_data2 = op.outputs.coordinate_system_data2()
+ """ # noqa: E501
+ return self._coordinate_system_data2
diff --git a/src/ansys/dpf/core/operators/metadata/element_types_provider.py b/src/ansys/dpf/core/operators/metadata/element_types_provider.py
new file mode 100644
index 00000000000..fd359a72795
--- /dev/null
+++ b/src/ansys/dpf/core/operators/metadata/element_types_provider.py
@@ -0,0 +1,312 @@
+"""
+element_types_provider
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class element_types_provider(Operator):
+ """Reads element types data from the result files contained in the
+ streams or data sources.
+
+ Parameters
+ ----------
+ solver_element_types_ids : int, optional
+ Element type ids to recover used by the
+ solver. if not set, all available
+ element types to be recovered.
+ streams : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data.
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set.
+
+ Returns
+ -------
+ element_types_data : GenericDataContainer
+ The generic_data_container has a class_name:
+ elementtypesproperties. it contains
+ the following property fields:
+ element_routine_number: element
+ routine number. e.g 186 for solid186,
+ keyopts: element type option keys,
+ kdofs: dof/node for this element
+ type.this is a bit mapping, nodelm:
+ number of nodes for this element
+ type, nodfor: number of nodes per
+ element having nodal forces, nodstr:
+ number of nodes per element having
+ nodal stresses, new_gen_element:
+ element of new generation.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.metadata.element_types_provider()
+
+ >>> # Make input connections
+ >>> my_solver_element_types_ids = int()
+ >>> op.inputs.solver_element_types_ids.connect(my_solver_element_types_ids)
+ >>> my_streams = dpf.StreamsContainer()
+ >>> op.inputs.streams.connect(my_streams)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.metadata.element_types_provider(
+ ... solver_element_types_ids=my_solver_element_types_ids,
+ ... streams=my_streams,
+ ... data_sources=my_data_sources,
+ ... )
+
+ >>> # Get output data
+ >>> result_element_types_data = op.outputs.element_types_data()
+ """
+
+ def __init__(
+ self,
+ solver_element_types_ids=None,
+ streams=None,
+ data_sources=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="element_types_provider", config=config, server=server)
+ self._inputs = InputsElementTypesProvider(self)
+ self._outputs = OutputsElementTypesProvider(self)
+ if solver_element_types_ids is not None:
+ self.inputs.solver_element_types_ids.connect(solver_element_types_ids)
+ if streams is not None:
+ self.inputs.streams.connect(streams)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+
+ @staticmethod
+ def _spec():
+ description = """Reads element types data from the result files contained in the
+ streams or data sources."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 1: PinSpecification(
+ name="solver_element_types_ids",
+ type_names=["int32", "vector"],
+ optional=True,
+ document="""Element type ids to recover used by the
+ solver. if not set, all available
+ element types to be recovered.""",
+ ),
+ 3: PinSpecification(
+ name="streams",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data.""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set.""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="element_types_data",
+ type_names=["generic_data_container"],
+ optional=False,
+ document="""The generic_data_container has a class_name:
+ elementtypesproperties. it contains
+ the following property fields:
+ element_routine_number: element
+ routine number. e.g 186 for solid186,
+ keyopts: element type option keys,
+ kdofs: dof/node for this element
+ type.this is a bit mapping, nodelm:
+ number of nodes for this element
+ type, nodfor: number of nodes per
+ element having nodal forces, nodstr:
+ number of nodes per element having
+ nodal stresses, new_gen_element:
+ element of new generation.""",
+ ),
+ },
+ )
+ 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="element_types_provider", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsElementTypesProvider
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsElementTypesProvider
+ """
+ return super().outputs
+
+
+class InputsElementTypesProvider(_Inputs):
+ """Intermediate class used to connect user inputs to
+ element_types_provider operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.element_types_provider()
+ >>> my_solver_element_types_ids = int()
+ >>> op.inputs.solver_element_types_ids.connect(my_solver_element_types_ids)
+ >>> my_streams = dpf.StreamsContainer()
+ >>> op.inputs.streams.connect(my_streams)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(element_types_provider._spec().inputs, op)
+ self._solver_element_types_ids = Input(
+ element_types_provider._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._solver_element_types_ids)
+ self._streams = Input(element_types_provider._spec().input_pin(3), 3, op, -1)
+ self._inputs.append(self._streams)
+ self._data_sources = Input(
+ element_types_provider._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+
+ @property
+ def solver_element_types_ids(self):
+ """Allows to connect solver_element_types_ids input to the operator.
+
+ Element type ids to recover used by the
+ solver. if not set, all available
+ element types to be recovered.
+
+ Parameters
+ ----------
+ my_solver_element_types_ids : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.element_types_provider()
+ >>> op.inputs.solver_element_types_ids.connect(my_solver_element_types_ids)
+ >>> # or
+ >>> op.inputs.solver_element_types_ids(my_solver_element_types_ids)
+ """
+ return self._solver_element_types_ids
+
+ @property
+ def streams(self):
+ """Allows to connect streams input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data.
+
+ Parameters
+ ----------
+ my_streams : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.element_types_provider()
+ >>> op.inputs.streams.connect(my_streams)
+ >>> # or
+ >>> op.inputs.streams(my_streams)
+ """
+ return self._streams
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set.
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.element_types_provider()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+
+class OutputsElementTypesProvider(_Outputs):
+ """Intermediate class used to get outputs from
+ element_types_provider operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.element_types_provider()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_element_types_data = op.outputs.element_types_data()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(element_types_provider._spec().outputs, op)
+ self._element_types_data = Output(
+ element_types_provider._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._element_types_data)
+
+ @property
+ def element_types_data(self):
+ """Allows to get element_types_data output of the operator
+
+ Returns
+ ----------
+ my_element_types_data : GenericDataContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.element_types_provider()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_element_types_data = op.outputs.element_types_data()
+ """ # noqa: E501
+ return self._element_types_data
diff --git a/src/ansys/dpf/core/operators/metadata/real_constants_provider.py b/src/ansys/dpf/core/operators/metadata/real_constants_provider.py
new file mode 100644
index 00000000000..78efd6d52c4
--- /dev/null
+++ b/src/ansys/dpf/core/operators/metadata/real_constants_provider.py
@@ -0,0 +1,315 @@
+"""
+real_constants_provider
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class real_constants_provider(Operator):
+ """Reads real constants from the result files contained in the streams or
+ data sources.
+
+ Parameters
+ ----------
+ solver_real_constants_ids : int, optional
+ Real constant ids to recover used by the
+ solver. if not set, all available
+ real constants to be recovered.
+ streams : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data.
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set.
+
+ Returns
+ -------
+ real_constants1 : Field
+ real_constants2 : Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.metadata.real_constants_provider()
+
+ >>> # Make input connections
+ >>> my_solver_real_constants_ids = int()
+ >>> op.inputs.solver_real_constants_ids.connect(my_solver_real_constants_ids)
+ >>> my_streams = dpf.StreamsContainer()
+ >>> op.inputs.streams.connect(my_streams)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.metadata.real_constants_provider(
+ ... solver_real_constants_ids=my_solver_real_constants_ids,
+ ... streams=my_streams,
+ ... data_sources=my_data_sources,
+ ... )
+
+ >>> # Get output data
+ >>> result_real_constants1 = op.outputs.real_constants1()
+ >>> result_real_constants2 = op.outputs.real_constants2()
+ """
+
+ def __init__(
+ self,
+ solver_real_constants_ids=None,
+ streams=None,
+ data_sources=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="real_constants_provider", config=config, server=server)
+ self._inputs = InputsRealConstantsProvider(self)
+ self._outputs = OutputsRealConstantsProvider(self)
+ if solver_real_constants_ids is not None:
+ self.inputs.solver_real_constants_ids.connect(solver_real_constants_ids)
+ if streams is not None:
+ self.inputs.streams.connect(streams)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+
+ @staticmethod
+ def _spec():
+ description = """Reads real constants from the result files contained in the streams or
+ data sources."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 1: PinSpecification(
+ name="solver_real_constants_ids",
+ type_names=["int32", "vector"],
+ optional=True,
+ document="""Real constant ids to recover used by the
+ solver. if not set, all available
+ real constants to be recovered.""",
+ ),
+ 3: PinSpecification(
+ name="streams",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data.""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set.""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="real_constants1",
+ type_names=["field"],
+ optional=False,
+ document="""""",
+ ),
+ 1: PinSpecification(
+ name="real_constants2",
+ type_names=["field"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="real_constants_provider", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsRealConstantsProvider
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsRealConstantsProvider
+ """
+ return super().outputs
+
+
+class InputsRealConstantsProvider(_Inputs):
+ """Intermediate class used to connect user inputs to
+ real_constants_provider operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.real_constants_provider()
+ >>> my_solver_real_constants_ids = int()
+ >>> op.inputs.solver_real_constants_ids.connect(my_solver_real_constants_ids)
+ >>> my_streams = dpf.StreamsContainer()
+ >>> op.inputs.streams.connect(my_streams)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(real_constants_provider._spec().inputs, op)
+ self._solver_real_constants_ids = Input(
+ real_constants_provider._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._solver_real_constants_ids)
+ self._streams = Input(real_constants_provider._spec().input_pin(3), 3, op, -1)
+ self._inputs.append(self._streams)
+ self._data_sources = Input(
+ real_constants_provider._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+
+ @property
+ def solver_real_constants_ids(self):
+ """Allows to connect solver_real_constants_ids input to the operator.
+
+ Real constant ids to recover used by the
+ solver. if not set, all available
+ real constants to be recovered.
+
+ Parameters
+ ----------
+ my_solver_real_constants_ids : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.real_constants_provider()
+ >>> op.inputs.solver_real_constants_ids.connect(my_solver_real_constants_ids)
+ >>> # or
+ >>> op.inputs.solver_real_constants_ids(my_solver_real_constants_ids)
+ """
+ return self._solver_real_constants_ids
+
+ @property
+ def streams(self):
+ """Allows to connect streams input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data.
+
+ Parameters
+ ----------
+ my_streams : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.real_constants_provider()
+ >>> op.inputs.streams.connect(my_streams)
+ >>> # or
+ >>> op.inputs.streams(my_streams)
+ """
+ return self._streams
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set.
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.real_constants_provider()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+
+class OutputsRealConstantsProvider(_Outputs):
+ """Intermediate class used to get outputs from
+ real_constants_provider operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.real_constants_provider()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_real_constants1 = op.outputs.real_constants1()
+ >>> result_real_constants2 = op.outputs.real_constants2()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(real_constants_provider._spec().outputs, op)
+ self._real_constants1 = Output(
+ real_constants_provider._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._real_constants1)
+ self._real_constants2 = Output(
+ real_constants_provider._spec().output_pin(1), 1, op
+ )
+ self._outputs.append(self._real_constants2)
+
+ @property
+ def real_constants1(self):
+ """Allows to get real_constants1 output of the operator
+
+ Returns
+ ----------
+ my_real_constants1 : Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.real_constants_provider()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_real_constants1 = op.outputs.real_constants1()
+ """ # noqa: E501
+ return self._real_constants1
+
+ @property
+ def real_constants2(self):
+ """Allows to get real_constants2 output of the operator
+
+ Returns
+ ----------
+ my_real_constants2 : Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.metadata.real_constants_provider()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_real_constants2 = op.outputs.real_constants2()
+ """ # noqa: E501
+ return self._real_constants2
diff --git a/src/ansys/dpf/core/operators/result/__init__.py b/src/ansys/dpf/core/operators/result/__init__.py
index 05261fd0f89..7ea819543e3 100644
--- a/src/ansys/dpf/core/operators/result/__init__.py
+++ b/src/ansys/dpf/core/operators/result/__init__.py
@@ -99,7 +99,13 @@
from .elastic_strain_YZ import elastic_strain_YZ
from .elastic_strain_Z import elastic_strain_Z
from .electric_field import electric_field
+from .electric_field_X import electric_field_X
+from .electric_field_Y import electric_field_Y
+from .electric_field_Z import electric_field_Z
from .electric_flux_density import electric_flux_density
+from .electric_flux_density_X import electric_flux_density_X
+from .electric_flux_density_Y import electric_flux_density_Y
+from .electric_flux_density_Z import electric_flux_density_Z
from .electric_potential import electric_potential
from .elemental_heat_generation import elemental_heat_generation
from .elemental_mass import elemental_mass
@@ -181,7 +187,13 @@
from .kinetic_energy import kinetic_energy
from .mach_number import mach_number
from .magnetic_field import magnetic_field
+from .magnetic_field_X import magnetic_field_X
+from .magnetic_field_Y import magnetic_field_Y
+from .magnetic_field_Z import magnetic_field_Z
from .magnetic_flux_density import magnetic_flux_density
+from .magnetic_flux_density_X import magnetic_flux_density_X
+from .magnetic_flux_density_Y import magnetic_flux_density_Y
+from .magnetic_flux_density_Z import magnetic_flux_density_Z
from .magnetic_scalar_potential import magnetic_scalar_potential
from .magnetic_vector_potential import magnetic_vector_potential
from .mapdl_material_properties import mapdl_material_properties
@@ -285,6 +297,9 @@
from .tangential_contact_moment import tangential_contact_moment
from .temperature import temperature
from .temperature_grad import temperature_grad
+from .temperature_grad_X import temperature_grad_X
+from .temperature_grad_Y import temperature_grad_Y
+from .temperature_grad_Z import temperature_grad_Z
from .thermal_conductivity import thermal_conductivity
from .thermal_dissipation_energy import thermal_dissipation_energy
from .thermal_strain import thermal_strain
diff --git a/src/ansys/dpf/core/operators/result/cyclic_expanded_heat_flux.py b/src/ansys/dpf/core/operators/result/cyclic_expanded_heat_flux.py
index 036f09a13c5..f6ecda5a511 100644
--- a/src/ansys/dpf/core/operators/result/cyclic_expanded_heat_flux.py
+++ b/src/ansys/dpf/core/operators/result/cyclic_expanded_heat_flux.py
@@ -12,7 +12,7 @@
class cyclic_expanded_heat_flux(Operator):
- """Read mapdl::rth::TF from an rst file and expand it with cyclic
+ """Read mapdl::rst::TF from an rst file and expand it with cyclic
symmetry.
Parameters
@@ -138,7 +138,7 @@ def __init__(
config=None,
server=None,
):
- super().__init__(name="mapdl::rth::TF_cyclic", config=config, server=server)
+ super().__init__(name="mapdl::rst::TF_cyclic", config=config, server=server)
self._inputs = InputsCyclicExpandedHeatFlux(self)
self._outputs = OutputsCyclicExpandedHeatFlux(self)
if time_scoping is not None:
@@ -172,7 +172,7 @@ def __init__(
@staticmethod
def _spec():
- description = """Read mapdl::rth::TF from an rst file and expand it with cyclic
+ description = """Read mapdl::rst::TF from an rst file and expand it with cyclic
symmetry."""
spec = Specification(
description=description,
@@ -303,7 +303,7 @@ def default_config(server=None):
Server with channel connected to the remote or local instance. When
``None``, attempts to use the global server.
"""
- return Operator.default_config(name="mapdl::rth::TF_cyclic", server=server)
+ return Operator.default_config(name="mapdl::rst::TF_cyclic", server=server)
@property
def inputs(self):
diff --git a/src/ansys/dpf/core/operators/result/cyclic_expanded_temperature.py b/src/ansys/dpf/core/operators/result/cyclic_expanded_temperature.py
index eca446d9713..efe19cbf06c 100644
--- a/src/ansys/dpf/core/operators/result/cyclic_expanded_temperature.py
+++ b/src/ansys/dpf/core/operators/result/cyclic_expanded_temperature.py
@@ -137,7 +137,7 @@ def __init__(
config=None,
server=None,
):
- super().__init__(name="mapdl::rth::TEMP_cyclic", config=config, server=server)
+ super().__init__(name="mapdl::rst::TEMP_cyclic", config=config, server=server)
self._inputs = InputsCyclicExpandedTemperature(self)
self._outputs = OutputsCyclicExpandedTemperature(self)
if time_scoping is not None:
@@ -303,7 +303,7 @@ def default_config(server=None):
Server with channel connected to the remote or local instance. When
``None``, attempts to use the global server.
"""
- return Operator.default_config(name="mapdl::rth::TEMP_cyclic", server=server)
+ return Operator.default_config(name="mapdl::rst::TEMP_cyclic", server=server)
@property
def inputs(self):
diff --git a/src/ansys/dpf/core/operators/result/electric_field_X.py b/src/ansys/dpf/core/operators/result/electric_field_X.py
new file mode 100644
index 00000000000..48baca6fa5b
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/electric_field_X.py
@@ -0,0 +1,653 @@
+"""
+electric_field_X
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class electric_field_X(Operator):
+ """Read/compute electric field X component of the vector (1st component)
+ by calling the readers defined by the datasources. Regarding the
+ requested location and the input mesh scoping, the result location
+ can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.electric_field_X()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.electric_field_X(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EFX", config=config, server=server)
+ self._inputs = InputsElectricFieldX(self)
+ self._outputs = OutputsElectricFieldX(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute electric field X component of the vector (1st component)
+ by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh
+ scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="EFX", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsElectricFieldX
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsElectricFieldX
+ """
+ return super().outputs
+
+
+class InputsElectricFieldX(_Inputs):
+ """Intermediate class used to connect user inputs to
+ electric_field_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_field_X._spec().inputs, op)
+ self._time_scoping = Input(electric_field_X._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(electric_field_X._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(electric_field_X._spec().input_pin(2), 2, op, -1)
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ electric_field_X._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(electric_field_X._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ electric_field_X._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(electric_field_X._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ electric_field_X._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(electric_field_X._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(electric_field_X._spec().input_pin(22), 22, op, -1)
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsElectricFieldX(_Outputs):
+ """Intermediate class used to get outputs from
+ electric_field_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_field_X._spec().outputs, op)
+ self._fields_container = Output(electric_field_X._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/electric_field_Y.py b/src/ansys/dpf/core/operators/result/electric_field_Y.py
new file mode 100644
index 00000000000..b501ff24fa4
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/electric_field_Y.py
@@ -0,0 +1,653 @@
+"""
+electric_field_Y
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class electric_field_Y(Operator):
+ """Read/compute electric field Y component of the vector (2nd component)
+ by calling the readers defined by the datasources. Regarding the
+ requested location and the input mesh scoping, the result location
+ can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.electric_field_Y()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.electric_field_Y(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EFY", config=config, server=server)
+ self._inputs = InputsElectricFieldY(self)
+ self._outputs = OutputsElectricFieldY(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute electric field Y component of the vector (2nd component)
+ by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh
+ scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="EFY", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsElectricFieldY
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsElectricFieldY
+ """
+ return super().outputs
+
+
+class InputsElectricFieldY(_Inputs):
+ """Intermediate class used to connect user inputs to
+ electric_field_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_field_Y._spec().inputs, op)
+ self._time_scoping = Input(electric_field_Y._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(electric_field_Y._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(electric_field_Y._spec().input_pin(2), 2, op, -1)
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ electric_field_Y._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(electric_field_Y._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ electric_field_Y._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(electric_field_Y._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ electric_field_Y._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(electric_field_Y._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(electric_field_Y._spec().input_pin(22), 22, op, -1)
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsElectricFieldY(_Outputs):
+ """Intermediate class used to get outputs from
+ electric_field_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_field_Y._spec().outputs, op)
+ self._fields_container = Output(electric_field_Y._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/electric_field_Z.py b/src/ansys/dpf/core/operators/result/electric_field_Z.py
new file mode 100644
index 00000000000..0dbc2c6e9f2
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/electric_field_Z.py
@@ -0,0 +1,653 @@
+"""
+electric_field_Z
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class electric_field_Z(Operator):
+ """Read/compute electric field Z component of the vector (3rd component)
+ by calling the readers defined by the datasources. Regarding the
+ requested location and the input mesh scoping, the result location
+ can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.electric_field_Z()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.electric_field_Z(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EFZ", config=config, server=server)
+ self._inputs = InputsElectricFieldZ(self)
+ self._outputs = OutputsElectricFieldZ(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute electric field Z component of the vector (3rd component)
+ by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh
+ scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="EFZ", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsElectricFieldZ
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsElectricFieldZ
+ """
+ return super().outputs
+
+
+class InputsElectricFieldZ(_Inputs):
+ """Intermediate class used to connect user inputs to
+ electric_field_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_field_Z._spec().inputs, op)
+ self._time_scoping = Input(electric_field_Z._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(electric_field_Z._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(electric_field_Z._spec().input_pin(2), 2, op, -1)
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ electric_field_Z._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(electric_field_Z._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ electric_field_Z._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(electric_field_Z._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ electric_field_Z._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(electric_field_Z._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(electric_field_Z._spec().input_pin(22), 22, op, -1)
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsElectricFieldZ(_Outputs):
+ """Intermediate class used to get outputs from
+ electric_field_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_field_Z._spec().outputs, op)
+ self._fields_container = Output(electric_field_Z._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_field_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/electric_flux_density_X.py b/src/ansys/dpf/core/operators/result/electric_flux_density_X.py
new file mode 100644
index 00000000000..ecd132ad55a
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/electric_flux_density_X.py
@@ -0,0 +1,667 @@
+"""
+electric_flux_density_X
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class electric_flux_density_X(Operator):
+ """Read/compute Electric flux density X component of the vector (1st
+ component) by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh scoping, the
+ result location can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.electric_flux_density_X()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.electric_flux_density_X(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EFDX", config=config, server=server)
+ self._inputs = InputsElectricFluxDensityX(self)
+ self._outputs = OutputsElectricFluxDensityX(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Electric flux density X component of the vector (1st
+ component) by calling the readers defined by the
+ datasources. Regarding the requested location and the
+ input mesh scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="EFDX", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsElectricFluxDensityX
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsElectricFluxDensityX
+ """
+ return super().outputs
+
+
+class InputsElectricFluxDensityX(_Inputs):
+ """Intermediate class used to connect user inputs to
+ electric_flux_density_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_flux_density_X._spec().inputs, op)
+ self._time_scoping = Input(
+ electric_flux_density_X._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ electric_flux_density_X._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ electric_flux_density_X._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ electric_flux_density_X._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ electric_flux_density_X._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ electric_flux_density_X._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(electric_flux_density_X._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ electric_flux_density_X._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(
+ electric_flux_density_X._spec().input_pin(14), 14, op, -1
+ )
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(
+ electric_flux_density_X._spec().input_pin(22), 22, op, -1
+ )
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsElectricFluxDensityX(_Outputs):
+ """Intermediate class used to get outputs from
+ electric_flux_density_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_flux_density_X._spec().outputs, op)
+ self._fields_container = Output(
+ electric_flux_density_X._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/electric_flux_density_Y.py b/src/ansys/dpf/core/operators/result/electric_flux_density_Y.py
new file mode 100644
index 00000000000..4d0c69a5b0d
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/electric_flux_density_Y.py
@@ -0,0 +1,667 @@
+"""
+electric_flux_density_Y
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class electric_flux_density_Y(Operator):
+ """Read/compute Electric flux density Y component of the vector (2nd
+ component) by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh scoping, the
+ result location can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.electric_flux_density_Y(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EFDY", config=config, server=server)
+ self._inputs = InputsElectricFluxDensityY(self)
+ self._outputs = OutputsElectricFluxDensityY(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Electric flux density Y component of the vector (2nd
+ component) by calling the readers defined by the
+ datasources. Regarding the requested location and the
+ input mesh scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="EFDY", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsElectricFluxDensityY
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsElectricFluxDensityY
+ """
+ return super().outputs
+
+
+class InputsElectricFluxDensityY(_Inputs):
+ """Intermediate class used to connect user inputs to
+ electric_flux_density_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_flux_density_Y._spec().inputs, op)
+ self._time_scoping = Input(
+ electric_flux_density_Y._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ electric_flux_density_Y._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ electric_flux_density_Y._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ electric_flux_density_Y._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ electric_flux_density_Y._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ electric_flux_density_Y._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(electric_flux_density_Y._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ electric_flux_density_Y._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(
+ electric_flux_density_Y._spec().input_pin(14), 14, op, -1
+ )
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(
+ electric_flux_density_Y._spec().input_pin(22), 22, op, -1
+ )
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsElectricFluxDensityY(_Outputs):
+ """Intermediate class used to get outputs from
+ electric_flux_density_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_flux_density_Y._spec().outputs, op)
+ self._fields_container = Output(
+ electric_flux_density_Y._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/electric_flux_density_Z.py b/src/ansys/dpf/core/operators/result/electric_flux_density_Z.py
new file mode 100644
index 00000000000..0e0be41756d
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/electric_flux_density_Z.py
@@ -0,0 +1,667 @@
+"""
+electric_flux_density_Z
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class electric_flux_density_Z(Operator):
+ """Read/compute Electric flux density Z component of the vector (3rd
+ component) by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh scoping, the
+ result location can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.electric_flux_density_Z(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="EFDZ", config=config, server=server)
+ self._inputs = InputsElectricFluxDensityZ(self)
+ self._outputs = OutputsElectricFluxDensityZ(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Electric flux density Z component of the vector (3rd
+ component) by calling the readers defined by the
+ datasources. Regarding the requested location and the
+ input mesh scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="EFDZ", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsElectricFluxDensityZ
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsElectricFluxDensityZ
+ """
+ return super().outputs
+
+
+class InputsElectricFluxDensityZ(_Inputs):
+ """Intermediate class used to connect user inputs to
+ electric_flux_density_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_flux_density_Z._spec().inputs, op)
+ self._time_scoping = Input(
+ electric_flux_density_Z._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ electric_flux_density_Z._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ electric_flux_density_Z._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ electric_flux_density_Z._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ electric_flux_density_Z._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ electric_flux_density_Z._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(electric_flux_density_Z._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ electric_flux_density_Z._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(
+ electric_flux_density_Z._spec().input_pin(14), 14, op, -1
+ )
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(
+ electric_flux_density_Z._spec().input_pin(22), 22, op, -1
+ )
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsElectricFluxDensityZ(_Outputs):
+ """Intermediate class used to get outputs from
+ electric_flux_density_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(electric_flux_density_Z._spec().outputs, op)
+ self._fields_container = Output(
+ electric_flux_density_Z._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.electric_flux_density_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/magnetic_field_X.py b/src/ansys/dpf/core/operators/result/magnetic_field_X.py
new file mode 100644
index 00000000000..97131fb60f3
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/magnetic_field_X.py
@@ -0,0 +1,653 @@
+"""
+magnetic_field_X
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class magnetic_field_X(Operator):
+ """Read/compute Magnetic Field X component of the vector (1st component)
+ by calling the readers defined by the datasources. Regarding the
+ requested location and the input mesh scoping, the result location
+ can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.magnetic_field_X()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.magnetic_field_X(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="MFX", config=config, server=server)
+ self._inputs = InputsMagneticFieldX(self)
+ self._outputs = OutputsMagneticFieldX(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Magnetic Field X component of the vector (1st component)
+ by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh
+ scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="MFX", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsMagneticFieldX
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsMagneticFieldX
+ """
+ return super().outputs
+
+
+class InputsMagneticFieldX(_Inputs):
+ """Intermediate class used to connect user inputs to
+ magnetic_field_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_field_X._spec().inputs, op)
+ self._time_scoping = Input(magnetic_field_X._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(magnetic_field_X._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(magnetic_field_X._spec().input_pin(2), 2, op, -1)
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ magnetic_field_X._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(magnetic_field_X._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ magnetic_field_X._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(magnetic_field_X._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ magnetic_field_X._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(magnetic_field_X._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(magnetic_field_X._spec().input_pin(22), 22, op, -1)
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsMagneticFieldX(_Outputs):
+ """Intermediate class used to get outputs from
+ magnetic_field_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_field_X._spec().outputs, op)
+ self._fields_container = Output(magnetic_field_X._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/magnetic_field_Y.py b/src/ansys/dpf/core/operators/result/magnetic_field_Y.py
new file mode 100644
index 00000000000..76f61b74c1a
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/magnetic_field_Y.py
@@ -0,0 +1,653 @@
+"""
+magnetic_field_Y
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class magnetic_field_Y(Operator):
+ """Read/compute Magnetic Field Y component of the vector (2nd component)
+ by calling the readers defined by the datasources. Regarding the
+ requested location and the input mesh scoping, the result location
+ can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.magnetic_field_Y()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.magnetic_field_Y(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="MFY", config=config, server=server)
+ self._inputs = InputsMagneticFieldY(self)
+ self._outputs = OutputsMagneticFieldY(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Magnetic Field Y component of the vector (2nd component)
+ by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh
+ scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="MFY", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsMagneticFieldY
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsMagneticFieldY
+ """
+ return super().outputs
+
+
+class InputsMagneticFieldY(_Inputs):
+ """Intermediate class used to connect user inputs to
+ magnetic_field_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_field_Y._spec().inputs, op)
+ self._time_scoping = Input(magnetic_field_Y._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(magnetic_field_Y._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(magnetic_field_Y._spec().input_pin(2), 2, op, -1)
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ magnetic_field_Y._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(magnetic_field_Y._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ magnetic_field_Y._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(magnetic_field_Y._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ magnetic_field_Y._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(magnetic_field_Y._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(magnetic_field_Y._spec().input_pin(22), 22, op, -1)
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsMagneticFieldY(_Outputs):
+ """Intermediate class used to get outputs from
+ magnetic_field_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_field_Y._spec().outputs, op)
+ self._fields_container = Output(magnetic_field_Y._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/magnetic_field_Z.py b/src/ansys/dpf/core/operators/result/magnetic_field_Z.py
new file mode 100644
index 00000000000..996c1ac01cb
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/magnetic_field_Z.py
@@ -0,0 +1,653 @@
+"""
+magnetic_field_Z
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class magnetic_field_Z(Operator):
+ """Read/compute Magnetic Field Z component of the vector (3rd component)
+ by calling the readers defined by the datasources. Regarding the
+ requested location and the input mesh scoping, the result location
+ can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.magnetic_field_Z()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.magnetic_field_Z(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="MFZ", config=config, server=server)
+ self._inputs = InputsMagneticFieldZ(self)
+ self._outputs = OutputsMagneticFieldZ(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Magnetic Field Z component of the vector (3rd component)
+ by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh
+ scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="MFZ", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsMagneticFieldZ
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsMagneticFieldZ
+ """
+ return super().outputs
+
+
+class InputsMagneticFieldZ(_Inputs):
+ """Intermediate class used to connect user inputs to
+ magnetic_field_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_field_Z._spec().inputs, op)
+ self._time_scoping = Input(magnetic_field_Z._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(magnetic_field_Z._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(magnetic_field_Z._spec().input_pin(2), 2, op, -1)
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ magnetic_field_Z._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(magnetic_field_Z._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ magnetic_field_Z._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(magnetic_field_Z._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ magnetic_field_Z._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(magnetic_field_Z._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(magnetic_field_Z._spec().input_pin(22), 22, op, -1)
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsMagneticFieldZ(_Outputs):
+ """Intermediate class used to get outputs from
+ magnetic_field_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_field_Z._spec().outputs, op)
+ self._fields_container = Output(magnetic_field_Z._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_field_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/magnetic_flux_density_X.py b/src/ansys/dpf/core/operators/result/magnetic_flux_density_X.py
new file mode 100644
index 00000000000..481d3ee4590
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/magnetic_flux_density_X.py
@@ -0,0 +1,667 @@
+"""
+magnetic_flux_density_X
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class magnetic_flux_density_X(Operator):
+ """Read/compute Magnetic Flux Density X component of the vector (1st
+ component) by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh scoping, the
+ result location can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.magnetic_flux_density_X(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="MFDX", config=config, server=server)
+ self._inputs = InputsMagneticFluxDensityX(self)
+ self._outputs = OutputsMagneticFluxDensityX(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Magnetic Flux Density X component of the vector (1st
+ component) by calling the readers defined by the
+ datasources. Regarding the requested location and the
+ input mesh scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="MFDX", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsMagneticFluxDensityX
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsMagneticFluxDensityX
+ """
+ return super().outputs
+
+
+class InputsMagneticFluxDensityX(_Inputs):
+ """Intermediate class used to connect user inputs to
+ magnetic_flux_density_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_flux_density_X._spec().inputs, op)
+ self._time_scoping = Input(
+ magnetic_flux_density_X._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ magnetic_flux_density_X._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ magnetic_flux_density_X._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ magnetic_flux_density_X._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ magnetic_flux_density_X._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ magnetic_flux_density_X._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(magnetic_flux_density_X._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ magnetic_flux_density_X._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(
+ magnetic_flux_density_X._spec().input_pin(14), 14, op, -1
+ )
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(
+ magnetic_flux_density_X._spec().input_pin(22), 22, op, -1
+ )
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsMagneticFluxDensityX(_Outputs):
+ """Intermediate class used to get outputs from
+ magnetic_flux_density_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_flux_density_X._spec().outputs, op)
+ self._fields_container = Output(
+ magnetic_flux_density_X._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/magnetic_flux_density_Y.py b/src/ansys/dpf/core/operators/result/magnetic_flux_density_Y.py
new file mode 100644
index 00000000000..b99d0f82e2e
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/magnetic_flux_density_Y.py
@@ -0,0 +1,667 @@
+"""
+magnetic_flux_density_Y
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class magnetic_flux_density_Y(Operator):
+ """Read/compute Magnetic Flux Density Y component of the vector (2nd
+ component) by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh scoping, the
+ result location can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.magnetic_flux_density_Y(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="MFDY", config=config, server=server)
+ self._inputs = InputsMagneticFluxDensityY(self)
+ self._outputs = OutputsMagneticFluxDensityY(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Magnetic Flux Density Y component of the vector (2nd
+ component) by calling the readers defined by the
+ datasources. Regarding the requested location and the
+ input mesh scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="MFDY", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsMagneticFluxDensityY
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsMagneticFluxDensityY
+ """
+ return super().outputs
+
+
+class InputsMagneticFluxDensityY(_Inputs):
+ """Intermediate class used to connect user inputs to
+ magnetic_flux_density_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_flux_density_Y._spec().inputs, op)
+ self._time_scoping = Input(
+ magnetic_flux_density_Y._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ magnetic_flux_density_Y._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ magnetic_flux_density_Y._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ magnetic_flux_density_Y._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ magnetic_flux_density_Y._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ magnetic_flux_density_Y._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(magnetic_flux_density_Y._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ magnetic_flux_density_Y._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(
+ magnetic_flux_density_Y._spec().input_pin(14), 14, op, -1
+ )
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(
+ magnetic_flux_density_Y._spec().input_pin(22), 22, op, -1
+ )
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsMagneticFluxDensityY(_Outputs):
+ """Intermediate class used to get outputs from
+ magnetic_flux_density_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_flux_density_Y._spec().outputs, op)
+ self._fields_container = Output(
+ magnetic_flux_density_Y._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/magnetic_flux_density_Z.py b/src/ansys/dpf/core/operators/result/magnetic_flux_density_Z.py
new file mode 100644
index 00000000000..075217ae303
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/magnetic_flux_density_Z.py
@@ -0,0 +1,667 @@
+"""
+magnetic_flux_density_Z
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class magnetic_flux_density_Z(Operator):
+ """Read/compute Magnetic Flux Density Z component of the vector (3rd
+ component) by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh scoping, the
+ result location can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.magnetic_flux_density_Z(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="MFDZ", config=config, server=server)
+ self._inputs = InputsMagneticFluxDensityZ(self)
+ self._outputs = OutputsMagneticFluxDensityZ(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Magnetic Flux Density Z component of the vector (3rd
+ component) by calling the readers defined by the
+ datasources. Regarding the requested location and the
+ input mesh scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="MFDZ", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsMagneticFluxDensityZ
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsMagneticFluxDensityZ
+ """
+ return super().outputs
+
+
+class InputsMagneticFluxDensityZ(_Inputs):
+ """Intermediate class used to connect user inputs to
+ magnetic_flux_density_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_flux_density_Z._spec().inputs, op)
+ self._time_scoping = Input(
+ magnetic_flux_density_Z._spec().input_pin(0), 0, op, -1
+ )
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(
+ magnetic_flux_density_Z._spec().input_pin(1), 1, op, -1
+ )
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ magnetic_flux_density_Z._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ magnetic_flux_density_Z._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(
+ magnetic_flux_density_Z._spec().input_pin(4), 4, op, -1
+ )
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ magnetic_flux_density_Z._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(magnetic_flux_density_Z._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ magnetic_flux_density_Z._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(
+ magnetic_flux_density_Z._spec().input_pin(14), 14, op, -1
+ )
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(
+ magnetic_flux_density_Z._spec().input_pin(22), 22, op, -1
+ )
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsMagneticFluxDensityZ(_Outputs):
+ """Intermediate class used to get outputs from
+ magnetic_flux_density_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(magnetic_flux_density_Z._spec().outputs, op)
+ self._fields_container = Output(
+ magnetic_flux_density_Z._spec().output_pin(0), 0, op
+ )
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.magnetic_flux_density_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/temperature_grad_X.py b/src/ansys/dpf/core/operators/result/temperature_grad_X.py
new file mode 100644
index 00000000000..cd778e776fc
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/temperature_grad_X.py
@@ -0,0 +1,655 @@
+"""
+temperature_grad_X
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class temperature_grad_X(Operator):
+ """Read/compute Temperature Gradient X component of the vector (1st
+ component) by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh scoping, the
+ result location can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.temperature_grad_X()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.temperature_grad_X(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="TGX", config=config, server=server)
+ self._inputs = InputsTemperatureGradX(self)
+ self._outputs = OutputsTemperatureGradX(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Temperature Gradient X component of the vector (1st
+ component) by calling the readers defined by the
+ datasources. Regarding the requested location and the
+ input mesh scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="TGX", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsTemperatureGradX
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsTemperatureGradX
+ """
+ return super().outputs
+
+
+class InputsTemperatureGradX(_Inputs):
+ """Intermediate class used to connect user inputs to
+ temperature_grad_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(temperature_grad_X._spec().inputs, op)
+ self._time_scoping = Input(temperature_grad_X._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(temperature_grad_X._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ temperature_grad_X._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ temperature_grad_X._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(temperature_grad_X._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ temperature_grad_X._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(temperature_grad_X._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ temperature_grad_X._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(temperature_grad_X._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(temperature_grad_X._spec().input_pin(22), 22, op, -1)
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsTemperatureGradX(_Outputs):
+ """Intermediate class used to get outputs from
+ temperature_grad_X operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(temperature_grad_X._spec().outputs, op)
+ self._fields_container = Output(temperature_grad_X._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_X()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/temperature_grad_Y.py b/src/ansys/dpf/core/operators/result/temperature_grad_Y.py
new file mode 100644
index 00000000000..d1affd4fd21
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/temperature_grad_Y.py
@@ -0,0 +1,655 @@
+"""
+temperature_grad_Y
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class temperature_grad_Y(Operator):
+ """Read/compute Temperature Gradient Y component of the vector (2nd
+ component) by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh scoping, the
+ result location can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.temperature_grad_Y()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.temperature_grad_Y(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="TGY", config=config, server=server)
+ self._inputs = InputsTemperatureGradY(self)
+ self._outputs = OutputsTemperatureGradY(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Temperature Gradient Y component of the vector (2nd
+ component) by calling the readers defined by the
+ datasources. Regarding the requested location and the
+ input mesh scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="TGY", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsTemperatureGradY
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsTemperatureGradY
+ """
+ return super().outputs
+
+
+class InputsTemperatureGradY(_Inputs):
+ """Intermediate class used to connect user inputs to
+ temperature_grad_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(temperature_grad_Y._spec().inputs, op)
+ self._time_scoping = Input(temperature_grad_Y._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(temperature_grad_Y._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ temperature_grad_Y._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ temperature_grad_Y._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(temperature_grad_Y._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ temperature_grad_Y._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(temperature_grad_Y._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ temperature_grad_Y._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(temperature_grad_Y._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(temperature_grad_Y._spec().input_pin(22), 22, op, -1)
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsTemperatureGradY(_Outputs):
+ """Intermediate class used to get outputs from
+ temperature_grad_Y operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(temperature_grad_Y._spec().outputs, op)
+ self._fields_container = Output(temperature_grad_Y._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Y()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/core/operators/result/temperature_grad_Z.py b/src/ansys/dpf/core/operators/result/temperature_grad_Z.py
new file mode 100644
index 00000000000..76961e47634
--- /dev/null
+++ b/src/ansys/dpf/core/operators/result/temperature_grad_Z.py
@@ -0,0 +1,655 @@
+"""
+temperature_grad_Z
+
+Autogenerated DPF operator classes.
+"""
+
+from warnings import warn
+from ansys.dpf.core.dpf_operator import Operator
+from ansys.dpf.core.inputs import Input, _Inputs
+from ansys.dpf.core.outputs import Output, _Outputs
+from ansys.dpf.core.operators.specification import PinSpecification, Specification
+
+
+class temperature_grad_Z(Operator):
+ """Read/compute Temperature Gradient Z component of the vector (3rd
+ component) by calling the readers defined by the datasources.
+ Regarding the requested location and the input mesh scoping, the
+ result location can be Nodal/ElementalNodal/Elemental.
+
+ Parameters
+ ----------
+ time_scoping : Scoping or int or float or Field, optional
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+ mesh_scoping : ScopingsContainer or Scoping, optional
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+ fields_container : FieldsContainer, optional
+ Fieldscontainer already allocated modified
+ inplace
+ streams_container : StreamsContainer, optional
+ Result file container allowed to be kept open
+ to cache data
+ data_sources : DataSources
+ Result file path container, used if no
+ streams are set
+ bool_rotate_to_global : bool, optional
+ If true the field is rotated to global
+ coordinate system (default true)
+ mesh : MeshedRegion or MeshesContainer, optional
+ Prevents from reading the mesh in the result
+ files
+ requested_location : str, optional
+ Requested location, default is nodal
+ read_cyclic : int, optional
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+ read_beams : bool, optional
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Returns
+ -------
+ fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+
+ >>> # Instantiate operator
+ >>> op = dpf.operators.result.temperature_grad_Z()
+
+ >>> # Make input connections
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+
+ >>> # Instantiate operator and connect inputs in one line
+ >>> op = dpf.operators.result.temperature_grad_Z(
+ ... time_scoping=my_time_scoping,
+ ... mesh_scoping=my_mesh_scoping,
+ ... fields_container=my_fields_container,
+ ... streams_container=my_streams_container,
+ ... data_sources=my_data_sources,
+ ... bool_rotate_to_global=my_bool_rotate_to_global,
+ ... mesh=my_mesh,
+ ... requested_location=my_requested_location,
+ ... read_cyclic=my_read_cyclic,
+ ... read_beams=my_read_beams,
+ ... )
+
+ >>> # Get output data
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(
+ self,
+ time_scoping=None,
+ mesh_scoping=None,
+ fields_container=None,
+ streams_container=None,
+ data_sources=None,
+ bool_rotate_to_global=None,
+ mesh=None,
+ requested_location=None,
+ read_cyclic=None,
+ read_beams=None,
+ config=None,
+ server=None,
+ ):
+ super().__init__(name="TGZ", config=config, server=server)
+ self._inputs = InputsTemperatureGradZ(self)
+ self._outputs = OutputsTemperatureGradZ(self)
+ if time_scoping is not None:
+ self.inputs.time_scoping.connect(time_scoping)
+ if mesh_scoping is not None:
+ self.inputs.mesh_scoping.connect(mesh_scoping)
+ if fields_container is not None:
+ self.inputs.fields_container.connect(fields_container)
+ if streams_container is not None:
+ self.inputs.streams_container.connect(streams_container)
+ if data_sources is not None:
+ self.inputs.data_sources.connect(data_sources)
+ if bool_rotate_to_global is not None:
+ self.inputs.bool_rotate_to_global.connect(bool_rotate_to_global)
+ if mesh is not None:
+ self.inputs.mesh.connect(mesh)
+ if requested_location is not None:
+ self.inputs.requested_location.connect(requested_location)
+ if read_cyclic is not None:
+ self.inputs.read_cyclic.connect(read_cyclic)
+ if read_beams is not None:
+ self.inputs.read_beams.connect(read_beams)
+
+ @staticmethod
+ def _spec():
+ description = """Read/compute Temperature Gradient Z component of the vector (3rd
+ component) by calling the readers defined by the
+ datasources. Regarding the requested location and the
+ input mesh scoping, the result location can be
+ Nodal/ElementalNodal/Elemental."""
+ spec = Specification(
+ description=description,
+ map_input_pin_spec={
+ 0: PinSpecification(
+ name="time_scoping",
+ type_names=[
+ "scoping",
+ "int32",
+ "vector",
+ "double",
+ "field",
+ "vector",
+ ],
+ optional=True,
+ document="""Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.""",
+ ),
+ 1: PinSpecification(
+ name="mesh_scoping",
+ type_names=["scopings_container", "scoping"],
+ optional=True,
+ document="""Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains""",
+ ),
+ 2: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=True,
+ document="""Fieldscontainer already allocated modified
+ inplace""",
+ ),
+ 3: PinSpecification(
+ name="streams_container",
+ type_names=["streams_container"],
+ optional=True,
+ document="""Result file container allowed to be kept open
+ to cache data""",
+ ),
+ 4: PinSpecification(
+ name="data_sources",
+ type_names=["data_sources"],
+ optional=False,
+ document="""Result file path container, used if no
+ streams are set""",
+ ),
+ 5: PinSpecification(
+ name="bool_rotate_to_global",
+ type_names=["bool"],
+ optional=True,
+ document="""If true the field is rotated to global
+ coordinate system (default true)""",
+ ),
+ 7: PinSpecification(
+ name="mesh",
+ type_names=["abstract_meshed_region", "meshes_container"],
+ optional=True,
+ document="""Prevents from reading the mesh in the result
+ files""",
+ ),
+ 9: PinSpecification(
+ name="requested_location",
+ type_names=["string"],
+ optional=True,
+ document="""Requested location, default is nodal""",
+ ),
+ 14: PinSpecification(
+ name="read_cyclic",
+ type_names=["enum dataProcessing::ECyclicReading", "int32"],
+ optional=True,
+ document="""If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)""",
+ ),
+ 22: PinSpecification(
+ name="read_beams",
+ type_names=["bool"],
+ optional=True,
+ document="""Elemental nodal beam results are read if this
+ pin is set to true (default is false)""",
+ ),
+ },
+ map_output_pin_spec={
+ 0: PinSpecification(
+ name="fields_container",
+ type_names=["fields_container"],
+ optional=False,
+ document="""""",
+ ),
+ },
+ )
+ return spec
+
+ @staticmethod
+ def default_config(server=None):
+ """Returns the default config of the operator.
+
+ This config can then be changed to the user needs and be used to
+ instantiate the operator. The Configuration allows to customize
+ how the operation will be processed by the operator.
+
+ Parameters
+ ----------
+ server : server.DPFServer, optional
+ Server with channel connected to the remote or local instance. When
+ ``None``, attempts to use the global server.
+ """
+ return Operator.default_config(name="TGZ", server=server)
+
+ @property
+ def inputs(self):
+ """Enables to connect inputs to the operator
+
+ Returns
+ --------
+ inputs : InputsTemperatureGradZ
+ """
+ return super().inputs
+
+ @property
+ def outputs(self):
+ """Enables to get outputs of the operator by evaluating it
+
+ Returns
+ --------
+ outputs : OutputsTemperatureGradZ
+ """
+ return super().outputs
+
+
+class InputsTemperatureGradZ(_Inputs):
+ """Intermediate class used to connect user inputs to
+ temperature_grad_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> my_time_scoping = dpf.Scoping()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> my_mesh_scoping = dpf.ScopingsContainer()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> my_fields_container = dpf.FieldsContainer()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> my_streams_container = dpf.StreamsContainer()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> my_data_sources = dpf.DataSources()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> my_bool_rotate_to_global = bool()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> my_mesh = dpf.MeshedRegion()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> my_requested_location = str()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> my_read_cyclic = int()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> my_read_beams = bool()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(temperature_grad_Z._spec().inputs, op)
+ self._time_scoping = Input(temperature_grad_Z._spec().input_pin(0), 0, op, -1)
+ self._inputs.append(self._time_scoping)
+ self._mesh_scoping = Input(temperature_grad_Z._spec().input_pin(1), 1, op, -1)
+ self._inputs.append(self._mesh_scoping)
+ self._fields_container = Input(
+ temperature_grad_Z._spec().input_pin(2), 2, op, -1
+ )
+ self._inputs.append(self._fields_container)
+ self._streams_container = Input(
+ temperature_grad_Z._spec().input_pin(3), 3, op, -1
+ )
+ self._inputs.append(self._streams_container)
+ self._data_sources = Input(temperature_grad_Z._spec().input_pin(4), 4, op, -1)
+ self._inputs.append(self._data_sources)
+ self._bool_rotate_to_global = Input(
+ temperature_grad_Z._spec().input_pin(5), 5, op, -1
+ )
+ self._inputs.append(self._bool_rotate_to_global)
+ self._mesh = Input(temperature_grad_Z._spec().input_pin(7), 7, op, -1)
+ self._inputs.append(self._mesh)
+ self._requested_location = Input(
+ temperature_grad_Z._spec().input_pin(9), 9, op, -1
+ )
+ self._inputs.append(self._requested_location)
+ self._read_cyclic = Input(temperature_grad_Z._spec().input_pin(14), 14, op, -1)
+ self._inputs.append(self._read_cyclic)
+ self._read_beams = Input(temperature_grad_Z._spec().input_pin(22), 22, op, -1)
+ self._inputs.append(self._read_beams)
+
+ @property
+ def time_scoping(self):
+ """Allows to connect time_scoping input to the operator.
+
+ Time/freq values (use doubles or field),
+ time/freq set ids (use ints or
+ scoping) or time/freq step ids (use
+ scoping with timefreq_steps location)
+ required in output. to specify
+ time/freq values at specific load
+ steps, put a field (and not a list)
+ in input with a scoping located on
+ "timefreq_steps". linear time freq
+ intrapolation is performed if the
+ values are not in the result files
+ and the data at the max time or freq
+ is taken when time/freqs are higher
+ than available time/freqs in result
+ files.
+
+ Parameters
+ ----------
+ my_time_scoping : Scoping or int or float or Field
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.time_scoping.connect(my_time_scoping)
+ >>> # or
+ >>> op.inputs.time_scoping(my_time_scoping)
+ """
+ return self._time_scoping
+
+ @property
+ def mesh_scoping(self):
+ """Allows to connect mesh_scoping input to the operator.
+
+ Nodes or elements scoping required in output.
+ the output fields will be scoped on
+ these node or element ids. to figure
+ out the ordering of the fields data,
+ look at their scoping ids as they
+ might not be ordered as the input
+ scoping was. the scoping's location
+ indicates whether nodes or elements
+ are asked for. using scopings
+ container allows you to split the
+ result fields container into domains
+
+ Parameters
+ ----------
+ my_mesh_scoping : ScopingsContainer or Scoping
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.mesh_scoping.connect(my_mesh_scoping)
+ >>> # or
+ >>> op.inputs.mesh_scoping(my_mesh_scoping)
+ """
+ return self._mesh_scoping
+
+ @property
+ def fields_container(self):
+ """Allows to connect fields_container input to the operator.
+
+ Fieldscontainer already allocated modified
+ inplace
+
+ Parameters
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.fields_container.connect(my_fields_container)
+ >>> # or
+ >>> op.inputs.fields_container(my_fields_container)
+ """
+ return self._fields_container
+
+ @property
+ def streams_container(self):
+ """Allows to connect streams_container input to the operator.
+
+ Result file container allowed to be kept open
+ to cache data
+
+ Parameters
+ ----------
+ my_streams_container : StreamsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.streams_container.connect(my_streams_container)
+ >>> # or
+ >>> op.inputs.streams_container(my_streams_container)
+ """
+ return self._streams_container
+
+ @property
+ def data_sources(self):
+ """Allows to connect data_sources input to the operator.
+
+ Result file path container, used if no
+ streams are set
+
+ Parameters
+ ----------
+ my_data_sources : DataSources
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.data_sources.connect(my_data_sources)
+ >>> # or
+ >>> op.inputs.data_sources(my_data_sources)
+ """
+ return self._data_sources
+
+ @property
+ def bool_rotate_to_global(self):
+ """Allows to connect bool_rotate_to_global input to the operator.
+
+ If true the field is rotated to global
+ coordinate system (default true)
+
+ Parameters
+ ----------
+ my_bool_rotate_to_global : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
+ >>> # or
+ >>> op.inputs.bool_rotate_to_global(my_bool_rotate_to_global)
+ """
+ return self._bool_rotate_to_global
+
+ @property
+ def mesh(self):
+ """Allows to connect mesh input to the operator.
+
+ Prevents from reading the mesh in the result
+ files
+
+ Parameters
+ ----------
+ my_mesh : MeshedRegion or MeshesContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.mesh.connect(my_mesh)
+ >>> # or
+ >>> op.inputs.mesh(my_mesh)
+ """
+ return self._mesh
+
+ @property
+ def requested_location(self):
+ """Allows to connect requested_location input to the operator.
+
+ Requested location, default is nodal
+
+ Parameters
+ ----------
+ my_requested_location : str
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.requested_location.connect(my_requested_location)
+ >>> # or
+ >>> op.inputs.requested_location(my_requested_location)
+ """
+ return self._requested_location
+
+ @property
+ def read_cyclic(self):
+ """Allows to connect read_cyclic input to the operator.
+
+ If 0 cyclic symmetry is ignored, if 1 cyclic
+ sector is read, if 2 cyclic expansion
+ is done, if 3 cyclic expansion is
+ done and stages are merged (default
+ is 1)
+
+ Parameters
+ ----------
+ my_read_cyclic : int
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+ >>> # or
+ >>> op.inputs.read_cyclic(my_read_cyclic)
+ """
+ return self._read_cyclic
+
+ @property
+ def read_beams(self):
+ """Allows to connect read_beams input to the operator.
+
+ Elemental nodal beam results are read if this
+ pin is set to true (default is false)
+
+ Parameters
+ ----------
+ my_read_beams : bool
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> op.inputs.read_beams.connect(my_read_beams)
+ >>> # or
+ >>> op.inputs.read_beams(my_read_beams)
+ """
+ return self._read_beams
+
+
+class OutputsTemperatureGradZ(_Outputs):
+ """Intermediate class used to get outputs from
+ temperature_grad_Z operator.
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """
+
+ def __init__(self, op: Operator):
+ super().__init__(temperature_grad_Z._spec().outputs, op)
+ self._fields_container = Output(temperature_grad_Z._spec().output_pin(0), 0, op)
+ self._outputs.append(self._fields_container)
+
+ @property
+ def fields_container(self):
+ """Allows to get fields_container output of the operator
+
+ Returns
+ ----------
+ my_fields_container : FieldsContainer
+
+ Examples
+ --------
+ >>> from ansys.dpf import core as dpf
+ >>> op = dpf.operators.result.temperature_grad_Z()
+ >>> # Connect inputs : op.inputs. ...
+ >>> result_fields_container = op.outputs.fields_container()
+ """ # noqa: E501
+ return self._fields_container
diff --git a/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll b/src/ansys/dpf/gatebin/Ans.Dpf.GrpcClient.dll
index d4ec333117e57c2edd38bbc69897803776ede8a3..1642ab0bc3ad2bc99bec2d1547a20de1b4c10d88 100644
GIT binary patch
delta 3257657
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